rostests/apitests/powrprof/power.c

   1 /*
   2  * PROJECT:         ReactOS api tests
   3  * LICENSE:         GPL - See COPYING in the top level directory
   4  * PURPOSE:         Tests for powrprof.dll
   5  * PROGRAMMER:      Alex Wurzinger
   6  *                  Johannes Anderwald
   7  *                  Martin Rottensteiner
   8  */
   9
  10 #include <stdarg.h>
  11 #include <ntstatus.h>
  12 #define WIN32_NO_STATUS
  13 #define STANDALONE
  14 #include <wine/test.h>
  15 #include <winreg.h>
  16 #include <powrprof.h>
  17
  18 /*
  19    LONG WINAPI RegOpenCurrentUser(REGSAM a,PHKEY b)
  20    {
  21       *b = HKEY_CURRENT_USER;
  22       return ERROR_SUCCESS;
  23    }
  24  */
  25 unsigned int g_NumPwrSchemes = 0;
  26 unsigned int g_NumPwrSchemesEnumerated = 0;
  27 unsigned int g_ActivePwrScheme = 3;
  28 unsigned int g_TempPwrScheme = 99;
  29
  30 POWER_POLICY g_PowerPolicy;
  31
  32 static const WCHAR szMachPowerPoliciesSubKey[] = { 'S', 'O', 'F', 'T', 'W', 'A', 'R',
  33                                                    'E', '\\', 'M', 'i', 'c', 'r', 'o', 's', 'o', 'f', 't', '\\', 'W', 'i', 'n', 'd',
  34                                                    'o', 'w', 's', '\\', 'C', 'u', 'r', 'r', 'e', 'n', 't', 'V', 'e', 'r', 's', 'i',
  35                                                    'o', 'n', '\\', 'C', 'o', 'n', 't', 'r', 'o', 'l', 's', ' ', 'F', 'o', 'l', 'd',
  36                                                    'e', 'r', '\\', 'P', 'o', 'w', 'e', 'r', 'C', 'f', 'g', '\\', 'P', 'o', 'w', 'e',
  37                                                    'r', 'P', 'o', 'l', 'i', 'c', 'i', 'e', 's', 0};
  38
  39 static const WCHAR szTempPwrScheme[] = { '9', '9', 0 };
  40
  41 void test_ValidatePowerPolicies_Next(PGLOBAL_POWER_POLICY pGPP_original,PPOWER_POLICY pPP_original);
  42
  43 void test_CallNtPowerInformation(void)
  44 {
  45    DWORD retval;
  46    ADMINISTRATOR_POWER_POLICY apolicy;
  47    ULONGLONG atime, ctime;
  48    PROCESSOR_POWER_INFORMATION ppi, *pppi;
  49    PROCESSOR_POWER_POLICY ppp;
  50    SYSTEM_BATTERY_STATE sbs;
  51    SYSTEM_POWER_CAPABILITIES spc;
  52    SYSTEM_POWER_INFORMATION spi;
  53    SYSTEM_POWER_POLICY spp;
  54    HANDLE x=NULL;
  55
  56    /* AdministratorPowerPolicy tests */
  57    retval = CallNtPowerInformation(AdministratorPowerPolicy, 0, 0, 0, 0);
  58    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
  59    retval = CallNtPowerInformation(AdministratorPowerPolicy, 0, 0, &apolicy, sizeof(ADMINISTRATOR_POWER_POLICY));
  60    ok(retval == STATUS_SUCCESS, "function expected STATUS_SUCCESS but got %d\n", (UINT)retval);
  61    retval = CallNtPowerInformation(AdministratorPowerPolicy, &apolicy, sizeof(ADMINISTRATOR_POWER_POLICY), 0, 0);
  62    ok(retval != STATUS_PRIVILEGE_NOT_HELD, "Privileg not held!!!! more errors to expect\n");
  63    ok(retval == STATUS_SUCCESS, "function expected STATUS_SUCCESS but got %d\n", (UINT)retval);
  64
  65    /* LastSleepTime tests */
  66    retval = CallNtPowerInformation(LastSleepTime, 0, 0, 0, 0);
  67    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
  68    retval = CallNtPowerInformation(LastSleepTime, &atime, sizeof(sizeof(ULONGLONG)), 0, 0);
  69    ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
  70    retval = CallNtPowerInformation(LastSleepTime, &atime, sizeof(ULONGLONG), &ctime, sizeof(ULONGLONG));
  71    ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
  72    retval = CallNtPowerInformation(LastSleepTime, 0, 0, &atime, sizeof(ULONGLONG));
  73    ok(retval == STATUS_SUCCESS, "function expected STATUS_SUCCESS but got %d\n",(UINT)retval);
  74
  75    /* LastWakeTime tests */
  76    retval = CallNtPowerInformation(LastWakeTime, 0, 0, 0, 0);
  77    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
  78    retval = CallNtPowerInformation(LastWakeTime, &atime, sizeof(sizeof(ULONGLONG)), 0, 0);
  79    ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
  80    retval = CallNtPowerInformation(LastWakeTime, &atime, sizeof(ULONGLONG), &ctime, sizeof(ULONGLONG));
  81    ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
  82    retval = CallNtPowerInformation(LastWakeTime, 0, 0, &atime, sizeof(ULONGLONG));
  83    ok(retval == STATUS_SUCCESS, "function expected STATUS_SUCCESS but got %d\n",(UINT)retval);
  84
  85    /* ProcessorInformation tests */
  86    retval = CallNtPowerInformation(ProcessorInformation, 0, 0, 0, 0);
  87    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
  88    retval = CallNtPowerInformation(ProcessorInformation, 0, 0, &ppi, sizeof(PROCESSOR_POWER_INFORMATION));
  89    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
  90    retval = CallNtPowerInformation(ProcessorInformation, &ppi, sizeof(PROCESSOR_POWER_INFORMATION), 0, 0);
  91    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
  92    retval = CallNtPowerInformation(ProcessorInformation, &ppi, sizeof(PROCESSOR_POWER_INFORMATION), &ppi, sizeof(PROCESSOR_POWER_INFORMATION));
  93
  94    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
  95    retval = CallNtPowerInformation(ProcessorInformation, 0, 0, &pppi, sizeof(PPROCESSOR_POWER_INFORMATION));
  96    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
  97    retval = CallNtPowerInformation(ProcessorInformation, &pppi, sizeof(PPROCESSOR_POWER_INFORMATION), 0, 0);
  98    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
  99    retval = CallNtPowerInformation(ProcessorInformation, &pppi, sizeof(PPROCESSOR_POWER_INFORMATION), &pppi, sizeof(PPROCESSOR_POWER_INFORMATION));
 100    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 101
 102    /* ProcessorPowerPolicyAc tests */
 103    retval = CallNtPowerInformation(ProcessorPowerPolicyAc, 0, 0, 0, 0);
 104    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 105    retval = CallNtPowerInformation(ProcessorPowerPolicyAc, 0, 0, &ppp, sizeof(PROCESSOR_POWER_POLICY));
 106    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 107    retval = CallNtPowerInformation(ProcessorPowerPolicyAc, &ppp, sizeof(PROCESSOR_POWER_POLICY), 0, 0);
 108    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 109    retval = CallNtPowerInformation(ProcessorPowerPolicyAc, &ppp, sizeof(PROCESSOR_POWER_POLICY), &ppp, sizeof(PROCESSOR_POWER_POLICY));
 110    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 111
 112    /* ProcessorPowerPolicyCurrent tests */
 113    retval = CallNtPowerInformation(ProcessorPowerPolicyCurrent, 0, 0, 0, 0);
 114    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 115    retval = CallNtPowerInformation(ProcessorPowerPolicyCurrent, 0, 0, &ppp, sizeof(PROCESSOR_POWER_POLICY));
 116    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 117    retval = CallNtPowerInformation(ProcessorPowerPolicyCurrent, &ppp, sizeof(PROCESSOR_POWER_POLICY), 0, 0);
 118    ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
 119    retval = CallNtPowerInformation(ProcessorPowerPolicyCurrent, &ppp, sizeof(PROCESSOR_POWER_POLICY), &ppp, sizeof(PROCESSOR_POWER_POLICY));
 120    ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
 121
 122    /* ProcessorPowerPolicyDc tests */
 123    retval = CallNtPowerInformation(ProcessorPowerPolicyDc, 0, 0, 0, 0);
 124    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 125    retval = CallNtPowerInformation(ProcessorPowerPolicyDc, 0, 0, &ppp, sizeof(PROCESSOR_POWER_POLICY));
 126    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 127    retval = CallNtPowerInformation(ProcessorPowerPolicyDc, &ppp, sizeof(PROCESSOR_POWER_POLICY), 0, 0);
 128    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 129    retval = CallNtPowerInformation(ProcessorPowerPolicyDc, &ppp, sizeof(PROCESSOR_POWER_POLICY), &ppp, sizeof(PROCESSOR_POWER_POLICY));
 130    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 131
 132    /* SystemBatteryState tests */
 133    retval = CallNtPowerInformation(SystemBatteryState, 0, 0, 0, 0);
 134    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 135    retval = CallNtPowerInformation(SystemBatteryState, 0, 0, &sbs, sizeof(SYSTEM_BATTERY_STATE));
 136    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 137    retval = CallNtPowerInformation(SystemBatteryState, &sbs, sizeof(SYSTEM_BATTERY_STATE), 0, 0);
 138    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 139    retval = CallNtPowerInformation(SystemBatteryState, &sbs, sizeof(SYSTEM_BATTERY_STATE), &sbs, sizeof(SYSTEM_BATTERY_STATE));
 140    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 141
 142    /* SystemExecutionState tests */
 143    retval = CallNtPowerInformation(SystemExecutionState, 0, 0, 0, 0);
 144    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 145
 146    /* SystemPowerCapabilities tests */
 147    retval = CallNtPowerInformation(SystemPowerCapabilities, 0, 0, 0, 0);
 148    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 149    retval = CallNtPowerInformation(SystemPowerCapabilities, 0, 0, &spc, sizeof(SYSTEM_POWER_CAPABILITIES));
 150    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 151    retval = CallNtPowerInformation(SystemPowerCapabilities, &spc, sizeof(SYSTEM_POWER_CAPABILITIES), 0, 0);
 152    ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
 153    retval = CallNtPowerInformation(SystemPowerCapabilities, &spc, sizeof(SYSTEM_POWER_CAPABILITIES), &spc, sizeof(SYSTEM_POWER_CAPABILITIES));
 154    ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
 155
 156    /* SystemPowerInformation tests */
 157    retval = CallNtPowerInformation(SystemPowerInformation, 0, 0, 0, 0);
 158    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 159    retval = CallNtPowerInformation(SystemPowerInformation, 0, 0, &spi, sizeof(SYSTEM_POWER_INFORMATION));
 160    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 161    retval = CallNtPowerInformation(SystemPowerInformation, &spi, sizeof(SYSTEM_POWER_INFORMATION), 0, 0);
 162    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 163    retval = CallNtPowerInformation(SystemPowerInformation, &spi, sizeof(SYSTEM_POWER_INFORMATION), &spi, sizeof(SYSTEM_POWER_INFORMATION));
 164    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 165    retval = CallNtPowerInformation(SystemPowerInformation, &spp, sizeof(SYSTEM_POWER_POLICY), 0, 0);
 166    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 167    retval = CallNtPowerInformation(SystemPowerInformation, &spp, sizeof(SYSTEM_POWER_POLICY), &spi, sizeof(SYSTEM_POWER_INFORMATION));
 168    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 169
 170    /* SystemPowerPolicyAc tests */
 171    retval = CallNtPowerInformation(SystemPowerPolicyAc, 0, 0, 0, 0);
 172    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 173    retval = CallNtPowerInformation(SystemPowerPolicyAc, 0, 0, &spp, sizeof(SYSTEM_POWER_POLICY));
 174    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 175    retval = CallNtPowerInformation(SystemPowerPolicyAc, &spp, sizeof(SYSTEM_POWER_POLICY), 0, 0);
 176    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 177    retval = CallNtPowerInformation(SystemPowerPolicyAc, &spp, sizeof(SYSTEM_POWER_POLICY), &spp, sizeof(SYSTEM_POWER_POLICY));
 178    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 179
 180    /* SystemPowerPolicyCurrent tests */
 181    retval = CallNtPowerInformation(SystemPowerPolicyCurrent, 0, 0, 0, 0);
 182    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 183    retval = CallNtPowerInformation(SystemPowerPolicyCurrent, 0, 0, &spp, sizeof(SYSTEM_POWER_POLICY));
 184    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 185    retval = CallNtPowerInformation(SystemPowerPolicyCurrent, &spp, sizeof(SYSTEM_POWER_POLICY), 0, 0);
 186    ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
 187    retval = CallNtPowerInformation(SystemPowerPolicyCurrent, &spp, sizeof(SYSTEM_POWER_POLICY), &spp, sizeof(SYSTEM_POWER_POLICY));
 188    ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
 189
 190    /* SystemPowerPolicyDc tests */
 191    retval = CallNtPowerInformation(SystemPowerPolicyDc, 0, 0, 0, 0);
 192    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 193    retval = CallNtPowerInformation(SystemPowerPolicyDc, 0, 0, &spp, sizeof(SYSTEM_POWER_POLICY));
 194    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 195    retval = CallNtPowerInformation(SystemPowerPolicyDc, &spp, sizeof(SYSTEM_POWER_POLICY), 0, 0);
 196    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 197    retval = CallNtPowerInformation(SystemPowerPolicyDc, &spp, sizeof(SYSTEM_POWER_POLICY), &spp, sizeof(SYSTEM_POWER_POLICY));
 198    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 199
 200    /* SystemReserveHiberFile tests */
 201 /*
 202    retval = CallNtPowerInformation(SystemReserveHiberFile, 0, 0, 0, 0);
 203    ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected STATUS_INVALID_PARAMETER but got %ld\n", retval);
 204    bln=TRUE;
 205    retval = CallNtPowerInformation(SystemReserveHiberFile, &bln, sizeof(bln), 0, 0);
 206    ok(retval == STATUS_DISK_FULL, "function result wrong expected STATUS_DISK_FULL but got %ld\n", nret);
 207    bln=FALSE;
 208    retval = CallNtPowerInformation(SystemReserveHiberFile, &bln, sizeof(bln), 0, 0);
 209    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %ld\n", nret);
 210
 211    bln2=TRUE;
 212    nret = CallNtPowerInformation(SystemReserveHiberFile, 0, 0, &bln2, sizeof(bln2));
 213    ok(nret == STATUS_DATATYPE_MISALIGNMENT, "function result wrong expected STATUS_DATATYPE_MISALIGNMENT but got %ld\n", nret);
 214    bln2=FALSE;
 215    nret = CallNtPowerInformation(SystemReserveHiberFile, 0, 0, &bln2, sizeof(bln2));
 216    ok(nret == STATUS_DATATYPE_MISALIGNMENT, "function result wrong expected STATUS_DATATYPE_MISALIGNMENT but got %ld\n", nret);
 217
 218    bln=TRUE;
 219    bln2=TRUE;
 220    nret = CallNtPowerInformation(SystemReserveHiberFile, &bln, sizeof(bln), &bln2, sizeof(bln2));
 221    ok(nret == STATUS_DATATYPE_MISALIGNMENT, "function result wrong expected STATUS_DATATYPE_MISALIGNMENT but got %ld\n", nret);
 222    bln2=FALSE;
 223    nret = CallNtPowerInformation(SystemReserveHiberFile, &bln, sizeof(bln), &bln2, sizeof(bln2));
 224    ok(nret == STATUS_DATATYPE_MISALIGNMENT, "function result wrong expected STATUS_DATATYPE_MISALIGNMENT but got %ld\n", nret);
 225    bln=FALSE;
 226    bln2=TRUE;
 227    nret = CallNtPowerInformation(SystemReserveHiberFile, &bln, sizeof(bln), &bln2, sizeof(bln2));
 228    ok(nret == STATUS_DATATYPE_MISALIGNMENT, "function result wrong expected STATUS_DATATYPE_MISALIGNMENT but got %ld\n", nret);
 229    bln2=FALSE;
 230    nret = CallNtPowerInformation(SystemReserveHiberFile, &bln, sizeof(bln), &bln2, sizeof(bln2));
 231    ok(nret == STATUS_DATATYPE_MISALIGNMENT, "function result wrong expected STATUS_DATATYPE_MISALIGNMENT but got %ld\n", nret);
 232  */
 233
 234    /* VerifyProcessorPowerPolicyAc tests */
 235    retval = CallNtPowerInformation(VerifyProcessorPowerPolicyAc, 0, 0, 0, 0);
 236    ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
 237    retval = CallNtPowerInformation(VerifyProcessorPowerPolicyAc, 0, 0, &ppp, sizeof(PROCESSOR_POWER_POLICY));
 238    ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
 239    retval = CallNtPowerInformation(VerifyProcessorPowerPolicyAc, &ppp, sizeof(PROCESSOR_POWER_POLICY), 0, 0);
 240    ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
 241    retval = CallNtPowerInformation(VerifyProcessorPowerPolicyAc, &ppp, sizeof(PROCESSOR_POWER_POLICY), &ppp, sizeof(PROCESSOR_POWER_POLICY));
 242    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 243
 244    /* VerifyProcessorPowerPolicyDc tests */
 245    retval = CallNtPowerInformation(VerifyProcessorPowerPolicyDc, 0, 0, 0, 0);
 246    ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
 247    retval = CallNtPowerInformation(VerifyProcessorPowerPolicyDc, 0, 0, &ppp, sizeof(PROCESSOR_POWER_POLICY));
 248    ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
 249    retval = CallNtPowerInformation(VerifyProcessorPowerPolicyDc, &ppp, sizeof(PROCESSOR_POWER_POLICY), 0, 0);
 250    ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
 251    retval = CallNtPowerInformation(VerifyProcessorPowerPolicyDc, &ppp, sizeof(PROCESSOR_POWER_POLICY), &ppp, sizeof(PROCESSOR_POWER_POLICY));
 252    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 253
 254    /* VerifySystemPolicyAc tests */
 255    retval = CallNtPowerInformation(VerifySystemPolicyAc, 0, 0, 0, 0);
 256    ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
 257    retval = CallNtPowerInformation(VerifySystemPolicyAc, 0, 0, &spp, sizeof(SYSTEM_POWER_POLICY));
 258    ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
 259    retval = CallNtPowerInformation(VerifySystemPolicyAc, &spp, sizeof(SYSTEM_POWER_POLICY), 0, 0);
 260    ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
 261    retval = CallNtPowerInformation(VerifySystemPolicyAc, &spp, sizeof(SYSTEM_POWER_POLICY), &spp, sizeof(SYSTEM_POWER_POLICY));
 262    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 263
 264    /* VerifySystemPolicyDc tests */
 265    retval = CallNtPowerInformation(VerifySystemPolicyDc, 0, 0, 0, 0);
 266    ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
 267    retval = CallNtPowerInformation(VerifySystemPolicyDc, 0, 0, &spp, sizeof(SYSTEM_POWER_POLICY));
 268    ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
 269    retval = CallNtPowerInformation(VerifySystemPolicyDc, &spp, sizeof(SYSTEM_POWER_POLICY), 0, 0);
 270    ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
 271    retval = CallNtPowerInformation(VerifySystemPolicyDc, &spp, sizeof(SYSTEM_POWER_POLICY), &spp, sizeof(SYSTEM_POWER_POLICY));
 272    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 273
 274    /* SystemPowerStateHandler tests */
 275    retval = CallNtPowerInformation(SystemPowerStateHandler, 0, 0, 0, 0);
 276    ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
 277    retval = CallNtPowerInformation(SystemPowerStateHandler, 0, 0, x, sizeof(HANDLE));
 278    ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
 279
 280    /* ProcessorStateHandler tests */
 281    retval = CallNtPowerInformation(ProcessorStateHandler, 0, 0, 0, 0);
 282    ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
 283    retval = CallNtPowerInformation(ProcessorStateHandler, 0, 0, x, sizeof(HANDLE));
 284    ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
 285
 286    /* ProcessorStateHandler2 tests */
 287    retval = CallNtPowerInformation(ProcessorStateHandler2, 0, 0, 0, 0);
 288    ok(retval == STATUS_ACCESS_DENIED, "function result wrong expected STATUS_ACCESS_DENIED but got %d\n", (UINT)retval);
 289    retval = CallNtPowerInformation(ProcessorStateHandler2, 0, 0, x, sizeof(HANDLE));
 290    ok(retval == STATUS_ACCESS_DENIED, "function result wrong expected STATUS_ACCESS_DENIED but got %d\n", (UINT)retval);
 291
 292    /* SystemPowerStateNotifyHandler tests */
 293    retval = CallNtPowerInformation(SystemPowerStateNotifyHandler, 0, 0, 0, 0);
 294    ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
 295    retval = CallNtPowerInformation(SystemPowerStateNotifyHandler, 0, 0, x, sizeof(HANDLE));
 296    ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
 297
 298 }
 299
 300 /*
 301    @implemented
 302  */
 303 void test_CanUserWritePwrScheme(void)
 304 {
 305    DWORD error, retval;
 306
 307    retval = CanUserWritePwrScheme();
 308
 309    error = GetLastError();
 310
 311    if (retval)
 312       ok(retval, "function failed?");
 313    else
 314       ok(error == ERROR_ACCESS_DENIED, "function last error wrong expected ERROR_ACCESS_DENIED but got %d\n", (UINT)error);
 315
 316 }
 317 BOOLEAN CALLBACK test_callback_EnumPwrScheme(UINT uiIndex, DWORD dwName, LPWSTR sName, DWORD dwDesc,
 318                                              LPWSTR sDesc, PPOWER_POLICY pp,LPARAM lParam )
 319 {
 320    ok(uiIndex == g_NumPwrSchemes, "expected power scheme index of %d but got %d\n", g_NumPwrSchemes, uiIndex);
 321    g_NumPwrSchemes++;
 322
 323    ok(lParam == 0xDEADBEEF, "expected function lParam to be 0xDEADBEEF but got %d\n", (UINT)lParam);
 324
 325    return TRUE;
 326 }
 327
 328 BOOLEAN CALLBACK test_callback_stop_EnumPwrScheme(UINT uiIndex, DWORD dwName, LPWSTR sName, DWORD dwDesc,
 329                                                   LPWSTR sDesc, PPOWER_POLICY pp,LPARAM lParam )
 330 {
 331    ok((!uiIndex || g_NumPwrSchemesEnumerated + 1 == uiIndex), "expected power scheme %d but got %d\n",g_NumPwrSchemesEnumerated+1, uiIndex);
 332    g_NumPwrSchemesEnumerated = uiIndex;
 333
 334    ok(uiIndex <= (UINT)lParam, "enumeration should have already been stopped at index %d current index %d\n", (UINT)lParam, uiIndex);
 335    if (uiIndex == (UINT)lParam)
 336       return FALSE;
 337    else
 338       return TRUE;
 339 }
 340
 341 void test_DeletePwrScheme(void)
 342 {
 343    DWORD retval;
 344    HKEY hSubKey = NULL;
 345
 346
 347    /*
 348     *  try inexistant profile number, should fail
 349     */
 350
 351    retval = DeletePwrScheme(0xFFFFFFFF);
 352    ok(!retval, "function should have failed error %x\n",(UINT)GetLastError());
 353
 354    /*
 355     *  delete active power scheme, should fail
 356     */
 357
 358    retval = GetActivePwrScheme(&g_ActivePwrScheme);
 359    ok(retval, "function was expected to succeed, error %x\n",(UINT)GetLastError());
 360
 361    retval = DeletePwrScheme(g_ActivePwrScheme);
 362    ok(!retval, "function should have failed\n");
 363    ok(GetLastError() == ERROR_ACCESS_DENIED, "function should have failed with ERROR_ACCESS_DENIED but got %x\n", (UINT)GetLastError());
 364
 365    /*
 366     * delete a temporarly created power scheme
 367     */
 368    retval = DeletePwrScheme(g_TempPwrScheme);
 369    ok(retval, "function should have succeeded\n");
 370
 371 /*
 372  *      clean up, delete illegal entry, witch was created for this test
 373  */
 374
 375    if (RegOpenKeyW(HKEY_LOCAL_MACHINE, szMachPowerPoliciesSubKey, &hSubKey) == ERROR_SUCCESS)
 376    {
 377       if (RegDeleteKeyW(hSubKey, szTempPwrScheme) != STATUS_SUCCESS)
 378          printf("#1 failed to delete subkey %i (testentry)\n", g_TempPwrScheme);
 379       RegCloseKey(hSubKey);
 380    }
 381
 382 }
 383
 384 void test_EnumPwrSchemes(void)
 385 {
 386    BOOLEAN retval;
 387
 388    /*
 389     * test EnumPwrScheme with null pointer callback
 390     */
 391
 392    retval = EnumPwrSchemes(0, 0);
 393    ok(!retval, "function was expected to fail\n");
 394    ok(GetLastError() == ERROR_INVALID_PARAMETER, "expected ERROR_INVALID_PARAMETER but got %x\n",(UINT)GetLastError());
 395
 396    /*
 397     * enumerate power schemes, should succeed
 398     */
 399
 400    retval = EnumPwrSchemes(test_callback_EnumPwrScheme, 0xDEADBEEF);
 401    ok(retval, "function was expected to succeed %d\n",retval);
 402    ok(g_NumPwrSchemes, "Warning: no power schemes available\n");
 403
 404    /*
 405     * stop enumeration after first power scheme
 406     */
 407
 408    retval = EnumPwrSchemes(test_callback_stop_EnumPwrScheme, (LPARAM)0);
 409    ok(!retval, "function was expected to false\n");
 410
 411    /*
 412     *  enumerate half of all avalailble profiles
 413     */
 414
 415    g_NumPwrSchemesEnumerated = 0;
 416    retval = EnumPwrSchemes(test_callback_stop_EnumPwrScheme, (LPARAM)g_NumPwrSchemes / 2);
 417    ok(retval, "function was expected to succeed but got %i\n", (UINT)retval);
 418    ok(g_NumPwrSchemesEnumerated == g_NumPwrSchemes / 2, "function did not enumerate requested num of profiles %d enumerated %d\n", g_NumPwrSchemes / 2, g_NumPwrSchemesEnumerated);
 419
 420
 421 }
 422
 423 void test_GetSetActivePwrScheme(void)
 424 {
 425    DWORD retval;
 426    UINT current_scheme = 2;
 427    UINT temp_scheme = 0;
 428
 429    /*
 430     * read active power scheme
 431     */
 432
 433    retval = GetActivePwrScheme(&g_ActivePwrScheme);
 434
 435    ok(retval, "function was expected to succeed, error %x\n",(UINT)GetLastError());
 436    ok(retval <= g_NumPwrSchemes, "expected index lower as power scheme count %d but got %d\n", g_NumPwrSchemes, g_ActivePwrScheme);
 437
 438    /*
 439     *  sets active power scheme to inexistant profile
 440     * -> corrupts power scheme enumeration on Windows XP SP2
 441     */
 442    //corrupts registry
 443    //retval = SetActivePwrScheme(0xFFFFFFFF, 0, 0);
 444    //ok(!retval, "function was expected to fail");
 445    //current_scheme = min(active_scheme+1, g_NumPwrSchemes-1);
 446
 447    /*
 448     * sets the active power scheme to profile with index 0
 449     */
 450
 451    retval = SetActivePwrScheme(current_scheme, 0, 0);
 452    ok(retval, "function was expected to succeed, error %x\n",(UINT)GetLastError());
 453
 454    /*
 455     *  read back the active power scheme
 456     */
 457
 458    retval = GetActivePwrScheme(&temp_scheme);
 459    ok(retval, "function was expected to succeed, error %x\n",(UINT)GetLastError());
 460    ok(temp_scheme == current_scheme, "expected %d but got %d\n", (UINT)current_scheme, (UINT)temp_scheme);
 461
 462    /*
 463     * restore previous active power scheme
 464     */
 465
 466    retval = SetActivePwrScheme(g_ActivePwrScheme, 0, 0);
 467    ok(retval, "Warning: failed to restore old active power scheme %d\n", (UINT)g_ActivePwrScheme);
 468 }
 469
 470 void test_GetCurrentPowerPolicies(void)
 471 {
 472    GLOBAL_POWER_POLICY gpp;
 473    POWER_POLICY pp;
 474    BOOLEAN ret;
 475    UINT current_scheme = 2;
 476
 477    g_ActivePwrScheme=3;
 478    ret = GetActivePwrScheme(&g_ActivePwrScheme);
 479
 480    ok(ret, "function was expected to succeed, error %x\n",(UINT)GetLastError());
 481    ret = SetActivePwrScheme(0, &gpp, 0);
 482
 483    ok(!ret, "function was expected to fail\n");
 484
 485    ret = SetActivePwrScheme(0, 0, &pp);
 486    ok(!ret, "function was expected to fail\n");
 487
 488    ret = SetActivePwrScheme(0, &gpp, &pp);
 489    ok(!ret, "function was expected to fail\n");
 490
 491    ret = SetActivePwrScheme(current_scheme, &gpp, 0);
 492    ok(!ret, "function was expected to fail\n");
 493
 494    ret = SetActivePwrScheme(current_scheme, 0, &pp);
 495    ok(!ret, "function was expected to fail\n");
 496
 497    ret = SetActivePwrScheme(current_scheme, &gpp, &pp);
 498    ok(!ret, "function was expected to fail\n");
 499
 500    ret = SetActivePwrScheme(g_ActivePwrScheme, 0, 0);
 501    ok(ret, "Warning: failed to restore old active power scheme %d\n", (UINT)g_ActivePwrScheme);
 502
 503    ret = GetCurrentPowerPolicies(0,0);
 504    ok(ret, "function was expected to succeed, error %x\n",(UINT)GetLastError());
 505
 506    ret = GetCurrentPowerPolicies(&gpp,0);
 507    ok(ret, "function was expected to succeed, error %x\n",(UINT)GetLastError());
 508
 509    ret = GetCurrentPowerPolicies(0,&pp);
 510    ok(ret, "function was expected to succeed, error %x\n",(UINT)GetLastError());
 511
 512    ret = GetCurrentPowerPolicies(&gpp,&pp);
 513    ok(ret, "function was expected to succeed, error %x\n",(UINT)GetLastError());
 514    ok(gpp.mach.Revision  == 1,"Global Mach Revision was expected to be 1 got %i\n",(UINT)gpp.mach.Revision);
 515    ok(gpp.user.Revision  == 1,"Global User Revision was expected to be 1 got %i\n",(UINT)gpp.mach.Revision);
 516    ok(pp.mach.Revision  == 1,"Mach Revision was expected to be 1 got %i\n",(UINT)gpp.mach.Revision);
 517    ok(pp.user.Revision  == 1,"User Revision was expected to be 1 got %i\n",(UINT)gpp.mach.Revision);
 518
 519
 520    ret = GetActivePwrScheme(&g_ActivePwrScheme);
 521    ok(ret, "function was expected to succeed, error %x\n",(UINT)GetLastError());
 522
 523    ret = SetActivePwrScheme(0, &gpp, 0);
 524    ok(ret, "function was expected to succeed, error %x\n",(UINT)GetLastError());
 525
 526    ret = SetActivePwrScheme(0, 0, &pp);
 527    ok(ret, "function was expected to succeed, error %x\n",(UINT)GetLastError());
 528
 529    ret = SetActivePwrScheme(0, &gpp, &pp);
 530    ok(ret, "function was expected to succeed, error %x\n",(UINT)GetLastError());
 531
 532    ret = SetActivePwrScheme(current_scheme, &gpp, 0);
 533    ok(ret, "function was expected to succeed, error %x\n",(UINT)GetLastError());
 534
 535    ret = SetActivePwrScheme(current_scheme, 0, &pp);
 536    ok(ret, "function was expected to succeed, error %x\n",(UINT)GetLastError());
 537
 538    ret = SetActivePwrScheme(current_scheme, &gpp, &pp);
 539    ok(ret, "function was expected to succeed, error %x\n",(UINT)GetLastError());
 540
 541    ret = SetActivePwrScheme(g_ActivePwrScheme, 0, 0);
 542    ok(ret, "Warning: failed to restore old active power scheme %d\n", (UINT)g_ActivePwrScheme);
 543
 544 }
 545
 546 void test_GetPwrCapabilities(void)
 547 {
 548    SYSTEM_POWER_CAPABILITIES spc;
 549    BOOLEAN ret;
 550
 551    ret = GetPwrCapabilities(0);
 552    ok(!ret, "function was expected to fail\n");
 553    if (!ret)
 554    {
 555       ok(GetLastError() == ERROR_INVALID_PARAMETER,"function was expectet to return ERROR_INVALID_PARAMETER, but returns: %x\n",(UINT)GetLastError());
 556    }
 557    ret = GetPwrCapabilities(&spc);
 558    ok(ret, "function was expected to succeed, error %x\n",(UINT)GetLastError());
 559 }
 560
 561 void test_GetPwrDiskSpindownRange(void)
 562 {
 563    DWORD retval;
 564    UINT min = 0;
 565    UINT max = 0;
 566
 567    /*
 568     *  invalid parameter checks
 569     */
 570
 571    retval = GetPwrDiskSpindownRange(NULL, NULL);
 572    ok(!retval, "function was expected to fail\n");
 573    ok(GetLastError() == ERROR_INVALID_PARAMETER, "expected error ERROR_INVALID_PARAMETER but got %x\n", (UINT)GetLastError());
 574
 575    retval = GetPwrDiskSpindownRange(&max, NULL);
 576    ok(!retval, "function was expected to fail\n");
 577    ok(GetLastError() == ERROR_INVALID_PARAMETER, "expected error ERROR_INVALID_PARAMETER but got %x\n", (UINT)GetLastError());
 578
 579    retval = GetPwrDiskSpindownRange(NULL, &min);
 580    ok(!retval, "function was expected to fail\n");
 581    ok(GetLastError() == ERROR_INVALID_PARAMETER, "expected error ERROR_INVALID_PARAMETER but got %x\n", (UINT)GetLastError());
 582
 583    /*
 584     * read disk spindown range
 585     */
 586
 587    retval = GetPwrDiskSpindownRange(&max, &min);
 588    ok(retval, "function was expected to succeed error %x\n",(UINT)GetLastError());
 589    ok(min <= max, "range mismatch min %d max %d\n",min, max);
 590 }
 591
 592 void test_IsAdminOverrideActive(void)
 593 {
 594    ADMINISTRATOR_POWER_POLICY app;
 595    BOOLEAN ret;
 596
 597    ret = IsAdminOverrideActive(0);
 598    ok(!ret, "function was expected to fail\n");
 599
 600    ret = IsAdminOverrideActive(&app);
 601    ok(!ret, "function was expected to fail\n");
 602
 603    app.MinSleep = 0;
 604    app.MaxSleep = 0;
 605    app.MinVideoTimeout = 0;
 606    app.MaxVideoTimeout = 0;
 607    app.MinSpindownTimeout = 0;
 608    app.MaxSpindownTimeout = 0;
 609
 610    ret = IsAdminOverrideActive(&app);
 611    ok(!ret, "function was expected to fail\n");
 612
 613    app.MinSleep = 1;
 614    app.MaxSleep = 2;
 615    app.MinVideoTimeout = 3;
 616    app.MaxVideoTimeout = 4;
 617    app.MinSpindownTimeout = 5;
 618    app.MaxSpindownTimeout = 6;
 619
 620    ret = IsAdminOverrideActive(&app);
 621    ok(!ret, "function was expected to fail\n");
 622
 623 }
 624
 625 void test_IsPwrHibernateAllowed(void)
 626 {
 627 /*
 628         BOOLEAN ret;
 629
 630         ret = IsPwrHibernateAllowed();
 631         ok(!ret, "function was expected to fail\n");
 632  */
 633 }
 634
 635 void test_IsPwrShutdownAllowed(void)
 636 {
 637 /*
 638         BOOLEAN ret;
 639
 640         ret = IsPwrShutdownAllowed();
 641         ok(ret, "function was expected to succeed, error %x\n",(UINT)GetLastError());
 642  */
 643 }
 644
 645 void test_IsPwrSuspendAllowed(void)
 646 {
 647 /*
 648         BOOLEAN ret;
 649
 650         ret = IsPwrSuspendAllowed();
 651         ok(ret, "function was expected to succed, error %x\n",(UINT)GetLastError());
 652  */
 653 }
 654
 655 void test_ReadGlobalPwrPolicy(void)
 656 {
 657    GLOBAL_POWER_POLICY gpp;
 658    BOOLEAN ret;
 659
 660    ret = ReadGlobalPwrPolicy(&gpp);
 661    ok(ret, "function was expected to succeed, error %x\n",(UINT)GetLastError());
 662    ok(gpp.mach.Revision  == 1,"Global Mach Revision was expected to be 1 got %i\n",(UINT)gpp.mach.Revision);
 663    ok(gpp.user.Revision  == 1,"Global User Revision was expected to be 1 got %i\n",(UINT)gpp.mach.Revision);
 664
 665
 666
 667 }
 668
 669 void test_ReadProcessorPwrScheme(void)
 670 {
 671    MACHINE_PROCESSOR_POWER_POLICY mppp;
 672    BOOLEAN ret;
 673    UINT i = 0;
 674    DWORD err;
 675
 676    do
 677    {
 678       RtlZeroMemory(&mppp, sizeof(MACHINE_PROCESSOR_POWER_POLICY));
 679       ret = ReadProcessorPwrScheme(i,&mppp);
 680       if (ret)
 681       {
 682          ok(mppp.Revision == 1,"Main Revision was expected to be 1 got %i\n",(UINT)mppp.Revision);
 683          ok(mppp.ProcessorPolicyAc.Revision == 1,"PowerAC Revision was expected to be 1 got %i\n",(UINT)mppp.ProcessorPolicyAc.Revision);
 684          ok(mppp.ProcessorPolicyDc.Revision == 1,"PowerDC Revision was expected to be 1 got %i\n",(UINT)mppp.ProcessorPolicyDc.Revision);
 685       }
 686       else
 687       {
 688          err = GetLastError();
 689          ok(err == 0,"Failed Error %x\n",(UINT)err);
 690          return;
 691       }
 692       i++;
 693       if (i == g_NumPwrSchemes)
 694          return;
 695    } while (TRUE);
 696
 697 }
 698
 699 void test_ReadPwrScheme(void)
 700 {
 701    DWORD retval;
 702
 703    /*
 704     * read power scheme with null pointer -> crashs on Windows XP SP2
 705     */
 706    //retval = ReadPwrScheme(0, NULL);
 707    //ok(!retval, "function was expected to fail\n");
 708    //ok(GetLastError() == STATUS_INVALID_PARAMETER, "expected error ... but got %x\n", GetLastError());
 709
 710    /*
 711     *  read a power scheme with an invalid index, leads to the creation of the key
 712     *  -> corrupts power scheme enumeration
 713     */
 714    //retval = ReadPwrScheme(0xFFFFFFFF, &powerPolicy);
 715    //ok(!retval, "function was expected to fail\n");
 716    //ok(GetLastError() == ERROR_ACCESS_DENIED, "expected error ERROR_ACCESS_DENIED but got %x\n", GetLastError());
 717
 718    /*
 719     * read current active power scheme
 720     */
 721
 722    retval = ReadPwrScheme(g_ActivePwrScheme, &g_PowerPolicy);
 723    ok(retval, "function was expected to succeed error %x\n",(UINT)GetLastError());
 724
 725 }
 726
 727 void test_SetSuspendState(void)
 728 {
 729 //      SetSuspendState(FALSE,FALSE,FALSE)
 730 }
 731
 732
 733 BOOLEAN globalcompare(GLOBAL_POWER_POLICY gpp, GLOBAL_POWER_POLICY gpp_compare)
 734 {
 735         //return TRUE;
 736         int i,j;
 737         BOOLEAN ret;
 738
 739         ret = TRUE;
 740         if (gpp.mach.BroadcastCapacityResolution != gpp_compare.mach.BroadcastCapacityResolution)
 741         {
 742                 printf("mach.BroadcastCapacityResolution failed %i != %i\n",gpp.mach.BroadcastCapacityResolution,gpp_compare.mach.BroadcastCapacityResolution);
 743                 ret = FALSE;
 744         }
 745         if (gpp.mach.LidOpenWakeAc != gpp_compare.mach.LidOpenWakeAc)
 746         {
 747                 printf("mach.LidOpenWakeAc failed %i != %i\n",gpp.mach.LidOpenWakeAc,gpp_compare.mach.LidOpenWakeAc);
 748                 ret = FALSE;
 749         }
 750         if (gpp.mach.LidOpenWakeDc != gpp_compare.mach.LidOpenWakeDc)
 751         {
 752                 printf("mach.LidOpenWakeDc failed %i != %i\n",gpp.mach.LidOpenWakeDc,gpp_compare.mach.LidOpenWakeDc);
 753                 ret = FALSE;
 754         }
 755         if (gpp.mach.Revision != gpp_compare.mach.Revision)
 756         {
 757                 printf("mach.Revision failed %i != %i\n",gpp.mach.Revision,gpp_compare.mach.Revision);
 758                 ret = FALSE;
 759         }
 760
 761         if (gpp.user.PowerButtonAc.Action != gpp_compare.user.PowerButtonAc.Action)
 762         {
 763                 printf("user.PowerButtonAc.Action failed %i != %i\n",gpp.user.PowerButtonAc.Action,gpp_compare.user.PowerButtonAc.Action);
 764                 ret = FALSE;
 765         }
 766         if (gpp.user.PowerButtonAc.EventCode != gpp_compare.user.PowerButtonAc.EventCode)
 767         {
 768                 printf("user.PowerButtonAc.EventCode failed %i != %i\n",gpp.user.PowerButtonAc.EventCode,gpp_compare.user.PowerButtonAc.EventCode);
 769                 ret = FALSE;
 770         }
 771         if (gpp.user.PowerButtonAc.Flags != gpp_compare.user.PowerButtonAc.Flags)
 772         {
 773                 printf("user.PowerButtonAc.Flags failed %i != %i\n",gpp.user.PowerButtonAc.Flags,gpp_compare.user.PowerButtonAc.Flags);
 774                 ret = FALSE;
 775         }
 776         if (gpp.user.PowerButtonDc.Action != gpp_compare.user.PowerButtonDc.Action)
 777         {
 778                 printf("user.PowerButtonDc.Action failed %i != %i\n",gpp.user.PowerButtonDc.Action,gpp_compare.user.PowerButtonDc.Action);
 779                 ret = FALSE;
 780         }
 781         if (gpp.user.PowerButtonDc.EventCode != gpp_compare.user.PowerButtonDc.EventCode)
 782         {
 783                 printf("user.PowerButtonDc.EventCode failed %i != %i\n",gpp.user.PowerButtonDc.EventCode,gpp_compare.user.PowerButtonDc.EventCode);
 784                 ret = FALSE;
 785         }
 786         if (gpp.user.PowerButtonDc.Flags != gpp_compare.user.PowerButtonDc.Flags)
 787         {
 788                 printf("user.PowerButtonDc.Flags failed %i != %i\n",gpp.user.PowerButtonDc.Flags,gpp_compare.user.PowerButtonDc.Flags);
 789                 ret = FALSE;
 790         }
 791     if (gpp.user.SleepButtonAc.Action != gpp_compare.user.SleepButtonAc.Action)
 792         {
 793                 printf("user.SleepButtonAc.Action failed %i != %i\n",gpp.user.SleepButtonAc.Action,gpp_compare.user.SleepButtonAc.Action);
 794                 ret = FALSE;
 795         }
 796         if (gpp.user.SleepButtonAc.EventCode != gpp_compare.user.SleepButtonAc.EventCode)
 797         {
 798                 printf("user.SleepButtonAc.EventCode failed %i != %i\n",gpp.user.SleepButtonAc.EventCode,gpp_compare.user.SleepButtonAc.EventCode);
 799                 ret = FALSE;
 800         }
 801         if (gpp.user.SleepButtonAc.Flags != gpp_compare.user.SleepButtonAc.Flags)
 802         {
 803                 printf("user.SleepButtonAc.Flags failed %i != %i\n",gpp.user.SleepButtonAc.Flags,gpp_compare.user.SleepButtonAc.Flags);
 804                 ret = FALSE;
 805         }
 806         if (gpp.user.SleepButtonDc.Action != gpp_compare.user.SleepButtonDc.Action)
 807         {
 808                 printf("user.SleepButtonDc.Action failed %i != %i\n",gpp.user.SleepButtonDc.Action,gpp_compare.user.SleepButtonDc.Action);
 809                 ret = FALSE;
 810         }
 811         if (gpp.user.SleepButtonDc.EventCode != gpp_compare.user.SleepButtonDc.EventCode)
 812         {
 813                 printf("user.SleepButtonDc.EventCode failed %i != %i\n",gpp.user.SleepButtonDc.EventCode,gpp_compare.user.SleepButtonDc.EventCode);
 814                 ret = FALSE;
 815         }
 816         if (gpp.user.SleepButtonDc.Flags != gpp_compare.user.SleepButtonDc.Flags)
 817         {
 818                 printf("user.SleepButtonDc.Flags failed %i != %i\n",gpp.user.SleepButtonDc.Flags,gpp_compare.user.SleepButtonDc.Flags);
 819                 ret = FALSE;
 820         }
 821         if (gpp.user.LidCloseAc.Action != gpp_compare.user.LidCloseAc.Action)
 822         {
 823                 printf("user.LidCloseAc.Action failed %i != %i\n",gpp.user.LidCloseAc.Action,gpp_compare.user.LidCloseAc.Action);
 824                 ret = FALSE;
 825         }
 826         if (gpp.user.LidCloseAc.EventCode != gpp_compare.user.LidCloseAc.EventCode)
 827         {
 828                 printf("user.LidCloseAc.EventCode failed %i != %i\n",gpp.user.LidCloseAc.EventCode,gpp_compare.user.LidCloseAc.EventCode);
 829                 ret = FALSE;
 830         }
 831         if (gpp.user.LidCloseAc.Flags != gpp_compare.user.LidCloseAc.Flags)
 832         {
 833                 printf("user.LidCloseAc.Flags failed %i != %i\n",gpp.user.LidCloseAc.Flags,gpp_compare.user.LidCloseAc.Flags);
 834                 ret = FALSE;
 835         }
 836         if (gpp.user.LidCloseDc.Action != gpp_compare.user.LidCloseDc.Action)
 837         {
 838                 printf("user.LidCloseDc.Action failed %i != %i\n",gpp.user.LidCloseDc.Action,gpp_compare.user.LidCloseDc.Action);
 839                 ret = FALSE;
 840         }
 841         if (gpp.user.LidCloseDc.EventCode != gpp_compare.user.LidCloseDc.EventCode)
 842         {
 843                 printf("user.LidCloseDc.EventCode failed %i != %i\n",gpp.user.LidCloseDc.EventCode,gpp_compare.user.LidCloseDc.EventCode);
 844                 ret = FALSE;
 845         }
 846         if (gpp.user.LidCloseDc.Flags != gpp_compare.user.LidCloseDc.Flags)
 847         {
 848                 printf("user.LidCloseDc.Flags failed %i != %i\n",gpp.user.LidCloseDc.Flags,gpp_compare.user.LidCloseDc.Flags);
 849                 ret = FALSE;
 850         }
 851
 852         for(i=0;i<NUM_DISCHARGE_POLICIES;i++)
 853         {
 854                 if (gpp.user.DischargePolicy[i].Enable != gpp_compare.user.DischargePolicy[i].Enable)
 855                 {
 856                         printf("user.DischargePolicy(%i).Enable failed %i != %i\n",i, gpp.user.DischargePolicy[i].Enable,gpp_compare.user.DischargePolicy[i].Enable);
 857                     ret = FALSE;
 858                 }
 859                 for (j=0;j<3;j++)
 860                 {
 861                         if (gpp.user.DischargePolicy[i].Spare[j] != gpp_compare.user.DischargePolicy[i].Spare[j])
 862                         {
 863                                 printf("user.DischargePolicy(%i).Spare[j] failed %i != %i\n",i, gpp.user.DischargePolicy[i].Spare[j],gpp_compare.user.DischargePolicy[i].Spare[j]);
 864                                 ret = FALSE;
 865                         }
 866                 }
 867                 if (gpp.user.DischargePolicy[i].BatteryLevel != gpp_compare.user.DischargePolicy[i].BatteryLevel)
 868                 {
 869                         printf("user.DischargePolicy(%i).BatteryLevel failed %i != %i\n",i, gpp.user.DischargePolicy[i].BatteryLevel,gpp_compare.user.DischargePolicy[i].BatteryLevel);
 870                     ret = FALSE;
 871                 }
 872                 if (gpp.user.DischargePolicy[i].PowerPolicy.Action != gpp_compare.user.DischargePolicy[i].PowerPolicy.Action)
 873                 {
 874                         printf("user.DischargePolicy(%i).PowerPolicy.Action failed %i != %i\n",i, gpp.user.DischargePolicy[i].PowerPolicy.Action,gpp_compare.user.DischargePolicy[i].PowerPolicy.Action);
 875                     ret = FALSE;
 876                 }
 877                 if (gpp.user.DischargePolicy[i].PowerPolicy.Flags != gpp_compare.user.DischargePolicy[i].PowerPolicy.Flags)
 878                 {
 879                         printf("user.DischargePolicy(%i).PowerPolicy.Flags failed %i != %i\n",i, gpp.user.DischargePolicy[i].PowerPolicy.Flags,gpp_compare.user.DischargePolicy[i].PowerPolicy.Flags);
 880                     ret = FALSE;
 881                 }
 882                 if (gpp.user.DischargePolicy[i].PowerPolicy.EventCode != gpp_compare.user.DischargePolicy[i].PowerPolicy.EventCode)
 883                 {
 884                         printf("user.DischargePolicy(%i).PowerPolicy.EventCode failed %i != %i\n",i, gpp.user.DischargePolicy[i].PowerPolicy.EventCode,gpp_compare.user.DischargePolicy[i].PowerPolicy.EventCode);
 885                     ret = FALSE;
 886                 }
 887                 if (gpp.user.DischargePolicy[i].MinSystemState != gpp_compare.user.DischargePolicy[i].MinSystemState)
 888                 {
 889                         printf("user.DischargePolicy(%i).MinSystemState failed %i != %i\n",i, gpp.user.DischargePolicy[i].MinSystemState,gpp_compare.user.DischargePolicy[i].MinSystemState);
 890                     ret = FALSE;
 891                 }
 892         }
 893     if (gpp.user.GlobalFlags != gpp_compare.user.GlobalFlags)
 894         {
 895                 printf("user.GlobalFlags failed %i != %i\n",gpp.user.GlobalFlags,gpp_compare.user.GlobalFlags);
 896                 ret = FALSE;
 897         }
 898         if (gpp.user.Revision != gpp_compare.user.Revision)
 899         {
 900                 printf("user.Revision failed %i != %i\n",gpp.user.Revision,gpp_compare.user.Revision);
 901                 ret = FALSE;
 902         }
 903     return ret;
 904 }
 905 BOOLEAN compare(POWER_POLICY pp, POWER_POLICY pp_compare)
 906 {
 907         //return TRUE;
 908         BOOLEAN ret=TRUE;
 909
 910         if (pp.mach.DozeS4TimeoutAc != pp_compare.mach.DozeS4TimeoutAc)
 911         {
 912                 printf("mach.DozeS4TimeoutAc failed %i != %i\n",pp.mach.DozeS4TimeoutAc,pp_compare.mach.DozeS4TimeoutAc);
 913                 ret = FALSE;
 914         }
 915         if (pp.mach.DozeS4TimeoutDc != pp_compare.mach.DozeS4TimeoutDc)
 916         {
 917                 printf("mach.DozeS4TimeoutDc failed %i != %i\n",pp.mach.DozeS4TimeoutDc,pp_compare.mach.DozeS4TimeoutDc);
 918                 ret = FALSE;
 919         }
 920         if (pp.mach.MinSleepAc != pp_compare.mach.MinSleepAc)
 921         {
 922                 printf("mach.MinSleepAc failed %i != %i\n",pp.mach.MinSleepAc,pp_compare.mach.MinSleepAc);
 923                 ret = FALSE;
 924         }
 925         if (pp.mach.MinSleepDc != pp_compare.mach.MinSleepDc)
 926         {
 927                 printf("mach.MinSleepDc failed %i != %i\n",pp.mach.MinSleepDc,pp_compare.mach.MinSleepDc);
 928                 ret = FALSE;
 929         }
 930         if (pp.mach.DozeTimeoutAc != pp_compare.mach.DozeTimeoutAc)
 931         {
 932                 printf("mach.DozeTimeoutAc failed %i != %i\n",pp.mach.DozeTimeoutAc,pp_compare.mach.DozeTimeoutAc);
 933                 ret = FALSE;
 934         }
 935         if (pp.mach.DozeTimeoutDc != pp_compare.mach.DozeTimeoutDc)
 936         {
 937                 printf("mach.DozeTimeoutDc failed %i != %i\n",pp.mach.DozeTimeoutDc,pp_compare.mach.DozeTimeoutDc);
 938                 ret = FALSE;
 939         }
 940         if (pp.mach.ReducedLatencySleepAc != pp_compare.mach.ReducedLatencySleepAc)
 941         {
 942                 printf("mach.ReducedLatencySleepAc failed %i != %i\n",pp.mach.ReducedLatencySleepAc,pp_compare.mach.ReducedLatencySleepAc);
 943                 ret = FALSE;
 944         }
 945         if (pp.mach.ReducedLatencySleepDc != pp_compare.mach.ReducedLatencySleepDc)
 946         {
 947                 printf("mach.ReducedLatencySleepDc failed %i != %i\n",pp.mach.ReducedLatencySleepDc,pp_compare.mach.ReducedLatencySleepDc);
 948                 ret = FALSE;
 949         }
 950         if (pp.mach.MinThrottleAc != pp_compare.mach.MinThrottleAc)
 951         {
 952                 printf("mach.MinThrottleAc failed %i != %i\n",pp.mach.MinThrottleAc,pp_compare.mach.MinThrottleAc);
 953                 ret = FALSE;
 954         }
 955         if (pp.mach.MinThrottleDc != pp_compare.mach.MinThrottleDc)
 956         {
 957                 printf("mach.MinThrottleDc failed %i != %i\n",pp.mach.MinThrottleDc,pp_compare.mach.MinThrottleDc);
 958                 ret = FALSE;
 959         }
 960
 961         if (pp.mach.OverThrottledAc.Action != pp_compare.mach.OverThrottledAc.Action)
 962         {
 963                 printf("mach.OverThrottledAc.Action failed %i != %i\n",pp.mach.OverThrottledAc.Action,pp_compare.mach.OverThrottledAc.Action);
 964                 ret = FALSE;
 965         }
 966         if (pp.mach.OverThrottledAc.Flags != pp_compare.mach.OverThrottledAc.Flags)
 967         {
 968                 printf("mach.OverThrottledAc.Flags failed %i != %i\n",pp.mach.OverThrottledAc.Flags,pp_compare.mach.OverThrottledAc.Flags);
 969                 ret = FALSE;
 970         }
 971         if (pp.mach.OverThrottledAc.EventCode != pp_compare.mach.OverThrottledAc.EventCode)
 972         {
 973                 printf("mach.OverThrottledAc.EventCode failed %i != %i\n",pp.mach.OverThrottledAc.EventCode,pp_compare.mach.OverThrottledAc.EventCode);
 974                 ret = FALSE;
 975         }
 976         if (pp.mach.OverThrottledDc.Action != pp_compare.mach.OverThrottledDc.Action)
 977         {
 978                 printf("mach.OverThrottledDc.Action failed %i != %i\n",pp.mach.OverThrottledDc.Action,pp_compare.mach.OverThrottledDc.Action);
 979                 ret = FALSE;
 980         }
 981         if (pp.mach.OverThrottledDc.Flags != pp_compare.mach.OverThrottledDc.Flags)
 982         {
 983                 printf("mach.OverThrottledDc.Flags failed %i != %i\n",pp.mach.OverThrottledDc.Flags,pp_compare.mach.OverThrottledDc.Flags);
 984                 ret = FALSE;
 985         }
 986         if (pp.mach.OverThrottledDc.EventCode != pp_compare.mach.OverThrottledDc.EventCode)
 987         {
 988                 printf("mach.OverThrottledDc.EventCode failed %i != %i\n",pp.mach.OverThrottledDc.EventCode,pp_compare.mach.OverThrottledDc.EventCode);
 989                 ret = FALSE;
 990         }
 991
 992         if (pp.mach.pad1[0] != pp_compare.mach.pad1[0])
 993         {
 994                 printf("mach.pad1[0] failed %i != %i\n",pp.mach.pad1[0],pp_compare.mach.pad1[0]);
 995                 ret = FALSE;
 996         }
 997         if (pp.mach.pad1[1] != pp_compare.mach.pad1[1])
 998         {
 999                 printf("mach.pad1[1] failed %i != %i\n",pp.mach.pad1[1],pp_compare.mach.pad1[1]);
1000                 ret = FALSE;
1001         }
1002         if (pp.mach.pad1[2] != pp_compare.mach.pad1[2])
1003         {
1004                 printf("mach.pad1[2] failed %i != %i\n",pp.mach.pad1[2],pp_compare.mach.pad1[2]);
1005                 ret = FALSE;
1006         }
1007         if (pp.mach.Revision != pp_compare.mach.Revision)
1008         {
1009                 printf("mach.Revision failed %i != %i\n",pp.mach.Revision,pp_compare.mach.Revision);
1010                 ret = FALSE;
1011         }
1012
1013         if (pp.user.IdleAc.Action != pp_compare.user.IdleAc.Action)
1014         {
1015                 printf("user.IdleAc.Action failed %i != %i\n",pp.user.IdleAc.Action,pp_compare.user.IdleAc.Action);
1016                 ret = FALSE;
1017         }
1018         if (pp.user.IdleAc.Flags != pp_compare.user.IdleAc.Flags)
1019         {
1020                 printf("user.IdleAc.Flags failed %i != %i\n",pp.user.IdleAc.Flags,pp_compare.user.IdleAc.Flags);
1021                 ret = FALSE;
1022         }
1023         if (pp.user.IdleAc.EventCode != pp_compare.user.IdleAc.EventCode)
1024         {
1025                 printf("user.IdleAc.EventCode failed %i != %i\n",pp.user.IdleAc.EventCode,pp_compare.user.IdleAc.EventCode);
1026                 ret = FALSE;
1027         }
1028         if (pp.user.IdleDc.Action != pp_compare.user.IdleDc.Action)
1029         {
1030                 printf("user.IdleDc.Action failed %i != %i\n",pp.user.IdleDc.Action,pp_compare.user.IdleDc.Action);
1031                 ret = FALSE;
1032         }
1033         if (pp.user.IdleDc.Flags != pp_compare.user.IdleDc.Flags)
1034         {
1035                 printf("user.IdleDc.Flags failed %i != %i\n",pp.user.IdleDc.Flags,pp_compare.user.IdleDc.Flags);
1036                 ret = FALSE;
1037         }
1038         if (pp.user.IdleDc.EventCode != pp_compare.user.IdleDc.EventCode)
1039         {
1040                 printf("user.IdleDc.EventCode failed %i != %i\n",pp.user.IdleDc.EventCode,pp_compare.user.IdleDc.EventCode);
1041                 ret = FALSE;
1042         }
1043         if (pp.user.IdleTimeoutAc != pp_compare.user.IdleTimeoutAc)
1044         {
1045                 printf("user.IdleTimeoutAc failed %i != %i\n",pp.user.IdleTimeoutAc,pp_compare.user.IdleTimeoutAc);
1046                 ret = FALSE;
1047         }
1048         if (pp.user.IdleTimeoutDc != pp_compare.user.IdleTimeoutDc)
1049         {
1050                 printf("user.IdleTimeoutDc failed %i != %i\n",pp.user.IdleTimeoutDc,pp_compare.user.IdleTimeoutDc);
1051                 ret = FALSE;
1052         }
1053         if (pp.user.IdleSensitivityAc != pp_compare.user.IdleSensitivityAc)
1054         {
1055                 printf("user.IdleSensitivityAc failed %i != %i\n",pp.user.IdleSensitivityAc,pp_compare.user.IdleSensitivityAc);
1056                 ret = FALSE;
1057         }
1058         if (pp.user.IdleSensitivityDc != pp_compare.user.IdleSensitivityDc)
1059         {
1060                 printf("user.IdleSensitivityDc failed %i != %i\n",pp.user.IdleSensitivityDc,pp_compare.user.IdleSensitivityDc);
1061                 ret = FALSE;
1062         }
1063         if (pp.user.ThrottlePolicyAc != pp_compare.user.ThrottlePolicyAc)
1064         {
1065                 printf("user.ThrottlePolicyAc failed %i != %i\n",pp.user.ThrottlePolicyAc,pp_compare.user.ThrottlePolicyAc);
1066                 ret = FALSE;
1067         }
1068         if (pp.user.ThrottlePolicyDc != pp_compare.user.ThrottlePolicyDc)
1069         {
1070                 printf("user.ThrottlePolicyDc failed %i != %i\n",pp.user.ThrottlePolicyDc,pp_compare.user.ThrottlePolicyDc);
1071                 ret = FALSE;
1072         }
1073         if (pp.user.MaxSleepAc != pp_compare.user.MaxSleepAc)
1074         {
1075                 printf("user.MaxSleepAc failed %i != %i\n",pp.user.MaxSleepAc,pp_compare.user.MaxSleepAc);
1076                 ret = FALSE;
1077         }
1078         if (pp.user.MaxSleepDc != pp_compare.user.MaxSleepDc)
1079         {
1080                 printf("user.MaxSleepDc failed %i != %i\n",pp.user.MaxSleepDc,pp_compare.user.MaxSleepDc);
1081                 ret = FALSE;
1082         }
1083         if (pp.user.Reserved[0] != pp_compare.user.Reserved[0])
1084         {
1085                 printf("user.Reserved[0] failed %i != %i\n",pp.user.Reserved[0],pp_compare.user.Reserved[0]);
1086                 ret = FALSE;
1087         }
1088         if (pp.user.Reserved[1] != pp_compare.user.Reserved[1])
1089         {
1090                 printf("user.Reserved[1] failed %i != %i\n",pp.user.Reserved[1],pp_compare.user.Reserved[1]);
1091                 ret = FALSE;
1092         }
1093         if (pp.user.Reserved[2] != pp_compare.user.Reserved[2])
1094         {
1095                 printf("user.Reserved[2] failed %i != %i\n",pp.user.Reserved[2],pp_compare.user.Reserved[2]);
1096                 ret = FALSE;
1097         }
1098         if (pp.user.VideoTimeoutAc != pp_compare.user.VideoTimeoutAc)
1099         {
1100                 printf("user.VideoTimeoutAc failed %i != %i\n",pp.user.VideoTimeoutAc,pp_compare.user.VideoTimeoutAc);
1101                 ret = FALSE;
1102         }
1103         if (pp.user.VideoTimeoutDc != pp_compare.user.VideoTimeoutDc)
1104         {
1105                 printf("user.VideoTimeoutDc failed %i != %i\n",pp.user.VideoTimeoutDc,pp_compare.user.VideoTimeoutDc);
1106                 ret = FALSE;
1107         }
1108
1109         if (pp.user.SpindownTimeoutAc != pp_compare.user.SpindownTimeoutAc)
1110         {
1111                 printf("user.SpindownTimeoutAc failed %i != %i\n",pp.user.SpindownTimeoutAc,pp_compare.user.SpindownTimeoutAc);
1112                 ret = FALSE;
1113         }
1114         if (pp.user.SpindownTimeoutDc != pp_compare.user.SpindownTimeoutDc)
1115         {
1116                 printf("user.SpindownTimeoutDc failed %i != %i\n",pp.user.SpindownTimeoutDc,pp_compare.user.SpindownTimeoutDc);
1117                 ret = FALSE;
1118         }
1119         if (pp.user.OptimizeForPowerAc != pp_compare.user.OptimizeForPowerAc)
1120         {
1121                 printf("user.OptimizeForPowerAc failed %i != %i\n",pp.user.OptimizeForPowerAc,pp_compare.user.OptimizeForPowerAc);
1122                 ret = FALSE;
1123         }
1124         if (pp.user.OptimizeForPowerDc != pp_compare.user.OptimizeForPowerDc)
1125         {
1126                 printf("user.OptimizeForPowerDc failed %i != %i\n",pp.user.OptimizeForPowerDc,pp_compare.user.OptimizeForPowerDc);
1127                 ret = FALSE;
1128         }
1129         if (pp.user.FanThrottleToleranceAc != pp_compare.user.FanThrottleToleranceAc)
1130         {
1131                 printf("user.FanThrottleToleranceAc failed %i != %i\n",pp.user.FanThrottleToleranceAc,pp_compare.user.FanThrottleToleranceAc);
1132                 ret = FALSE;
1133         }
1134         if (pp.user.FanThrottleToleranceDc != pp_compare.user.FanThrottleToleranceDc)
1135         {
1136                 printf("user.FanThrottleToleranceDc failed %i != %i\n",pp.user.FanThrottleToleranceDc,pp_compare.user.FanThrottleToleranceDc);
1137                 ret = FALSE;
1138         }
1139         if (pp.user.ForcedThrottleAc != pp_compare.user.ForcedThrottleAc)
1140         {
1141                 printf("user.ForcedThrottleAc failed %i != %i\n",pp.user.ForcedThrottleAc,pp_compare.user.ForcedThrottleAc);
1142                 ret = FALSE;
1143         }
1144         if (pp.user.ForcedThrottleDc != pp_compare.user.ForcedThrottleDc)
1145         {
1146                 printf("user.ForcedThrottleDc failed %i != %i\n",pp.user.ForcedThrottleDc,pp_compare.user.ForcedThrottleDc);
1147                 ret = FALSE;
1148         }
1149         if (pp.user.Revision != pp_compare.user.Revision)
1150         {
1151                 printf("user.Revision failed %i != %i\n",pp.user.Revision,pp_compare.user.Revision);
1152                 ret = FALSE;
1153         }
1154
1155         return ret;
1156 }
1157
1158 void test_ValidatePowerPolicies_Old(void)
1159 {
1160    GLOBAL_POWER_POLICY gpp;
1161    POWER_POLICY pp;
1162    BOOLEAN ret;
1163
1164    RtlZeroMemory(&gpp, sizeof(GLOBAL_POWER_POLICY));
1165    RtlZeroMemory(&pp, sizeof(POWER_POLICY));
1166
1167    SetLastError(0);
1168    ret = ValidatePowerPolicies(0,0);
1169    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
1170
1171    ret = ValidatePowerPolicies(&gpp,0);
1172    ok(!ret, "function was expected to fail return %i\n",(UINT)ret);
1173    ok(GetLastError() == ERROR_REVISION_MISMATCH,"function was expected to fail with ERROR_REVISION_MISMATCH(%i,%i), but error :%i\n",(UINT)gpp.user.Revision,(UINT)gpp.mach.Revision,(UINT)GetLastError());
1174
1175    ret = ValidatePowerPolicies(0,&pp);
1176    ok(!ret, "function was expected to fail return %i\n",(UINT)ret);
1177    ok(GetLastError() == ERROR_REVISION_MISMATCH,"function was expected to fail with ERROR_REVISION_MISMATCH, but error :%i\n",(UINT)GetLastError());
1178
1179    ret = ValidatePowerPolicies(&gpp,&pp);
1180    ok(!ret, "function was expected to fail return %i\n",(UINT)ret);
1181    ok(GetLastError() == ERROR_REVISION_MISMATCH,"function was expected to fail with ERROR_REVISION_MISMATCH, but error :%i\n",(UINT)GetLastError());
1182
1183    gpp.user.Revision = 1;
1184    gpp.mach.Revision = 1;
1185
1186    ret = ValidatePowerPolicies(&gpp,0);
1187    ok(!ret, "function was expected to fail return %i\n",(UINT)ret);
1188    ok(GetLastError() == ERROR_GEN_FAILURE,"function was expected to fail with ERROR_GEN_FAILURE, but error :%i\n",(UINT)GetLastError());
1189
1190    gpp.mach.LidOpenWakeAc = PowerSystemWorking;
1191    gpp.mach.LidOpenWakeDc = PowerSystemWorking;
1192
1193    ret = ValidatePowerPolicies(&gpp,0);
1194    ok(ret, "function was expected to succeed return %i\n",(UINT)GetLastError());
1195
1196    gpp.user.PowerButtonAc.Action = PowerActionNone;
1197    gpp.user.PowerButtonDc.Action = PowerActionNone;
1198    gpp.user.SleepButtonAc.Action = PowerActionNone;
1199    gpp.user.SleepButtonDc.Action = PowerActionNone;
1200    gpp.user.LidCloseAc.Action = PowerActionNone;
1201    gpp.user.LidCloseDc.Action = PowerActionNone;
1202
1203    gpp.user.DischargePolicy[0].Enable=FALSE;
1204    gpp.user.DischargePolicy[1].Enable=FALSE;
1205    gpp.user.DischargePolicy[2].Enable=FALSE;
1206    gpp.user.DischargePolicy[3].Enable=FALSE;
1207    ret = ValidatePowerPolicies(&gpp,0);
1208    ok(ret, "function was expected to succeed return %i\n",(UINT)GetLastError());
1209    if (!ret)
1210    {
1211       ok(GetLastError() == ERROR_INVALID_DATA,"function was expected to fail with ERROR_INVALID_DATA, but error :%i\n",(UINT)GetLastError());
1212    }
1213
1214    pp.user.Revision = 1;
1215    pp.mach.Revision = 1;
1216
1217    ret = ValidatePowerPolicies(0,&pp);
1218    ok(!ret, "function was expected to fail return %i\n",(UINT)ret);
1219    ok(GetLastError() == ERROR_INVALID_DATA || GetLastError() == ERROR_GEN_FAILURE,"function was expected to fail with ERROR_GEN_FAILURE or ERROR_INVALID_DATA, but error :%i\n",(UINT)GetLastError());
1220
1221    pp.mach.MinSleepAc = PowerSystemWorking;
1222    pp.mach.MinSleepDc = PowerSystemWorking;
1223    pp.mach.ReducedLatencySleepAc = PowerSystemWorking;
1224    pp.mach.ReducedLatencySleepDc = PowerSystemWorking;
1225    pp.mach.OverThrottledAc.Action = PowerActionNone;
1226    pp.mach.OverThrottledDc.Action = PowerActionNone;
1227
1228    pp.user.IdleAc.Action = PowerActionWarmEject+1;
1229    pp.user.IdleDc.Action = PowerActionNone-1;
1230    pp.user.MaxSleepAc = PowerSystemMaximum+1;
1231    pp.user.MaxSleepDc = PowerSystemUnspecified;
1232
1233    ret = ValidatePowerPolicies(0,&pp);
1234    ok(!ret, "function was expected to fail return %i\n",(UINT)GetLastError());
1235    if (!ret)
1236    {
1237       ok(GetLastError() == ERROR_INVALID_DATA,"function was expected to fail with ERROR_INVALID_DATA, but error :%i\n",(UINT)GetLastError());
1238    }
1239
1240    pp.user.IdleAc.Action = PowerActionNone;
1241    pp.user.IdleDc.Action = PowerActionNone;
1242    pp.user.MaxSleepAc = PowerSystemWorking;
1243    pp.user.MaxSleepDc = PowerSystemWorking;
1244
1245    ret = ValidatePowerPolicies(0,&pp);
1246    ok(ret, "function was expected to succeed, error %i\n",(UINT)GetLastError());
1247    if (!ret)
1248    {
1249       ok(GetLastError() == ERROR_GEN_FAILURE,"function was expected to fail with ERROR_GEN_FAILURE, but error :%i\n",(UINT)GetLastError());
1250    }
1251
1252    ret = ValidatePowerPolicies(&gpp,&pp);
1253    ok(ret, "function was expected to succeed, error %i\n",(UINT)GetLastError());
1254    if (!ret)
1255    {
1256                 ok(GetLastError() == ERROR_GEN_FAILURE,"function was expected to fail with ERROR_GEN_FAILURE, but error :%i\n",(UINT)GetLastError());
1257    }
1258
1259
1260    ret = GetCurrentPowerPolicies(&gpp,&pp);
1261    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
1262
1263    ret = ValidatePowerPolicies(&gpp,0);
1264    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
1265
1266    ret = ValidatePowerPolicies(0,&pp);
1267    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
1268
1269    ret = ValidatePowerPolicies(&gpp,&pp);
1270    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
1271
1272 }
1273
1274 void test_ValidatePowerPolicies(void)
1275 {
1276    GLOBAL_POWER_POLICY gpp, gpp_compare, gpp_original;
1277    POWER_POLICY pp, pp_compare, pp_original;
1278    BOOLEAN ret;
1279
1280    RtlZeroMemory(&gpp_original, sizeof(GLOBAL_POWER_POLICY));
1281    RtlZeroMemory(&pp_original, sizeof(POWER_POLICY));
1282
1283         memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
1284     memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
1285    ok(compare(pp,pp_compare),"Difference Found\n");
1286
1287     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1288     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1289    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
1290
1291    SetLastError(0);
1292    ret = ValidatePowerPolicies(0,0);
1293    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
1294
1295     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1296     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1297    ret = ValidatePowerPolicies(&gpp,0);
1298    ok(!ret, "function was expected to fail\n");
1299    ok(GetLastError() == ERROR_REVISION_MISMATCH,"function was expected to fail with ERROR_REVISION_MISMATCH(%i,%i), but error :%i\n",(UINT)gpp.user.Revision,(UINT)gpp.mach.Revision,(UINT)GetLastError());
1300    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
1301
1302         memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
1303     memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
1304    ret = ValidatePowerPolicies(0,&pp);
1305    ok(!ret, "function was expected to fail\n");
1306    ok(GetLastError() == ERROR_REVISION_MISMATCH,"function was expected to fail with ERROR_REVISION_MISMATCH, but error :%i\n",(UINT)GetLastError());
1307    ok(compare(pp,pp_compare),"Difference Found\n");
1308
1309     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1310     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1311         memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
1312     memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
1313    ret = ValidatePowerPolicies(&gpp,&pp);
1314    ok(!ret, "function was expected to fail\n");
1315    ok(GetLastError() == ERROR_REVISION_MISMATCH,"function was expected to fail with ERROR_REVISION_MISMATCH, but error :%i\n",(UINT)GetLastError());
1316    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
1317    ok(compare(pp,pp_compare),"Difference Found\n");
1318
1319    gpp_original.user.Revision = 1;
1320     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1321     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1322    ret = ValidatePowerPolicies(&gpp,0);
1323    ok(!ret, "function was expected to fail\n");
1324    ok(GetLastError() == ERROR_REVISION_MISMATCH,"function was expected to fail with ERROR_REVISION_MISMATCH, but error :%i\n",(UINT)GetLastError());
1325    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
1326
1327    gpp_original.mach.Revision = 1;
1328     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1329     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1330    ret = ValidatePowerPolicies(&gpp,0);
1331    ok(!ret, "function was expected to fail\n");
1332    ok(GetLastError() == ERROR_GEN_FAILURE,"function was expected to fail with ERROR_GEN_FAILURE, but error :%i\n",(UINT)GetLastError());
1333    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
1334
1335    gpp_original.mach.LidOpenWakeAc = PowerSystemWorking;
1336     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1337     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1338    ret = ValidatePowerPolicies(&gpp,0);
1339    ok(!ret, "function was expected to fail\n");
1340    ok(GetLastError() == ERROR_GEN_FAILURE,"function was expected to fail with ERROR_GEN_FAILURE, but error :%i\n",(UINT)GetLastError());
1341    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
1342
1343    gpp_original.mach.LidOpenWakeDc = PowerSystemWorking;
1344     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1345     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1346    ret = ValidatePowerPolicies(&gpp,0);
1347    ok(ret, "function was expected to succeed, error %x\n",(UINT)GetLastError());
1348    gpp_compare.mach.BroadcastCapacityResolution=100;
1349    gpp_compare.user.DischargePolicy[1].PowerPolicy.EventCode = 65536;
1350    gpp_compare.user.DischargePolicy[2].PowerPolicy.EventCode = 131072;
1351    gpp_compare.user.DischargePolicy[3].PowerPolicy.EventCode = 196608;
1352    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
1353
1354    gpp_original.user.PowerButtonAc.Action = PowerActionNone;
1355     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1356     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1357    ret = ValidatePowerPolicies(&gpp,0);
1358    ok(ret, "function was expected to succeed return %i\n",(UINT)GetLastError());
1359    gpp_compare.mach.BroadcastCapacityResolution=100;
1360    gpp_compare.user.DischargePolicy[1].PowerPolicy.EventCode = 65536;
1361    gpp_compare.user.DischargePolicy[2].PowerPolicy.EventCode = 131072;
1362    gpp_compare.user.DischargePolicy[3].PowerPolicy.EventCode = 196608;
1363    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
1364
1365    gpp_original.user.PowerButtonDc.Action = PowerActionNone;
1366     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1367     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1368    ret = ValidatePowerPolicies(&gpp,0);
1369    ok(ret, "function was expected to succeed return %i\n",(UINT)GetLastError());
1370    gpp_compare.mach.BroadcastCapacityResolution=100;
1371    gpp_compare.user.DischargePolicy[1].PowerPolicy.EventCode = 65536;
1372    gpp_compare.user.DischargePolicy[2].PowerPolicy.EventCode = 131072;
1373    gpp_compare.user.DischargePolicy[3].PowerPolicy.EventCode = 196608;
1374    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
1375
1376    gpp_original.user.SleepButtonAc.Action = PowerActionNone;
1377     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1378     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1379    ret = ValidatePowerPolicies(&gpp,0);
1380    ok(ret, "function was expected to succeed return %i\n",(UINT)GetLastError());
1381    gpp_compare.mach.BroadcastCapacityResolution=100;
1382    gpp_compare.user.DischargePolicy[1].PowerPolicy.EventCode = 65536;
1383    gpp_compare.user.DischargePolicy[2].PowerPolicy.EventCode = 131072;
1384    gpp_compare.user.DischargePolicy[3].PowerPolicy.EventCode = 196608;
1385    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
1386
1387    gpp_original.user.SleepButtonDc.Action = PowerActionNone;
1388     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1389     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1390    ret = ValidatePowerPolicies(&gpp,0);
1391    ok(ret, "function was expected to succeed return %i\n",(UINT)GetLastError());
1392    gpp_compare.mach.BroadcastCapacityResolution=100;
1393    gpp_compare.user.DischargePolicy[1].PowerPolicy.EventCode = 65536;
1394    gpp_compare.user.DischargePolicy[2].PowerPolicy.EventCode = 131072;
1395    gpp_compare.user.DischargePolicy[3].PowerPolicy.EventCode = 196608;
1396    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
1397
1398    gpp_original.user.LidCloseAc.Action = PowerActionNone;
1399     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1400     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1401    ret = ValidatePowerPolicies(&gpp,0);
1402    ok(ret, "function was expected to succeed return %i\n",(UINT)GetLastError());
1403    gpp_compare.mach.BroadcastCapacityResolution=100;
1404    gpp_compare.user.DischargePolicy[1].PowerPolicy.EventCode = 65536;
1405    gpp_compare.user.DischargePolicy[2].PowerPolicy.EventCode = 131072;
1406    gpp_compare.user.DischargePolicy[3].PowerPolicy.EventCode = 196608;
1407    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
1408
1409    gpp_original.user.LidCloseDc.Action = PowerActionNone;
1410     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1411     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1412    ret = ValidatePowerPolicies(&gpp,0);
1413    ok(ret, "function was expected to succeed return %i\n",(UINT)GetLastError());
1414    gpp_compare.mach.BroadcastCapacityResolution=100;
1415    gpp_compare.user.DischargePolicy[1].PowerPolicy.EventCode = 65536;
1416    gpp_compare.user.DischargePolicy[2].PowerPolicy.EventCode = 131072;
1417    gpp_compare.user.DischargePolicy[3].PowerPolicy.EventCode = 196608;
1418    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
1419
1420    gpp_original.user.DischargePolicy[0].Enable=FALSE;
1421     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1422     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1423    ret = ValidatePowerPolicies(&gpp,0);
1424    ok(ret, "function was expected to succeed return %i\n",(UINT)GetLastError());
1425    gpp_compare.mach.BroadcastCapacityResolution=100;
1426    gpp_compare.user.DischargePolicy[1].PowerPolicy.EventCode = 65536;
1427    gpp_compare.user.DischargePolicy[2].PowerPolicy.EventCode = 131072;
1428    gpp_compare.user.DischargePolicy[3].PowerPolicy.EventCode = 196608;
1429    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
1430
1431    gpp_original.user.DischargePolicy[1].Enable=FALSE;
1432     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1433     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1434    ret = ValidatePowerPolicies(&gpp,0);
1435    ok(ret, "function was expected to succeed return %i\n",(UINT)GetLastError());
1436    gpp_compare.mach.BroadcastCapacityResolution=100;
1437    gpp_compare.user.DischargePolicy[1].PowerPolicy.EventCode = 65536;
1438    gpp_compare.user.DischargePolicy[2].PowerPolicy.EventCode = 131072;
1439    gpp_compare.user.DischargePolicy[3].PowerPolicy.EventCode = 196608;
1440    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
1441
1442    gpp_original.user.DischargePolicy[2].Enable=FALSE;
1443     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1444     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1445    ret = ValidatePowerPolicies(&gpp,0);
1446    ok(ret, "function was expected to succeed return %i\n",(UINT)GetLastError());
1447    gpp_compare.mach.BroadcastCapacityResolution=100;
1448    gpp_compare.user.DischargePolicy[1].PowerPolicy.EventCode = 65536;
1449    gpp_compare.user.DischargePolicy[2].PowerPolicy.EventCode = 131072;
1450    gpp_compare.user.DischargePolicy[3].PowerPolicy.EventCode = 196608;
1451    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
1452
1453    gpp_original.user.DischargePolicy[3].Enable=FALSE;
1454     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1455     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1456    ret = ValidatePowerPolicies(&gpp,0);
1457    ok(ret, "function was expected to succeed return %i\n",(UINT)GetLastError());
1458    gpp_compare.mach.BroadcastCapacityResolution=100;
1459    gpp_compare.user.DischargePolicy[1].PowerPolicy.EventCode = 65536;
1460    gpp_compare.user.DischargePolicy[2].PowerPolicy.EventCode = 131072;
1461    gpp_compare.user.DischargePolicy[3].PowerPolicy.EventCode = 196608;
1462    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
1463
1464    pp_original.user.Revision = 1;
1465         memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
1466     memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
1467    ret = ValidatePowerPolicies(0,&pp);
1468    ok(!ret, "function was expected to fail\n");
1469    ok(GetLastError() ==  ERROR_REVISION_MISMATCH,"function was expected to fail with  ERROR_REVISION_MISMATCH, but error :%i\n",(UINT)GetLastError());
1470    ok(compare(pp,pp_compare),"Difference Found\n");
1471
1472    pp_original.mach.Revision = 1;
1473         memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
1474     memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
1475    ret = ValidatePowerPolicies(0,&pp);
1476    ok(!ret, "function was expected to fail\n");
1477    ok(GetLastError() == ERROR_GEN_FAILURE,"function was expected to fail with ERROR_GEN_FAILURE, but error :%i\n",(UINT)GetLastError());
1478    ok(compare(pp,pp_compare),"Difference Found\n");
1479
1480    pp_original.mach.MinSleepAc = PowerSystemWorking;
1481         memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
1482     memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
1483    ret = ValidatePowerPolicies(0,&pp);
1484    ok(!ret, "function was expected to fail\n");
1485    ok(GetLastError() == ERROR_GEN_FAILURE,"function was expected to fail with ERROR_GEN_FAILURE, but error :%i\n",(UINT)GetLastError());
1486    ok(compare(pp,pp_compare),"Difference Found\n");
1487
1488    pp_original.mach.MinSleepDc = PowerSystemWorking;
1489         memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
1490     memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
1491    ret = ValidatePowerPolicies(0,&pp);
1492    ok(!ret, "function was expected to fail\n");
1493    ok(GetLastError() == ERROR_GEN_FAILURE,"function was expected to fail with ERROR_GEN_FAILURE, but error :%i\n",(UINT)GetLastError());
1494    ok(compare(pp,pp_compare),"Difference Found\n");
1495
1496    pp_original.mach.ReducedLatencySleepAc = PowerSystemWorking;
1497         memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
1498     memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
1499    ret = ValidatePowerPolicies(0,&pp);
1500    ok(!ret, "function was expected to fail\n");
1501    ok(GetLastError() == ERROR_GEN_FAILURE,"function was expected to fail with ERROR_GEN_FAILURE, but error :%i\n",(UINT)GetLastError());
1502    ok(compare(pp,pp_compare),"Difference Found\n");
1503
1504    pp_original.mach.ReducedLatencySleepDc = PowerSystemWorking;
1505         memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
1506     memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
1507    ret = ValidatePowerPolicies(0,&pp);
1508    ok(!ret, "function was expected to fail\n");
1509    ok(GetLastError() == ERROR_GEN_FAILURE,"function was expected to fail with ERROR_GEN_FAILURE, but error :%i\n",(UINT)GetLastError());
1510    ok(compare(pp,pp_compare),"Difference Found\n");
1511
1512    pp_original.mach.OverThrottledAc.Action = PowerActionNone;
1513         memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
1514     memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
1515    ret = ValidatePowerPolicies(0,&pp);
1516    ok(!ret, "function was expected to fail\n");
1517    ok(GetLastError() == ERROR_GEN_FAILURE,"function was expected to fail with ERROR_GEN_FAILURE, but error :%i\n",(UINT)GetLastError());
1518    ok(compare(pp,pp_compare),"Difference Found\n");
1519
1520    pp_original.mach.OverThrottledDc.Action = PowerActionNone;
1521         memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
1522     memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
1523    ret = ValidatePowerPolicies(0,&pp);
1524    ok(!ret, "function was expected to fail\n");
1525    ok(GetLastError() == ERROR_GEN_FAILURE,"function was expected to fail with ERROR_GEN_FAILURE, but error :%i\n",(UINT)GetLastError());
1526    ok(compare(pp,pp_compare),"Difference Found\n");
1527
1528    pp_original.user.IdleAc.Action = PowerActionWarmEject+1;
1529         memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
1530     memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
1531    ret = ValidatePowerPolicies(0,&pp);
1532    ok(!ret, "function was expected to fail\n");
1533    ok(GetLastError() == ERROR_INVALID_DATA,"function was expected to fail with ERROR_INVALID_DATA, but error :%i\n",(UINT)GetLastError());
1534    ok(compare(pp,pp_compare),"Difference Found\n");
1535
1536    pp_original.user.IdleDc.Action = PowerActionNone-1;
1537         memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
1538     memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
1539    ret = ValidatePowerPolicies(0,&pp);
1540    ok(!ret, "function was expected to fail\n");
1541    ok(GetLastError() == ERROR_INVALID_DATA,"function was expected to fail with ERROR_INVALID_DATA, but error :%i\n",(UINT)GetLastError());
1542    ok(compare(pp,pp_compare),"Difference Found\n");
1543
1544    pp_original.user.MaxSleepAc = PowerSystemMaximum+1;
1545         memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
1546     memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
1547    ret = ValidatePowerPolicies(0,&pp);
1548    ok(!ret, "function was expected to fail\n");
1549    ok(GetLastError() == ERROR_INVALID_DATA,"function was expected to fail with ERROR_INVALID_DATA, but error :%i\n",(UINT)GetLastError());
1550    ok(compare(pp,pp_compare),"Difference Found\n");
1551
1552    pp_original.user.MaxSleepDc = PowerSystemUnspecified;
1553         memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
1554     memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
1555    ret = ValidatePowerPolicies(0,&pp);
1556    ok(!ret, "function was expected to fail\n");
1557    ok(GetLastError() == ERROR_INVALID_DATA,"function was expected to fail with ERROR_INVALID_DATA, but error :%i\n",(UINT)GetLastError());
1558    ok(compare(pp,pp_compare),"Difference Found\n");
1559
1560    pp_original.user.IdleAc.Action = PowerActionNone;
1561         memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
1562     memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
1563    ret = ValidatePowerPolicies(0,&pp);
1564    ok(!ret, "function was expected to fail\n");
1565    ok(GetLastError() == ERROR_INVALID_DATA,"function was expected to fail with ERROR_INVALID_DATA, but error :%i\n",(UINT)GetLastError());
1566    ok(compare(pp,pp_compare),"Difference Found\n");
1567
1568    pp_original.user.IdleDc.Action = PowerActionNone;
1569         memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
1570     memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
1571    ret = ValidatePowerPolicies(0,&pp);
1572    ok(!ret, "function was expected to fail\n");
1573    ok(GetLastError() == ERROR_GEN_FAILURE,"function was expected to fail with ERROR_GEN_FAILURE, but error :%i\n",(UINT)GetLastError());
1574    ok(compare(pp,pp_compare),"Difference Found\n");
1575
1576    pp_original.user.MaxSleepAc = PowerSystemWorking;
1577         memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
1578     memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
1579    ret = ValidatePowerPolicies(0,&pp);
1580    ok(!ret, "function was expected to fail\n");
1581    ok(GetLastError() == ERROR_GEN_FAILURE,"function was expected to fail with ERROR_GEN_FAILURE, but error :%i\n",(UINT)GetLastError());
1582    ok(compare(pp,pp_compare),"Difference Found\n");
1583
1584    pp_original.user.MaxSleepDc = PowerSystemWorking;
1585         memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
1586     memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
1587    ret = ValidatePowerPolicies(0,&pp);
1588    ok(ret, "function was expected to succeed, error %i\n",(UINT)GetLastError());
1589    pp_compare.mach.MinSleepAc=4;
1590    pp_compare.mach.MinSleepDc=4;
1591    pp_compare.user.MaxSleepAc=4;
1592    pp_compare.user.MaxSleepDc=4;
1593    pp_compare.user.OptimizeForPowerAc=1;
1594    pp_compare.user.OptimizeForPowerDc=1;
1595    ok(compare(pp,pp_compare),"Difference Found\n");
1596
1597     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1598     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1599         memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
1600     memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
1601    ret = ValidatePowerPolicies(&gpp,&pp);
1602    ok(ret, "function was expected to succeed, error %i\n",(UINT)GetLastError());
1603    gpp_compare.mach.BroadcastCapacityResolution=100;
1604    gpp_compare.user.DischargePolicy[1].PowerPolicy.EventCode = 65536;
1605    gpp_compare.user.DischargePolicy[2].PowerPolicy.EventCode = 131072;
1606    gpp_compare.user.DischargePolicy[3].PowerPolicy.EventCode = 196608;
1607    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
1608    pp_compare.mach.MinSleepAc=4;
1609    pp_compare.mach.MinSleepDc=4;
1610    pp_compare.user.MaxSleepAc=4;
1611    pp_compare.user.MaxSleepDc=4;
1612    pp_compare.user.OptimizeForPowerAc=1;
1613    pp_compare.user.OptimizeForPowerDc=1;
1614    ok(compare(pp,pp_compare),"Difference Found\n");
1615
1616
1617    gpp_original.mach.BroadcastCapacityResolution=95;
1618     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1619     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1620    ret = ValidatePowerPolicies(&gpp,0);
1621    ok(ret, "function was expected to succeed return %i\n",(UINT)GetLastError());
1622    gpp_compare.user.DischargePolicy[1].PowerPolicy.EventCode = 65536;
1623    gpp_compare.user.DischargePolicy[2].PowerPolicy.EventCode = 131072;
1624    gpp_compare.user.DischargePolicy[3].PowerPolicy.EventCode = 196608;
1625    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
1626
1627    gpp_original.user.DischargePolicy[1].PowerPolicy.EventCode = 256;
1628     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1629     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1630    ret = ValidatePowerPolicies(&gpp,0);
1631    ok(ret, "function was expected to succeed return %i\n",(UINT)GetLastError());
1632    gpp_compare.user.DischargePolicy[1].PowerPolicy.EventCode = 65792;
1633    gpp_compare.user.DischargePolicy[2].PowerPolicy.EventCode = 131072;
1634    gpp_compare.user.DischargePolicy[3].PowerPolicy.EventCode = 196608;
1635    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
1636
1637    gpp_original.user.DischargePolicy[2].PowerPolicy.EventCode = 256;
1638     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1639     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1640    ret = ValidatePowerPolicies(&gpp,0);
1641    ok(ret, "function was expected to succeed return %i\n",(UINT)GetLastError());
1642    gpp_compare.user.DischargePolicy[1].PowerPolicy.EventCode = 65792;
1643    gpp_compare.user.DischargePolicy[2].PowerPolicy.EventCode = 131328;
1644    gpp_compare.user.DischargePolicy[3].PowerPolicy.EventCode = 196608;
1645    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
1646
1647    gpp_original.user.DischargePolicy[3].PowerPolicy.EventCode = 256;
1648     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1649     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1650    ret = ValidatePowerPolicies(&gpp,0);
1651    ok(ret, "function was expected to succeed return %i\n",(UINT)GetLastError());
1652    gpp_compare.user.DischargePolicy[1].PowerPolicy.EventCode = 65792;
1653    gpp_compare.user.DischargePolicy[2].PowerPolicy.EventCode = 131328;
1654    gpp_compare.user.DischargePolicy[3].PowerPolicy.EventCode = 196864;
1655    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
1656
1657
1658    gpp_original.user.DischargePolicy[1].PowerPolicy.EventCode = 65792;
1659    gpp_original.user.DischargePolicy[2].PowerPolicy.EventCode = 131328;
1660    gpp_original.user.DischargePolicy[3].PowerPolicy.EventCode = 196864;
1661    gpp_original.mach.LidOpenWakeAc=PowerSystemUnspecified;
1662     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1663     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1664    ret = ValidatePowerPolicies(&gpp,0);
1665    ok(!ret, "function was expected to succeed return %i\n",(UINT)GetLastError());
1666    ok(GetLastError() == ERROR_GEN_FAILURE,"function was expected to fail with ERROR_GEN_FAILURE, but error :%i\n",(UINT)GetLastError());
1667    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
1668
1669    gpp_original.mach.LidOpenWakeAc=PowerSystemWorking;
1670    gpp_original.mach.LidOpenWakeDc=PowerSystemUnspecified;
1671     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1672     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1673    ret = ValidatePowerPolicies(&gpp,0);
1674    ok(!ret, "function was expected to succeed return %i\n",(UINT)GetLastError());
1675    ok(GetLastError() == ERROR_GEN_FAILURE,"function was expected to fail with ERROR_GEN_FAILURE, but error :%i\n",(UINT)GetLastError());
1676    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
1677
1678    gpp_original.mach.LidOpenWakeDc=PowerSystemWorking;
1679    gpp_original.user.LidCloseAc.Action = PowerActionWarmEject+1;
1680     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1681     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1682    ret = ValidatePowerPolicies(&gpp,0);
1683    ok(!ret, "function was expected to fail\n");
1684    ok(GetLastError() == ERROR_INVALID_DATA,"function was expected to fail with ERROR_INVALID_DATA, but error :%i\n",(UINT)GetLastError());
1685    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
1686
1687    gpp_original.user.LidCloseAc.Action = PowerActionWarmEject;
1688    gpp_original.user.LidCloseDc.Action = PowerActionNone;
1689     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1690     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1691    ret = ValidatePowerPolicies(&gpp,0);
1692    ok(ret, "function was expected to succeed return %i\n",(UINT)GetLastError());
1693    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
1694
1695    gpp_original.user.LidCloseDc.Action = PowerActionWarmEject;
1696    gpp_original.user.PowerButtonAc.Action = PowerActionNone-1;
1697     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1698     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1699    ret = ValidatePowerPolicies(&gpp,0);
1700    ok(!ret, "function was expected to fail\n");
1701    ok(GetLastError() == ERROR_INVALID_DATA,"function was expected to fail with ERROR_INVALID_DATA, but error :%i\n",(UINT)GetLastError());
1702    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
1703
1704    gpp_original.user.PowerButtonAc.Action = PowerActionNone;
1705    gpp_original.user.PowerButtonDc.Action = PowerActionWarmEject;
1706     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1707     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1708    ret = ValidatePowerPolicies(&gpp,0);
1709    ok(ret, "function was expected to succeed return %i\n",(UINT)GetLastError());
1710    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
1711
1712    gpp_original.user.SleepButtonAc.Action = PowerActionWarmEject;
1713     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1714     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1715    ret = ValidatePowerPolicies(&gpp,0);
1716    ok(ret, "function was expected to succeed return %i\n",(UINT)GetLastError());
1717    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
1718
1719    gpp_original.user.SleepButtonDc.Action = PowerActionWarmEject;
1720     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1721     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1722    ret = ValidatePowerPolicies(&gpp,0);
1723    ok(ret, "function was expected to succeed return %i\n",(UINT)GetLastError());
1724    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
1725
1726
1727    pp_original.mach.MinSleepAc=PowerSystemUnspecified-1;
1728     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1729     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1730         memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
1731     memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
1732    ret = ValidatePowerPolicies(0,&pp);
1733    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
1734    pp_compare.mach.MinSleepAc=4;
1735    pp_compare.mach.MinSleepDc=4;
1736    pp_compare.user.MaxSleepAc=4;
1737    pp_compare.user.MaxSleepDc=4;
1738    pp_compare.user.OptimizeForPowerAc=1;
1739    pp_compare.user.OptimizeForPowerDc=1;
1740    ok(compare(pp,pp_compare),"Difference Found\n");
1741
1742    pp_original.mach.MinSleepDc=PowerSystemUnspecified-1;
1743     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1744     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1745         memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
1746     memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
1747    ret = ValidatePowerPolicies(0,&pp);
1748    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
1749    pp_compare.mach.MinSleepAc=4;
1750    pp_compare.mach.MinSleepDc=4;
1751    pp_compare.user.MaxSleepAc=4;
1752    pp_compare.user.MaxSleepDc=4;
1753    pp_compare.user.OptimizeForPowerAc=1;
1754    pp_compare.user.OptimizeForPowerDc=1;
1755    ok(compare(pp,pp_compare),"Difference Found\n");
1756
1757    pp_original.user.MaxSleepAc=PowerSystemUnspecified-1;
1758     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1759     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1760         memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
1761     memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
1762    ret = ValidatePowerPolicies(0,&pp);
1763    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
1764    pp_compare.mach.MinSleepAc=4;
1765    pp_compare.mach.MinSleepDc=4;
1766    pp_compare.user.MaxSleepAc=4;
1767    pp_compare.user.MaxSleepDc=4;
1768    pp_compare.user.OptimizeForPowerAc=1;
1769    pp_compare.user.OptimizeForPowerDc=1;
1770    ok(compare(pp,pp_compare),"Difference Found\n");
1771
1772    pp_original.user.MaxSleepDc=PowerSystemUnspecified-1;
1773     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1774     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1775         memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
1776     memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
1777    ret = ValidatePowerPolicies(0,&pp);
1778    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
1779    pp_compare.mach.MinSleepAc=4;
1780    pp_compare.mach.MinSleepDc=4;
1781    pp_compare.user.MaxSleepAc=4;
1782    pp_compare.user.MaxSleepDc=4;
1783    pp_compare.user.OptimizeForPowerAc=1;
1784    pp_compare.user.OptimizeForPowerDc=1;
1785    ok(compare(pp,pp_compare),"Difference Found\n");
1786
1787    pp_original.mach.MinSleepAc=PowerSystemUnspecified;
1788     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1789     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1790         memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
1791     memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
1792    ret = ValidatePowerPolicies(0,&pp);
1793    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
1794    pp_compare.mach.MinSleepAc=4;
1795    pp_compare.mach.MinSleepDc=4;
1796    pp_compare.user.MaxSleepAc=4;
1797    pp_compare.user.MaxSleepDc=4;
1798    pp_compare.user.OptimizeForPowerAc=1;
1799    pp_compare.user.OptimizeForPowerDc=1;
1800    ok(compare(pp,pp_compare),"Difference Found\n");
1801
1802    pp_original.mach.MinSleepDc=PowerSystemUnspecified;
1803     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1804     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1805         memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
1806     memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
1807    ret = ValidatePowerPolicies(0,&pp);
1808    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
1809    pp_compare.mach.MinSleepAc=4;
1810    pp_compare.mach.MinSleepDc=4;
1811    pp_compare.user.MaxSleepAc=4;
1812    pp_compare.user.MaxSleepDc=4;
1813    pp_compare.user.OptimizeForPowerAc=1;
1814    pp_compare.user.OptimizeForPowerDc=1;
1815    ok(compare(pp,pp_compare),"Difference Found\n");
1816
1817    pp_original.user.MaxSleepAc=PowerSystemUnspecified;
1818     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1819     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1820         memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
1821     memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
1822    ret = ValidatePowerPolicies(0,&pp);
1823    ok(!ret, "function was expected to fail\n");
1824    ok(GetLastError() == ERROR_GEN_FAILURE,"function was expected to fail with ERROR_GEN_FAILURE, but error :%i\n",(UINT)GetLastError());
1825    ok(compare(pp,pp_compare),"Difference Found\n");
1826
1827    pp_original.user.MaxSleepDc=PowerSystemUnspecified;
1828     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1829     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1830         memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
1831     memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
1832    ret = ValidatePowerPolicies(0,&pp);
1833    ok(!ret, "function was expected to fail\n");
1834    ok(GetLastError() == ERROR_GEN_FAILURE,"function was expected to fail with ERROR_GEN_FAILURE, but error :%i\n",(UINT)GetLastError());
1835    ok(compare(pp,pp_compare),"Difference Found\n");
1836
1837    pp_original.mach.MinSleepAc=PowerSystemWorking;
1838     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1839     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1840         memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
1841     memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
1842    ret = ValidatePowerPolicies(0,&pp);
1843    ok(!ret, "function was expected to fail\n");
1844    ok(GetLastError() == ERROR_GEN_FAILURE,"function was expected to fail with ERROR_GEN_FAILURE, but error :%i\n",(UINT)GetLastError());
1845    //pp_compare.mach.MinSleepAc=4;
1846    //pp_compare.mach.MinSleepDc=4;
1847    //pp_compare.user.MaxSleepAc=4;
1848    //pp_compare.user.MaxSleepDc=4;
1849    ok(compare(pp,pp_compare),"Difference Found\n");
1850
1851    pp_original.mach.MinSleepDc=PowerSystemWorking;
1852     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1853     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1854         memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
1855     memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
1856    ret = ValidatePowerPolicies(0,&pp);
1857    ok(!ret, "function was expected to fail\n");
1858    ok(GetLastError() == ERROR_GEN_FAILURE,"function was expected to fail with ERROR_GEN_FAILURE, but error :%i\n",(UINT)GetLastError());
1859    //pp_compare.mach.MinSleepAc=4;
1860    //pp_compare.mach.MinSleepDc=4;
1861    //pp_compare.user.MaxSleepAc=4;
1862    //pp_compare.user.MaxSleepDc=4;
1863    ok(compare(pp,pp_compare),"Difference Found\n");
1864
1865    pp_original.user.MaxSleepAc=PowerSystemWorking;
1866     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1867     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1868         memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
1869     memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
1870    ret = ValidatePowerPolicies(0,&pp);
1871    ok(!ret, "function was expected to fail\n");
1872    ok(GetLastError() == ERROR_GEN_FAILURE,"function was expected to fail with ERROR_GEN_FAILURE, but error :%i\n",(UINT)GetLastError());
1873    //pp_compare.mach.MinSleepAc=4;
1874    //pp_compare.mach.MinSleepDc=4;
1875    //pp_compare.user.MaxSleepAc=4;
1876    //pp_compare.user.MaxSleepDc=4;
1877    //pp_compare.user.OptimizeForPowerAc=1;
1878    //pp_compare.user.OptimizeForPowerDc=1;
1879    ok(compare(pp,pp_compare),"Difference Found\n");
1880
1881    pp_original.user.MaxSleepDc=PowerSystemWorking;
1882     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1883     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1884         memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
1885     memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
1886    ret = ValidatePowerPolicies(0,&pp);
1887    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
1888    pp_compare.mach.MinSleepAc=4;
1889    pp_compare.mach.MinSleepDc=4;
1890    pp_compare.user.MaxSleepAc=4;
1891    pp_compare.user.MaxSleepDc=4;
1892    pp_compare.user.OptimizeForPowerAc=1;
1893    pp_compare.user.OptimizeForPowerDc=1;
1894    ok(compare(pp,pp_compare),"Difference Found\n");
1895
1896    pp_original.mach.MinSleepAc=PowerSystemSleeping1;
1897     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1898     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1899         memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
1900     memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
1901    ret = ValidatePowerPolicies(0,&pp);
1902    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
1903    pp_compare.mach.MinSleepAc=4;
1904    pp_compare.mach.MinSleepDc=4;
1905    pp_compare.user.MaxSleepAc=4;
1906    pp_compare.user.MaxSleepDc=4;
1907    pp_compare.user.OptimizeForPowerAc=1;
1908    pp_compare.user.OptimizeForPowerDc=1;
1909    ok(compare(pp,pp_compare),"Difference Found\n");
1910
1911    pp_original.mach.MinSleepDc=PowerSystemSleeping1;
1912     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1913     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1914         memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
1915     memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
1916    ret = ValidatePowerPolicies(0,&pp);
1917    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
1918    pp_compare.mach.MinSleepAc=4;
1919    pp_compare.mach.MinSleepDc=4;
1920    pp_compare.user.MaxSleepAc=4;
1921    pp_compare.user.MaxSleepDc=4;
1922    pp_compare.user.OptimizeForPowerAc=1;
1923    pp_compare.user.OptimizeForPowerDc=1;
1924    ok(compare(pp,pp_compare),"Difference Found\n");
1925
1926    pp_original.user.MaxSleepAc=PowerSystemSleeping1;
1927     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1928     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1929         memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
1930     memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
1931    ret = ValidatePowerPolicies(0,&pp);
1932    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
1933    pp_compare.mach.MinSleepAc=4;
1934    pp_compare.mach.MinSleepDc=4;
1935    pp_compare.user.MaxSleepAc=4;
1936    pp_compare.user.MaxSleepDc=4;
1937    pp_compare.user.OptimizeForPowerAc=1;
1938    pp_compare.user.OptimizeForPowerDc=1;
1939    ok(compare(pp,pp_compare),"Difference Found\n");
1940
1941    pp_original.user.MaxSleepDc=PowerSystemSleeping1;
1942     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1943     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1944         memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
1945     memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
1946    ret = ValidatePowerPolicies(0,&pp);
1947    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
1948    pp_compare.mach.MinSleepAc=4;
1949    pp_compare.mach.MinSleepDc=4;
1950    pp_compare.user.MaxSleepAc=4;
1951    pp_compare.user.MaxSleepDc=4;
1952    pp_compare.user.OptimizeForPowerAc=1;
1953    pp_compare.user.OptimizeForPowerDc=1;
1954    ok(compare(pp,pp_compare),"Difference Found\n");
1955
1956    pp_original.mach.MinSleepAc=PowerSystemSleeping2;
1957     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1958     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1959         memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
1960     memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
1961    ret = ValidatePowerPolicies(0,&pp);
1962    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
1963    pp_compare.mach.MinSleepAc=4;
1964    pp_compare.mach.MinSleepDc=4;
1965    pp_compare.user.MaxSleepAc=4;
1966    pp_compare.user.MaxSleepDc=4;
1967    pp_compare.user.OptimizeForPowerAc=1;
1968    pp_compare.user.OptimizeForPowerDc=1;
1969    ok(compare(pp,pp_compare),"Difference Found\n");
1970
1971    pp_original.mach.MinSleepDc=PowerSystemSleeping2;
1972     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1973     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1974         memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
1975     memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
1976    ret = ValidatePowerPolicies(0,&pp);
1977    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
1978    pp_compare.mach.MinSleepAc=4;
1979    pp_compare.mach.MinSleepDc=4;
1980    pp_compare.user.MaxSleepAc=4;
1981    pp_compare.user.MaxSleepDc=4;
1982    pp_compare.user.OptimizeForPowerAc=1;
1983    pp_compare.user.OptimizeForPowerDc=1;
1984    ok(compare(pp,pp_compare),"Difference Found\n");
1985
1986    pp_original.user.MaxSleepAc=PowerSystemSleeping2;
1987     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1988     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
1989         memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
1990     memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
1991    ret = ValidatePowerPolicies(0,&pp);
1992    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
1993    pp_compare.mach.MinSleepAc=4;
1994    pp_compare.mach.MinSleepDc=4;
1995    pp_compare.user.MaxSleepAc=4;
1996    pp_compare.user.MaxSleepDc=4;
1997    pp_compare.user.OptimizeForPowerAc=1;
1998    pp_compare.user.OptimizeForPowerDc=1;
1999    ok(compare(pp,pp_compare),"Difference Found\n");
2000
2001    pp_original.user.MaxSleepDc=PowerSystemSleeping2;
2002     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
2003     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
2004         memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
2005     memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
2006    ret = ValidatePowerPolicies(0,&pp);
2007    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
2008    pp_compare.mach.MinSleepAc=4;
2009    pp_compare.mach.MinSleepDc=4;
2010    pp_compare.user.MaxSleepAc=4;
2011    pp_compare.user.MaxSleepDc=4;
2012    pp_compare.user.OptimizeForPowerAc=1;
2013    pp_compare.user.OptimizeForPowerDc=1;
2014    ok(compare(pp,pp_compare),"Difference Found\n");
2015
2016    pp_original.mach.MinSleepAc=PowerSystemSleeping3;
2017     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
2018     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
2019         memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
2020     memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
2021    ret = ValidatePowerPolicies(0,&pp);
2022    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
2023    pp_compare.mach.MinSleepDc=4;
2024    pp_compare.user.MaxSleepAc=4;
2025    pp_compare.user.MaxSleepDc=4;
2026    pp_compare.user.OptimizeForPowerAc=1;
2027    pp_compare.user.OptimizeForPowerDc=1;
2028    ok(compare(pp,pp_compare),"Difference Found\n");
2029
2030    pp_original.mach.MinSleepDc=PowerSystemSleeping3;
2031     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
2032     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
2033         memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
2034     memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
2035    ret = ValidatePowerPolicies(0,&pp);
2036    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
2037    pp_compare.user.MaxSleepAc=4;
2038    pp_compare.user.MaxSleepDc=4;
2039    pp_compare.user.OptimizeForPowerAc=1;
2040    pp_compare.user.OptimizeForPowerDc=1;
2041    ok(compare(pp,pp_compare),"Difference Found\n");
2042
2043    pp_original.user.MaxSleepAc=PowerSystemSleeping3;
2044     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
2045     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
2046         memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
2047     memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
2048    ret = ValidatePowerPolicies(0,&pp);
2049    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
2050    pp_compare.user.MaxSleepDc=4;
2051    pp_compare.user.OptimizeForPowerAc=1;
2052    pp_compare.user.OptimizeForPowerDc=1;
2053    ok(compare(pp,pp_compare),"Difference Found\n");
2054
2055    pp_original.user.MaxSleepDc=PowerSystemSleeping3;
2056     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
2057     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
2058         memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
2059     memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
2060    ret = ValidatePowerPolicies(0,&pp);
2061    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
2062    pp_compare.user.OptimizeForPowerAc=1;
2063    pp_compare.user.OptimizeForPowerDc=1;
2064    ok(compare(pp,pp_compare),"Difference Found\n");
2065
2066    pp_original.mach.MinSleepAc=PowerSystemHibernate;
2067     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
2068     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
2069         memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
2070     memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
2071    ret = ValidatePowerPolicies(0,&pp);
2072    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
2073    pp_compare.mach.MinSleepAc=4;
2074    pp_compare.mach.MinSleepDc=4;
2075    pp_compare.user.MaxSleepAc=4;
2076    pp_compare.user.MaxSleepDc=4;
2077    pp_compare.user.OptimizeForPowerAc=1;
2078    pp_compare.user.OptimizeForPowerDc=1;
2079    ok(compare(pp,pp_compare),"Difference Found\n");
2080
2081    pp_original.mach.MinSleepDc=PowerSystemHibernate;
2082     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
2083     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
2084         memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
2085     memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
2086    ret = ValidatePowerPolicies(0,&pp);
2087    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
2088    pp_compare.mach.MinSleepAc=4;
2089    pp_compare.mach.MinSleepDc=4;
2090    pp_compare.user.MaxSleepAc=4;
2091    pp_compare.user.MaxSleepDc=4;
2092    pp_compare.user.OptimizeForPowerAc=1;
2093    pp_compare.user.OptimizeForPowerDc=1;
2094    ok(compare(pp,pp_compare),"Difference Found\n");
2095
2096    pp_original.user.MaxSleepAc=PowerSystemHibernate;
2097     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
2098     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
2099         memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
2100     memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
2101    ret = ValidatePowerPolicies(0,&pp);
2102    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
2103    pp_compare.mach.MinSleepAc=4;
2104    pp_compare.mach.MinSleepDc=4;
2105    pp_compare.user.MaxSleepAc=4;
2106    pp_compare.user.MaxSleepDc=4;
2107    pp_compare.user.OptimizeForPowerAc=1;
2108    pp_compare.user.OptimizeForPowerDc=1;
2109    ok(compare(pp,pp_compare),"Difference Found\n");
2110
2111    pp_original.user.MaxSleepDc=PowerSystemHibernate;
2112     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
2113     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
2114         memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
2115     memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
2116    ret = ValidatePowerPolicies(0,&pp);
2117    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
2118    pp_compare.mach.MinSleepAc=4;
2119    pp_compare.mach.MinSleepDc=4;
2120    pp_compare.user.MaxSleepAc=4;
2121    pp_compare.user.MaxSleepDc=4;
2122    pp_compare.user.OptimizeForPowerAc=1;
2123    pp_compare.user.OptimizeForPowerDc=1;
2124    ok(compare(pp,pp_compare),"Difference Found\n");
2125
2126    pp_original.mach.MinSleepAc=PowerSystemShutdown;
2127     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
2128     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
2129         memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
2130     memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
2131    ret = ValidatePowerPolicies(0,&pp);
2132    ok(!ret, "function was expected to fail\n");
2133    ok(GetLastError() == ERROR_GEN_FAILURE,"function was expected to fail with ERROR_GEN_FAILURE, but error :%i\n",(UINT)GetLastError());
2134    ok(compare(pp,pp_compare),"Difference Found\n");
2135
2136    pp_original.mach.MinSleepDc=PowerSystemShutdown;
2137     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
2138     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
2139         memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
2140     memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
2141    ret = ValidatePowerPolicies(0,&pp);
2142    ok(!ret, "function was expected to fail\n");
2143    ok(GetLastError() == ERROR_GEN_FAILURE,"function was expected to fail with ERROR_GEN_FAILURE, but error :%i\n",(UINT)GetLastError());
2144    ok(compare(pp,pp_compare),"Difference Found\n");
2145
2146    pp_original.user.MaxSleepAc=PowerSystemShutdown;
2147     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
2148     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
2149         memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
2150     memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
2151    ret = ValidatePowerPolicies(0,&pp);
2152    ok(!ret, "function was expected to fail\n");
2153    ok(GetLastError() == ERROR_GEN_FAILURE,"function was expected to fail with ERROR_GEN_FAILURE, but error :%i\n",(UINT)GetLastError());
2154    ok(compare(pp,pp_compare),"Difference Found\n");
2155
2156    pp_original.user.MaxSleepDc=PowerSystemShutdown;
2157     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
2158     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
2159         memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
2160     memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
2161    ret = ValidatePowerPolicies(0,&pp);
2162    ok(!ret, "function was expected to fail\n");
2163    ok(GetLastError() == ERROR_GEN_FAILURE,"function was expected to fail with ERROR_GEN_FAILURE, but error :%i\n",(UINT)GetLastError());
2164    ok(compare(pp,pp_compare),"Difference Found\n");
2165
2166    pp_original.mach.MinSleepAc=PowerSystemMaximum;
2167     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
2168     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
2169         memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
2170     memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
2171    ret = ValidatePowerPolicies(0,&pp);
2172    ok(!ret, "function was expected to fail\n");
2173    ok(GetLastError() == ERROR_GEN_FAILURE,"function was expected to fail with ERROR_GEN_FAILURE, but error :%i\n",(UINT)GetLastError());
2174    ok(compare(pp,pp_compare),"Difference Found\n");
2175
2176    pp_original.mach.MinSleepDc=PowerSystemMaximum;
2177     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
2178     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
2179         memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
2180     memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
2181    ret = ValidatePowerPolicies(0,&pp);
2182    ok(!ret, "function was expected to fail\n");
2183    ok(GetLastError() == ERROR_GEN_FAILURE,"function was expected to fail with ERROR_GEN_FAILURE, but error :%i\n",(UINT)GetLastError());
2184    ok(compare(pp,pp_compare),"Difference Found\n");
2185
2186    pp_original.user.MaxSleepAc=PowerSystemMaximum;
2187     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
2188     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
2189         memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
2190     memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
2191    ret = ValidatePowerPolicies(0,&pp);
2192    ok(!ret, "function was expected to fail\n");
2193    ok(GetLastError() == ERROR_GEN_FAILURE,"function was expected to fail with ERROR_GEN_FAILURE, but error :%i\n",(UINT)GetLastError());
2194    ok(compare(pp,pp_compare),"Difference Found\n");
2195
2196    pp_original.user.MaxSleepDc=PowerSystemMaximum;
2197     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
2198     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
2199         memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
2200     memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
2201    ret = ValidatePowerPolicies(0,&pp);
2202    ok(!ret, "function was expected to fail\n");
2203    ok(GetLastError() == ERROR_GEN_FAILURE,"function was expected to fail with ERROR_GEN_FAILURE, but error :%i\n",(UINT)GetLastError());
2204    ok(compare(pp,pp_compare),"Difference Found\n");
2205
2206    pp_original.mach.MinSleepAc=PowerSystemMaximum+1;
2207     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
2208     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
2209         memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
2210     memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
2211    ret = ValidatePowerPolicies(0,&pp);
2212    ok(!ret, "function was expected to fail\n");
2213    ok(GetLastError() == ERROR_GEN_FAILURE,"function was expected to fail with ERROR_GEN_FAILURE, but error :%i\n",(UINT)GetLastError());
2214    ok(compare(pp,pp_compare),"Difference Found\n");
2215
2216    pp_original.mach.MinSleepDc=PowerSystemMaximum+1;
2217     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
2218     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
2219         memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
2220     memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
2221    ret = ValidatePowerPolicies(0,&pp);
2222    ok(!ret, "function was expected to fail\n");
2223    ok(GetLastError() == ERROR_GEN_FAILURE,"function was expected to fail with ERROR_GEN_FAILURE, but error :%i\n",(UINT)GetLastError());
2224    ok(compare(pp,pp_compare),"Difference Found\n");
2225
2226    pp_original.user.MaxSleepAc=PowerSystemMaximum+1;
2227     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
2228     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
2229         memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
2230     memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
2231    ret = ValidatePowerPolicies(0,&pp);
2232    ok(!ret, "function was expected to fail\n");
2233    ok(GetLastError() == ERROR_GEN_FAILURE,"function was expected to fail with ERROR_GEN_FAILURE, but error :%i\n",(UINT)GetLastError());
2234    ok(compare(pp,pp_compare),"Difference Found\n");
2235
2236    pp_original.user.MaxSleepDc=PowerSystemMaximum+1;
2237     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
2238     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
2239         memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
2240     memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
2241    ret = ValidatePowerPolicies(0,&pp);
2242    ok(!ret, "function was expected to fail\n");
2243    ok(GetLastError() == ERROR_GEN_FAILURE,"function was expected to fail with ERROR_GEN_FAILURE, but error :%i\n",(UINT)GetLastError());
2244    ok(compare(pp,pp_compare),"Difference Found\n");
2245
2246    pp_original.mach.MinSleepAc=PowerSystemWorking;
2247    pp_original.mach.MinSleepDc=PowerSystemWorking;
2248    pp_original.user.MaxSleepAc=PowerSystemWorking;
2249    pp_original.user.MaxSleepDc=PowerSystemWorking;
2250
2251
2252    test_ValidatePowerPolicies_Next(&gpp_original,&pp_original);
2253
2254
2255  //   memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
2256  //   memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
2257         //memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
2258  //   memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
2259    ret = GetCurrentPowerPolicies(&gpp_original,&pp_original);
2260    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
2261    //gpp_compare.mach.BroadcastCapacityResolution = 3;
2262    //gpp_compare.user.PowerButtonAc.Action = 2;
2263    //gpp_compare.user.PowerButtonAc.Flags=3;
2264    //gpp_compare.user.PowerButtonDc.EventCode=16;
2265    //gpp_compare.user.PowerButtonDc.Flags=3;
2266    //gpp_compare.user.SleepButtonAc.Action=2;
2267    //gpp_compare.user.SleepButtonAc.Flags=3;
2268    //gpp_compare.user.SleepButtonDc.Action=2;
2269    //gpp_compare.user.SleepButtonDc.Flags=3;
2270    //gpp_compare.user.LidCloseAc.EventCode=-2147483648;
2271    //gpp_compare.user.LidCloseAc.Flags=1;
2272    //gpp_compare.user.LidCloseDc.EventCode=-2147483648;
2273    //gpp_compare.user.LidCloseDc.Flags=1;
2274
2275    //gpp_compare.user.DischargePolicy[0].Enable=1;
2276    ////gpp_compare.user.DischargePolicy[0].Spare[0]=3;
2277    //gpp_compare.user.DischargePolicy[0].Spare[3]=3;
2278    //gpp_compare.user.DischargePolicy[0].BatteryLevel=3;
2279    //gpp_compare.user.DischargePolicy[0].PowerPolicy.Action=2;
2280    //gpp_compare.user.DischargePolicy[0].PowerPolicy.Flags=-1073741820;
2281    //gpp_compare.user.DischargePolicy[0].PowerPolicy.EventCode=1;
2282    //gpp_compare.user.DischargePolicy[0].MinSystemState=4;
2283
2284    //gpp_compare.user.DischargePolicy[1].Enable=1;
2285    ////gpp_compare.user.DischargePolicy[1].Spare[0]=3;
2286    //gpp_compare.user.DischargePolicy[1].Spare[3]=10;
2287    //gpp_compare.user.DischargePolicy[1].BatteryLevel=10;
2288    ////gpp_compare.user.DischargePolicy[1].PowerPolicy.Action=3;
2289    //gpp_compare.user.DischargePolicy[1].PowerPolicy.Flags=3;
2290    //gpp_compare.user.DischargePolicy[1].PowerPolicy.EventCode=65537;
2291    //gpp_compare.user.DischargePolicy[1].MinSystemState=1;
2292    //
2293    //gpp_compare.user.DischargePolicy[2].PowerPolicy.EventCode=131072;
2294    //gpp_compare.user.DischargePolicy[3].PowerPolicy.EventCode=196608;
2295    //gpp_compare.user.GlobalFlags=20;
2296
2297    //ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
2298    //pp_compare.mach.MinSleepAc=4;
2299    //pp_compare.mach.MinSleepDc=4;
2300    //pp_compare.mach.ReducedLatencySleepAc=4;
2301    //pp_compare.mach.ReducedLatencySleepDc=4;
2302    //pp_compare.mach.OverThrottledAc.Action=2;
2303    //pp_compare.mach.OverThrottledAc.Flags=-1073741820;
2304    //pp_compare.mach.OverThrottledDc.Action=2;
2305    //pp_compare.mach.OverThrottledDc.Flags=-1073741820;
2306    //pp_compare.mach.pad1[2]=2;
2307    //pp_compare.user.IdleAc.Flags=1;
2308    //pp_compare.user.IdleDc.Flags=1;
2309    //pp_compare.user.IdleSensitivityAc=50;
2310    //pp_compare.user.IdleSensitivityDc=50;
2311    //pp_compare.user.ThrottlePolicyAc=3;
2312    //pp_compare.user.ThrottlePolicyDc=3;
2313    //pp_compare.user.Reserved[2]=1200;
2314    //pp_compare.user.VideoTimeoutAc=1200;
2315    //pp_compare.user.VideoTimeoutDc=600;
2316    //pp_compare.user.SpindownTimeoutAc=2700;
2317    //pp_compare.user.SpindownTimeoutDc=600;
2318    //pp_compare.user.FanThrottleToleranceAc=100;
2319    //pp_compare.user.FanThrottleToleranceDc=80;
2320    //pp_compare.user.ForcedThrottleAc=100;
2321    //pp_compare.user.ForcedThrottleDc=100;
2322    //pp_compare.user.MaxSleepAc=4;
2323    //pp_compare.user.MaxSleepDc=4;
2324    //pp_compare.user.OptimizeForPowerAc=1;
2325    //pp_compare.user.OptimizeForPowerDc=1;
2326    //ok(compare(pp,pp_compare),"Difference Found\n");
2327
2328     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
2329     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
2330         memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
2331     memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
2332    ret = ValidatePowerPolicies(&gpp,0);
2333    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
2334    //gpp_compare.mach.BroadcastCapacityResolution=100;
2335    //gpp_compare.user.DischargePolicy[1].PowerPolicy.EventCode = 65536;
2336    //gpp_compare.user.DischargePolicy[2].PowerPolicy.EventCode = 131072;
2337    //gpp_compare.user.DischargePolicy[3].PowerPolicy.EventCode = 196608;
2338    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
2339
2340     memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
2341     memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
2342         memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
2343     memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
2344    ret = ValidatePowerPolicies(0,&pp);
2345    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
2346    //pp_compare.mach.MinSleepAc=4;
2347    //pp_compare.mach.MinSleepDc=4;
2348    //pp_compare.user.MaxSleepAc=4;
2349    //pp_compare.user.MaxSleepDc=4;
2350    //pp_compare.user.OptimizeForPowerAc=1;
2351    //pp_compare.user.OptimizeForPowerDc=1;
2352    ok(compare(pp,pp_compare),"Difference Found\n");
2353
2354         memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
2355     memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
2356    ret = ValidatePowerPolicies(&gpp,&pp);
2357    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
2358    //gpp_compare.mach.BroadcastCapacityResolution=100;
2359    //gpp_compare.user.DischargePolicy[1].PowerPolicy.EventCode = 65536;
2360    //gpp_compare.user.DischargePolicy[2].PowerPolicy.EventCode = 131072;
2361    //gpp_compare.user.DischargePolicy[3].PowerPolicy.EventCode = 196608;
2362    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
2363    pp_compare.mach.MinSleepAc=4;
2364    pp_compare.mach.MinSleepDc=4;
2365    pp_compare.user.MaxSleepAc=4;
2366    pp_compare.user.MaxSleepDc=4;
2367    //pp_compare.user.OptimizeForPowerAc=1;
2368    //pp_compare.user.OptimizeForPowerDc=1;
2369    ok(compare(pp,pp_compare),"Difference Found\n");
2370
2371 }
2372
2373 void test_ValidatePowerPolicies_Next(PGLOBAL_POWER_POLICY pGPP_original,PPOWER_POLICY pPP_original)
2374 {
2375    GLOBAL_POWER_POLICY gpp, gpp_compare;
2376    POWER_POLICY pp, pp_compare;
2377    BOOLEAN ret;
2378
2379    //printf("Old: %i\n",pGPP_original->mach.LidOpenWakeAc);//1
2380    //printf("Old: %i\n",pGPP_original->mach.LidOpenWakeDc);//1
2381    //printf("Old: %i,%i,%i \n",pGPP_original->user.LidCloseAc.Action,pGPP_original->user.LidCloseAc.EventCode,pGPP_original->user.LidCloseAc.Flags);//7
2382    //printf("Old: %i,%i,%i \n",pGPP_original->user.LidCloseDc.Action,pGPP_original->user.LidCloseDc.EventCode,pGPP_original->user.LidCloseDc.Flags);//7
2383    //printf("Old: %i,%i,%i \n",pGPP_original->user.PowerButtonAc.Action,pGPP_original->user.PowerButtonAc.EventCode,pGPP_original->user.PowerButtonAc.Flags);//0,0,0
2384    //printf("Old: %i,%i,%i \n",pGPP_original->user.PowerButtonDc.Action,pGPP_original->user.PowerButtonDc.EventCode,pGPP_original->user.PowerButtonDc.Flags);//7,0,0
2385    //printf("Old: %i,%i,%i \n",pGPP_original->user.SleepButtonAc.Action,pGPP_original->user.SleepButtonAc.EventCode,pGPP_original->user.SleepButtonAc.Flags);//7,0,0
2386    //printf("Old: %i,%i,%i \n",pGPP_original->user.SleepButtonDc.Action,pGPP_original->user.SleepButtonDc.EventCode,pGPP_original->user.SleepButtonDc.Flags);//7,0,0
2387    //printf("Old: %i \n",pPP_original->mach.DozeS4TimeoutAc);//0
2388    //printf("Old: %i \n",pPP_original->mach.DozeS4TimeoutDc);//0
2389    //printf("Old: %i \n",pPP_original->mach.DozeTimeoutAc);//0
2390    //printf("Old: %i \n",pPP_original->mach.DozeTimeoutDc);//0
2391    //printf("Old: %i \n",pPP_original->mach.MinSleepAc);//1
2392    //printf("Old: %i \n",pPP_original->mach.MinSleepDc);//1
2393    //printf("Old: %i \n",pPP_original->mach.MinThrottleAc);//0
2394    //printf("Old: %i \n",pPP_original->mach.MinThrottleDc);//0
2395    //printf("Old: %i,%i,%i \n",pPP_original->mach.OverThrottledAc.Action,pPP_original->mach.OverThrottledAc.EventCode,pPP_original->mach.OverThrottledAc.Flags);//0,0,0
2396    //printf("Old: %i,%i,%i \n",pPP_original->mach.OverThrottledDc.Action,pPP_original->mach.OverThrottledDc.EventCode,pPP_original->mach.OverThrottledDc.Flags);//0,0,0
2397    //printf("Old: %i \n",pPP_original->mach.ReducedLatencySleepAc);//1
2398    //printf("Old: %i \n",pPP_original->mach.ReducedLatencySleepDc);//1
2399    //printf("Old: %i \n",pPP_original->user.FanThrottleToleranceAc);//0
2400    //printf("Old: %i \n",pPP_original->user.FanThrottleToleranceDc);//0
2401    //printf("Old: %i \n",pPP_original->user.ForcedThrottleAc);//0
2402    //printf("Old: %i \n",pPP_original->user.ForcedThrottleDc);//0
2403    //printf("Old: %i,%i,%i \n",pPP_original->user.IdleAc.Action,pPP_original->user.IdleAc.EventCode,pPP_original->user.IdleAc.Flags);//0,0,0
2404    //printf("Old: %i,%i,%i \n",pPP_original->user.IdleDc.Action,pPP_original->user.IdleDc.EventCode,pPP_original->user.IdleDc.Flags);//0,0,0
2405    //printf("Old: %i \n",pPP_original->user.IdleSensitivityAc);//0
2406    //printf("Old: %i \n",pPP_original->user.IdleSensitivityDc);//0
2407    //printf("Old: %i \n",pPP_original->user.IdleTimeoutAc);//0
2408    //printf("Old: %i \n",pPP_original->user.IdleTimeoutDc);//0
2409    //printf("Old: %i \n",pPP_original->user.MaxSleepAc);//1
2410    //printf("Old: %i \n",pPP_original->user.MaxSleepDc);//1
2411    //printf("Old: %i \n",pPP_original->user.OptimizeForPowerAc);//0
2412    //printf("Old: %i \n",pPP_original->user.OptimizeForPowerDc);//0
2413    //printf("Old: %i \n",pPP_original->user.SpindownTimeoutAc);//0
2414    //printf("Old: %i \n",pPP_original->user.SpindownTimeoutDc);//0
2415    //printf("Old: %i \n",pPP_original->user.ThrottlePolicyAc);//0
2416    //printf("Old: %i \n",pPP_original->user.ThrottlePolicyDc);//0
2417    //printf("Old: %i \n",pPP_original->user.VideoTimeoutAc);//0
2418    //printf("Old: %i \n",pPP_original->user.VideoTimeoutDc);//0
2419
2420    pPP_original->mach.MinSleepAc=4;
2421 pPP_original->mach.MinSleepDc=4;
2422 pPP_original->user.MaxSleepAc=4;
2423 pPP_original->user.MaxSleepDc=4;
2424 pPP_original->user.OptimizeForPowerAc=1;
2425 pPP_original->user.OptimizeForPowerDc=1;
2426
2427     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2428     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2429    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
2430
2431         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
2432     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
2433    ok(compare(pp,pp_compare),"Difference Found\n");
2434
2435    ret = ValidatePowerPolicies(&gpp,&pp);
2436    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
2437    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
2438    ok(compare(pp,pp_compare),"Difference Found\n");
2439
2440    pGPP_original->mach.LidOpenWakeAc=PowerSystemUnspecified-2;
2441     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2442     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2443         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
2444     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
2445    ret = ValidatePowerPolicies(&gpp,&pp);
2446    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
2447    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
2448    ok(compare(pp,pp_compare),"Difference Found\n");
2449
2450    pGPP_original->mach.LidOpenWakeAc=PowerSystemUnspecified-1;
2451     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2452     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2453         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
2454     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
2455    ret = ValidatePowerPolicies(&gpp,&pp);
2456    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
2457    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
2458    ok(compare(pp,pp_compare),"Difference Found\n");
2459
2460    pGPP_original->mach.LidOpenWakeAc=PowerSystemUnspecified;
2461     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2462     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2463         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
2464     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
2465    ret = ValidatePowerPolicies(&gpp,&pp);
2466    ok(!ret, "function was expected to fail\n");
2467    ok(GetLastError() == ERROR_GEN_FAILURE, "expected ERROR_GEN_FAILURE but got %i\n",(UINT)GetLastError());
2468    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
2469    ok(compare(pp,pp_compare),"Difference Found\n");
2470
2471    pGPP_original->mach.LidOpenWakeAc=PowerSystemWorking;
2472     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2473     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2474         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
2475     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
2476    ret = ValidatePowerPolicies(&gpp,&pp);
2477    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
2478    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
2479    ok(compare(pp,pp_compare),"Difference Found\n");
2480
2481    pGPP_original->mach.LidOpenWakeAc=PowerSystemSleeping1;
2482     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2483     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2484         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
2485     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
2486    ret = ValidatePowerPolicies(&gpp,&pp);
2487    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
2488    gpp_compare.mach.LidOpenWakeAc=4;
2489    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
2490    ok(compare(pp,pp_compare),"Difference Found\n");
2491
2492    pGPP_original->mach.LidOpenWakeAc=PowerSystemSleeping2;
2493     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2494     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2495         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
2496     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
2497    ret = ValidatePowerPolicies(&gpp,&pp);
2498    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
2499    gpp_compare.mach.LidOpenWakeAc=4;
2500    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
2501    ok(compare(pp,pp_compare),"Difference Found\n");
2502
2503    pGPP_original->mach.LidOpenWakeAc=PowerSystemSleeping3;
2504     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2505     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2506         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
2507     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
2508    ret = ValidatePowerPolicies(&gpp,&pp);
2509    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
2510    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
2511    ok(compare(pp,pp_compare),"Difference Found\n");
2512
2513    pGPP_original->mach.LidOpenWakeAc=PowerSystemHibernate;
2514     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2515     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2516         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
2517     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
2518    ret = ValidatePowerPolicies(&gpp,&pp);
2519    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
2520    gpp_compare.mach.LidOpenWakeAc=4;
2521    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
2522    ok(compare(pp,pp_compare),"Difference Found\n");
2523
2524    pGPP_original->mach.LidOpenWakeAc=PowerSystemShutdown;
2525     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2526     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2527         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
2528     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
2529    ret = ValidatePowerPolicies(&gpp,&pp);
2530    ok(!ret, "function was expected to fail\n");
2531    ok(GetLastError() == ERROR_GEN_FAILURE, "expected ERROR_GEN_FAILURE but got %i\n",(UINT)GetLastError());
2532    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
2533    ok(compare(pp,pp_compare),"Difference Found\n");
2534
2535    pGPP_original->mach.LidOpenWakeAc=PowerSystemMaximum;
2536     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2537     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2538         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
2539     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
2540    ret = ValidatePowerPolicies(&gpp,&pp);
2541    ok(!ret, "function was expected to fail\n");
2542    ok(GetLastError() == ERROR_GEN_FAILURE, "expected ERROR_GEN_FAILURE but got %i\n",(UINT)GetLastError());
2543    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
2544    ok(compare(pp,pp_compare),"Difference Found\n");
2545
2546    pGPP_original->mach.LidOpenWakeAc=PowerSystemMaximum+1;
2547     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2548     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2549         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
2550     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
2551    ret = ValidatePowerPolicies(&gpp,&pp);
2552    ok(!ret, "function was expected to fail\n");
2553    ok(GetLastError() == ERROR_GEN_FAILURE, "expected ERROR_GEN_FAILURE but got %i\n",(UINT)GetLastError());
2554    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
2555    ok(compare(pp,pp_compare),"Difference Found\n");
2556
2557    pGPP_original->mach.LidOpenWakeAc=PowerSystemMaximum+2;
2558     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2559     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2560         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
2561     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
2562    ret = ValidatePowerPolicies(&gpp,&pp);
2563    ok(!ret, "function was expected to fail\n");
2564    ok(GetLastError() == ERROR_GEN_FAILURE, "expected ERROR_GEN_FAILURE but got %i\n",(UINT)GetLastError());
2565    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
2566    ok(compare(pp,pp_compare),"Difference Found\n");
2567    pGPP_original->mach.LidOpenWakeAc=PowerSystemWorking;
2568
2569
2570    pGPP_original->mach.LidOpenWakeDc=PowerSystemUnspecified-2;
2571     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2572     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2573         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
2574     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
2575    ret = ValidatePowerPolicies(&gpp,&pp);
2576    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
2577    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
2578    ok(compare(pp,pp_compare),"Difference Found\n");
2579
2580    pGPP_original->mach.LidOpenWakeDc=PowerSystemUnspecified-1;
2581     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2582     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2583         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
2584     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
2585    ret = ValidatePowerPolicies(&gpp,&pp);
2586    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
2587    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
2588    ok(compare(pp,pp_compare),"Difference Found\n");
2589
2590    pGPP_original->mach.LidOpenWakeDc=PowerSystemUnspecified;
2591     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2592     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2593         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
2594     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
2595    ret = ValidatePowerPolicies(&gpp,&pp);
2596    ok(!ret, "function was expected to fail\n");
2597    ok(GetLastError() == ERROR_GEN_FAILURE, "expected ERROR_GEN_FAILURE but got %i\n",(UINT)GetLastError());
2598    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
2599    ok(compare(pp,pp_compare),"Difference Found\n");
2600
2601    pGPP_original->mach.LidOpenWakeDc=PowerSystemWorking;
2602     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2603     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2604         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
2605     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
2606    ret = ValidatePowerPolicies(&gpp,&pp);
2607    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
2608    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
2609    ok(compare(pp,pp_compare),"Difference Found\n");
2610
2611    pGPP_original->mach.LidOpenWakeDc=PowerSystemSleeping1;
2612     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2613     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2614         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
2615     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
2616    ret = ValidatePowerPolicies(&gpp,&pp);
2617    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
2618    gpp_compare.mach.LidOpenWakeDc=4;
2619    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
2620    ok(compare(pp,pp_compare),"Difference Found\n");
2621
2622    pGPP_original->mach.LidOpenWakeDc=PowerSystemSleeping2;
2623     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2624     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2625         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
2626     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
2627    ret = ValidatePowerPolicies(&gpp,&pp);
2628    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
2629    gpp_compare.mach.LidOpenWakeDc=4;
2630    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
2631    ok(compare(pp,pp_compare),"Difference Found\n");
2632
2633    pGPP_original->mach.LidOpenWakeDc=PowerSystemSleeping3;
2634     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2635     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2636         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
2637     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
2638    ret = ValidatePowerPolicies(&gpp,&pp);
2639    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
2640    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
2641    ok(compare(pp,pp_compare),"Difference Found\n");
2642
2643    pGPP_original->mach.LidOpenWakeDc=PowerSystemHibernate;
2644     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2645     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2646         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
2647     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
2648    ret = ValidatePowerPolicies(&gpp,&pp);
2649    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
2650    gpp_compare.mach.LidOpenWakeDc=4;
2651    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
2652    ok(compare(pp,pp_compare),"Difference Found\n");
2653
2654    pGPP_original->mach.LidOpenWakeDc=PowerSystemShutdown;
2655     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2656     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2657         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
2658     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
2659    ret = ValidatePowerPolicies(&gpp,&pp);
2660    ok(!ret, "function was expected to fail\n");
2661    ok(GetLastError() == ERROR_GEN_FAILURE, "expected ERROR_GEN_FAILURE but got %i\n",(UINT)GetLastError());
2662    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
2663    ok(compare(pp,pp_compare),"Difference Found\n");
2664
2665    pGPP_original->mach.LidOpenWakeDc=PowerSystemMaximum;
2666     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2667     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2668         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
2669     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
2670    ret = ValidatePowerPolicies(&gpp,&pp);
2671    ok(!ret, "function was expected to fail\n");
2672    ok(GetLastError() == ERROR_GEN_FAILURE, "expected ERROR_GEN_FAILURE but got %i\n",(UINT)GetLastError());
2673    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
2674    ok(compare(pp,pp_compare),"Difference Found\n");
2675
2676    pGPP_original->mach.LidOpenWakeDc=PowerSystemMaximum+1;
2677     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2678     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2679         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
2680     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
2681    ret = ValidatePowerPolicies(&gpp,&pp);
2682    ok(!ret, "function was expected to fail\n");
2683    ok(GetLastError() == ERROR_GEN_FAILURE, "expected ERROR_GEN_FAILURE but got %i\n",(UINT)GetLastError());
2684    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
2685    ok(compare(pp,pp_compare),"Difference Found\n");
2686
2687    pGPP_original->mach.LidOpenWakeDc=PowerSystemMaximum+2;
2688     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2689     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2690         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
2691     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
2692    ret = ValidatePowerPolicies(&gpp,&pp);
2693    ok(!ret, "function was expected to fail\n");
2694    ok(GetLastError() == ERROR_GEN_FAILURE, "expected ERROR_GEN_FAILURE but got %i\n",(UINT)GetLastError());
2695    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
2696    ok(compare(pp,pp_compare),"Difference Found\n");
2697    pGPP_original->mach.LidOpenWakeDc=PowerSystemWorking;
2698
2699    pGPP_original->user.LidCloseAc.Action=PowerActionNone-2;
2700     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2701     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2702         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
2703     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
2704    ret = ValidatePowerPolicies(&gpp,&pp);
2705    ok(!ret, "function was expected to fail\n");
2706    ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %x\n",(UINT)GetLastError());
2707    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
2708    ok(compare(pp,pp_compare),"Difference Found\n");
2709
2710    pGPP_original->user.LidCloseAc.Action=PowerActionNone-1;
2711     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2712     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2713         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
2714     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
2715    ret = ValidatePowerPolicies(&gpp,&pp);
2716    ok(!ret, "function was expected to fail\n");
2717    ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %x\n",(UINT)GetLastError());
2718    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
2719    ok(compare(pp,pp_compare),"Difference Found\n");
2720
2721    pGPP_original->user.LidCloseAc.Action=PowerActionNone;
2722     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2723     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2724         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
2725     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
2726    ret = ValidatePowerPolicies(&gpp,&pp);
2727    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
2728    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
2729    ok(compare(pp,pp_compare),"Difference Found\n");
2730
2731    pGPP_original->user.LidCloseAc.Action=PowerActionReserved;
2732     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2733     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2734         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
2735     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
2736    ret = ValidatePowerPolicies(&gpp,&pp);
2737    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
2738    gpp_compare.user.LidCloseAc.Action=2;
2739    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
2740    ok(compare(pp,pp_compare),"Difference Found\n");
2741
2742    pGPP_original->user.LidCloseAc.Action=PowerActionSleep;
2743     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2744     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2745         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
2746     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
2747    ret = ValidatePowerPolicies(&gpp,&pp);
2748    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
2749    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
2750    ok(compare(pp,pp_compare),"Difference Found\n");
2751
2752    pGPP_original->user.LidCloseAc.Action=PowerActionHibernate;
2753     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2754     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2755         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
2756     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
2757    ret = ValidatePowerPolicies(&gpp,&pp);
2758    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
2759    gpp_compare.user.LidCloseAc.Action=2;
2760    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
2761    ok(compare(pp,pp_compare),"Difference Found\n");
2762
2763    pGPP_original->user.LidCloseAc.Action=PowerActionShutdown;
2764     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2765     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2766         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
2767     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
2768    ret = ValidatePowerPolicies(&gpp,&pp);
2769    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
2770    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
2771    ok(compare(pp,pp_compare),"Difference Found\n");
2772
2773    pGPP_original->user.LidCloseAc.Action=PowerActionShutdownReset;
2774     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2775     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2776         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
2777     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
2778    ret = ValidatePowerPolicies(&gpp,&pp);
2779    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
2780    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
2781    ok(compare(pp,pp_compare),"Difference Found\n");
2782
2783    pGPP_original->user.LidCloseAc.Action=PowerActionShutdownOff;
2784     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2785     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2786         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
2787     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
2788    ret = ValidatePowerPolicies(&gpp,&pp);
2789    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
2790    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
2791    ok(compare(pp,pp_compare),"Difference Found\n");
2792
2793    pGPP_original->user.LidCloseAc.Action=PowerActionWarmEject;
2794     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2795     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2796         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
2797     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
2798    ret = ValidatePowerPolicies(&gpp,&pp);
2799    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
2800    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
2801    ok(compare(pp,pp_compare),"Difference Found\n");
2802
2803    pGPP_original->user.LidCloseAc.Action=PowerActionWarmEject+1;
2804     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2805     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2806         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
2807     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
2808    ret = ValidatePowerPolicies(&gpp,&pp);
2809    ok(!ret, "function was expected to fail\n");
2810    ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %i\n",(UINT)GetLastError());
2811    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
2812    ok(compare(pp,pp_compare),"Difference Found\n");
2813
2814    pGPP_original->user.LidCloseAc.Action=PowerActionWarmEject+2;
2815     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2816     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2817         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
2818     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
2819    ret = ValidatePowerPolicies(&gpp,&pp);
2820    ok(!ret, "function was expected to fail\n");
2821    ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %i\n",(UINT)GetLastError());
2822    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
2823    ok(compare(pp,pp_compare),"Difference Found\n");
2824   pGPP_original->user.LidCloseAc.Action=PowerActionWarmEject;
2825
2826
2827    pGPP_original->user.LidCloseDc.Action=PowerActionNone-2;
2828     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2829     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2830         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
2831     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
2832    ret = ValidatePowerPolicies(&gpp,&pp);
2833    ok(!ret, "function was expected to fail\n");
2834    ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %x\n",(UINT)GetLastError());
2835    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
2836    ok(compare(pp,pp_compare),"Difference Found\n");
2837
2838    pGPP_original->user.LidCloseDc.Action=PowerActionNone-1;
2839     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2840     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2841         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
2842     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
2843    ret = ValidatePowerPolicies(&gpp,&pp);
2844    ok(!ret, "function was expected to fail\n");
2845    ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %x\n",(UINT)GetLastError());
2846    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
2847    ok(compare(pp,pp_compare),"Difference Found\n");
2848
2849    pGPP_original->user.LidCloseDc.Action=PowerActionNone;
2850     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2851     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2852         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
2853     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
2854    ret = ValidatePowerPolicies(&gpp,&pp);
2855    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
2856    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
2857    ok(compare(pp,pp_compare),"Difference Found\n");
2858
2859    pGPP_original->user.LidCloseDc.Action=PowerActionReserved;
2860     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2861     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2862         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
2863     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
2864    ret = ValidatePowerPolicies(&gpp,&pp);
2865    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
2866    gpp_compare.user.LidCloseDc.Action=2;
2867    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
2868    ok(compare(pp,pp_compare),"Difference Found\n");
2869
2870    pGPP_original->user.LidCloseDc.Action=PowerActionSleep;
2871     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2872     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2873         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
2874     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
2875    ret = ValidatePowerPolicies(&gpp,&pp);
2876    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
2877    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
2878    ok(compare(pp,pp_compare),"Difference Found\n");
2879
2880    pGPP_original->user.LidCloseDc.Action=PowerActionHibernate;
2881     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2882     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2883         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
2884     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
2885    ret = ValidatePowerPolicies(&gpp,&pp);
2886    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
2887    gpp_compare.user.LidCloseDc.Action=2;
2888    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
2889    ok(compare(pp,pp_compare),"Difference Found\n");
2890
2891    pGPP_original->user.LidCloseDc.Action=PowerActionShutdown;
2892     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2893     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2894         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
2895     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
2896    ret = ValidatePowerPolicies(&gpp,&pp);
2897    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
2898    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
2899    ok(compare(pp,pp_compare),"Difference Found\n");
2900
2901    pGPP_original->user.LidCloseDc.Action=PowerActionShutdownReset;
2902     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2903     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2904         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
2905     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
2906    ret = ValidatePowerPolicies(&gpp,&pp);
2907    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
2908    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
2909    ok(compare(pp,pp_compare),"Difference Found\n");
2910
2911    pGPP_original->user.LidCloseDc.Action=PowerActionShutdownOff;
2912     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2913     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2914         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
2915     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
2916    ret = ValidatePowerPolicies(&gpp,&pp);
2917    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
2918    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
2919    ok(compare(pp,pp_compare),"Difference Found\n");
2920
2921    pGPP_original->user.LidCloseDc.Action=PowerActionWarmEject;
2922     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2923     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2924         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
2925     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
2926    ret = ValidatePowerPolicies(&gpp,&pp);
2927    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
2928    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
2929    ok(compare(pp,pp_compare),"Difference Found\n");
2930
2931    pGPP_original->user.LidCloseDc.Action=PowerActionWarmEject+1;
2932     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2933     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2934         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
2935     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
2936    ret = ValidatePowerPolicies(&gpp,&pp);
2937    ok(!ret, "function was expected to fail\n");
2938    ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %i\n",(UINT)GetLastError());
2939    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
2940    ok(compare(pp,pp_compare),"Difference Found\n");
2941
2942    pGPP_original->user.LidCloseDc.Action=PowerActionWarmEject+2;
2943     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2944     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2945         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
2946     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
2947    ret = ValidatePowerPolicies(&gpp,&pp);
2948    ok(!ret, "function was expected to fail\n");
2949    ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %i\n",(UINT)GetLastError());
2950    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
2951    ok(compare(pp,pp_compare),"Difference Found\n");
2952   pGPP_original->user.LidCloseDc.Action=PowerActionWarmEject;
2953
2954
2955    pGPP_original->user.PowerButtonAc.Action=PowerActionNone-2;
2956     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2957     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2958         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
2959     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
2960    ret = ValidatePowerPolicies(&gpp,&pp);
2961    ok(!ret, "function was expected to fail\n");
2962    ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %x\n",(UINT)GetLastError());
2963    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
2964    ok(compare(pp,pp_compare),"Difference Found\n");
2965
2966    pGPP_original->user.PowerButtonAc.Action=PowerActionNone-1;
2967     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2968     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2969         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
2970     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
2971    ret = ValidatePowerPolicies(&gpp,&pp);
2972    ok(!ret, "function was expected to fail\n");
2973    ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %x\n",(UINT)GetLastError());
2974    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
2975    ok(compare(pp,pp_compare),"Difference Found\n");
2976
2977    pGPP_original->user.PowerButtonAc.Action=PowerActionNone;
2978     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2979     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2980         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
2981     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
2982    ret = ValidatePowerPolicies(&gpp,&pp);
2983    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
2984    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
2985    ok(compare(pp,pp_compare),"Difference Found\n");
2986
2987    pGPP_original->user.PowerButtonAc.Action=PowerActionReserved;
2988     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2989     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
2990         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
2991     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
2992    ret = ValidatePowerPolicies(&gpp,&pp);
2993    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
2994    gpp_compare.user.PowerButtonAc.Action=2;
2995    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
2996    ok(compare(pp,pp_compare),"Difference Found\n");
2997
2998    pGPP_original->user.PowerButtonAc.Action=PowerActionSleep;
2999     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3000     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3001         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3002     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3003    ret = ValidatePowerPolicies(&gpp,&pp);
3004    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
3005    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3006    ok(compare(pp,pp_compare),"Difference Found\n");
3007
3008    pGPP_original->user.PowerButtonAc.Action=PowerActionHibernate;
3009     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3010     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3011         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3012     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3013    ret = ValidatePowerPolicies(&gpp,&pp);
3014    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
3015    gpp_compare.user.PowerButtonAc.Action=2;
3016    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3017    ok(compare(pp,pp_compare),"Difference Found\n");
3018
3019    pGPP_original->user.PowerButtonAc.Action=PowerActionShutdown;
3020     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3021     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3022         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3023     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3024    ret = ValidatePowerPolicies(&gpp,&pp);
3025    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
3026    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3027    ok(compare(pp,pp_compare),"Difference Found\n");
3028
3029    pGPP_original->user.PowerButtonAc.Action=PowerActionShutdownReset;
3030     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3031     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3032         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3033     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3034    ret = ValidatePowerPolicies(&gpp,&pp);
3035    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
3036    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3037    ok(compare(pp,pp_compare),"Difference Found\n");
3038
3039    pGPP_original->user.PowerButtonAc.Action=PowerActionShutdownOff;
3040     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3041     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3042         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3043     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3044    ret = ValidatePowerPolicies(&gpp,&pp);
3045    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
3046    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3047    ok(compare(pp,pp_compare),"Difference Found\n");
3048
3049    pGPP_original->user.PowerButtonAc.Action=PowerActionWarmEject;
3050     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3051     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3052         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3053     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3054    ret = ValidatePowerPolicies(&gpp,&pp);
3055    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
3056    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3057    ok(compare(pp,pp_compare),"Difference Found\n");
3058
3059    pGPP_original->user.PowerButtonAc.Action=PowerActionWarmEject+1;
3060     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3061     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3062         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3063     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3064    ret = ValidatePowerPolicies(&gpp,&pp);
3065    ok(!ret, "function was expected to fail\n");
3066    ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %i\n",(UINT)GetLastError());
3067    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3068    ok(compare(pp,pp_compare),"Difference Found\n");
3069
3070    pGPP_original->user.PowerButtonAc.Action=PowerActionWarmEject+2;
3071     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3072     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3073         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3074     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3075    ret = ValidatePowerPolicies(&gpp,&pp);
3076    ok(!ret, "function was expected to fail\n");
3077    ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %i\n",(UINT)GetLastError());
3078    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3079    ok(compare(pp,pp_compare),"Difference Found\n");
3080   pGPP_original->user.PowerButtonAc.Action=PowerActionNone;
3081
3082
3083    pGPP_original->user.PowerButtonDc.Action=PowerActionNone-2;
3084     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3085     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3086         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3087     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3088    ret = ValidatePowerPolicies(&gpp,&pp);
3089    ok(!ret, "function was expected to fail\n");
3090    ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %x\n",(UINT)GetLastError());
3091    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3092    ok(compare(pp,pp_compare),"Difference Found\n");
3093
3094    pGPP_original->user.PowerButtonDc.Action=PowerActionNone-1;
3095     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3096     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3097         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3098     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3099    ret = ValidatePowerPolicies(&gpp,&pp);
3100    ok(!ret, "function was expected to fail\n");
3101    ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %x\n",(UINT)GetLastError());
3102    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3103    ok(compare(pp,pp_compare),"Difference Found\n");
3104
3105    pGPP_original->user.PowerButtonDc.Action=PowerActionNone;
3106     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3107     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3108         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3109     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3110    ret = ValidatePowerPolicies(&gpp,&pp);
3111    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
3112    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3113    ok(compare(pp,pp_compare),"Difference Found\n");
3114
3115    pGPP_original->user.PowerButtonDc.Action=PowerActionReserved;
3116     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3117     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3118         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3119     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3120    ret = ValidatePowerPolicies(&gpp,&pp);
3121    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
3122    gpp_compare.user.PowerButtonDc.Action=2;
3123    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3124    ok(compare(pp,pp_compare),"Difference Found\n");
3125
3126    pGPP_original->user.PowerButtonDc.Action=PowerActionSleep;
3127     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3128     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3129         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3130     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3131    ret = ValidatePowerPolicies(&gpp,&pp);
3132    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
3133    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3134    ok(compare(pp,pp_compare),"Difference Found\n");
3135
3136    pGPP_original->user.PowerButtonDc.Action=PowerActionHibernate;
3137     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3138     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3139         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3140     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3141    ret = ValidatePowerPolicies(&gpp,&pp);
3142    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
3143    gpp_compare.user.PowerButtonDc.Action=2;
3144    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3145    ok(compare(pp,pp_compare),"Difference Found\n");
3146
3147    pGPP_original->user.PowerButtonDc.Action=PowerActionShutdown;
3148     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3149     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3150         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3151     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3152    ret = ValidatePowerPolicies(&gpp,&pp);
3153    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
3154    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3155    ok(compare(pp,pp_compare),"Difference Found\n");
3156
3157    pGPP_original->user.PowerButtonDc.Action=PowerActionShutdownReset;
3158     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3159     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3160         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3161     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3162    ret = ValidatePowerPolicies(&gpp,&pp);
3163    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
3164    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3165    ok(compare(pp,pp_compare),"Difference Found\n");
3166
3167    pGPP_original->user.PowerButtonDc.Action=PowerActionShutdownOff;
3168     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3169     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3170         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3171     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3172    ret = ValidatePowerPolicies(&gpp,&pp);
3173    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
3174    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3175    ok(compare(pp,pp_compare),"Difference Found\n");
3176
3177    pGPP_original->user.PowerButtonDc.Action=PowerActionWarmEject;
3178     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3179     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3180         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3181     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3182    ret = ValidatePowerPolicies(&gpp,&pp);
3183    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
3184    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3185    ok(compare(pp,pp_compare),"Difference Found\n");
3186
3187    pGPP_original->user.PowerButtonDc.Action=PowerActionWarmEject+1;
3188     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3189     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3190         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3191     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3192    ret = ValidatePowerPolicies(&gpp,&pp);
3193    ok(!ret, "function was expected to fail\n");
3194    ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %i\n",(UINT)GetLastError());
3195    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3196    ok(compare(pp,pp_compare),"Difference Found\n");
3197
3198    pGPP_original->user.PowerButtonDc.Action=PowerActionWarmEject+2;
3199     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3200     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3201         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3202     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3203    ret = ValidatePowerPolicies(&gpp,&pp);
3204    ok(!ret, "function was expected to fail\n");
3205    ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %i\n",(UINT)GetLastError());
3206    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3207    ok(compare(pp,pp_compare),"Difference Found\n");
3208   pGPP_original->user.PowerButtonDc.Action=PowerActionWarmEject;
3209
3210
3211    pGPP_original->user.SleepButtonAc.Action=PowerActionNone-2;
3212     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3213     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3214         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3215     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3216    ret = ValidatePowerPolicies(&gpp,&pp);
3217    ok(!ret, "function was expected to fail\n");
3218    ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %x\n",(UINT)GetLastError());
3219    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3220    ok(compare(pp,pp_compare),"Difference Found\n");
3221
3222    pGPP_original->user.SleepButtonAc.Action=PowerActionNone-1;
3223     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3224     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3225         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3226     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3227    ret = ValidatePowerPolicies(&gpp,&pp);
3228    ok(!ret, "function was expected to fail\n");
3229    ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %x\n",(UINT)GetLastError());
3230    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3231    ok(compare(pp,pp_compare),"Difference Found\n");
3232
3233    pGPP_original->user.SleepButtonAc.Action=PowerActionNone;
3234     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3235     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3236         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3237     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3238    ret = ValidatePowerPolicies(&gpp,&pp);
3239    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
3240    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3241    ok(compare(pp,pp_compare),"Difference Found\n");
3242
3243    pGPP_original->user.SleepButtonAc.Action=PowerActionReserved;
3244     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3245     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3246         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3247     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3248    ret = ValidatePowerPolicies(&gpp,&pp);
3249    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
3250    gpp_compare.user.SleepButtonAc.Action=2;
3251    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3252    ok(compare(pp,pp_compare),"Difference Found\n");
3253
3254    pGPP_original->user.SleepButtonAc.Action=PowerActionSleep;
3255     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3256     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3257         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3258     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3259    ret = ValidatePowerPolicies(&gpp,&pp);
3260    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
3261    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3262    ok(compare(pp,pp_compare),"Difference Found\n");
3263
3264    pGPP_original->user.SleepButtonAc.Action=PowerActionHibernate;
3265     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3266     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3267         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3268     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3269    ret = ValidatePowerPolicies(&gpp,&pp);
3270    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
3271    gpp_compare.user.SleepButtonAc.Action=2;
3272    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3273    ok(compare(pp,pp_compare),"Difference Found\n");
3274
3275    pGPP_original->user.SleepButtonAc.Action=PowerActionShutdown;
3276     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3277     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3278         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3279     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3280    ret = ValidatePowerPolicies(&gpp,&pp);
3281    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
3282    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3283    ok(compare(pp,pp_compare),"Difference Found\n");
3284
3285    pGPP_original->user.SleepButtonAc.Action=PowerActionShutdownReset;
3286     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3287     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3288         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3289     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3290    ret = ValidatePowerPolicies(&gpp,&pp);
3291    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
3292    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3293    ok(compare(pp,pp_compare),"Difference Found\n");
3294
3295    pGPP_original->user.SleepButtonAc.Action=PowerActionShutdownOff;
3296     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3297     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3298         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3299     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3300    ret = ValidatePowerPolicies(&gpp,&pp);
3301    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
3302    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3303    ok(compare(pp,pp_compare),"Difference Found\n");
3304
3305    pGPP_original->user.SleepButtonAc.Action=PowerActionWarmEject;
3306     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3307     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3308         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3309     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3310    ret = ValidatePowerPolicies(&gpp,&pp);
3311    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
3312    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3313    ok(compare(pp,pp_compare),"Difference Found\n");
3314
3315    pGPP_original->user.SleepButtonAc.Action=PowerActionWarmEject+1;
3316     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3317     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3318         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3319     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3320    ret = ValidatePowerPolicies(&gpp,&pp);
3321    ok(!ret, "function was expected to fail\n");
3322    ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %i\n",(UINT)GetLastError());
3323    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3324    ok(compare(pp,pp_compare),"Difference Found\n");
3325
3326    pGPP_original->user.SleepButtonAc.Action=PowerActionWarmEject+2;
3327     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3328     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3329         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3330     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3331    ret = ValidatePowerPolicies(&gpp,&pp);
3332    ok(!ret, "function was expected to fail\n");
3333    ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %i\n",(UINT)GetLastError());
3334    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3335    ok(compare(pp,pp_compare),"Difference Found\n");
3336   pGPP_original->user.SleepButtonAc.Action=PowerActionWarmEject;
3337
3338
3339    pGPP_original->user.SleepButtonDc.Action=PowerActionNone-2;
3340     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3341     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3342         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3343     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3344    ret = ValidatePowerPolicies(&gpp,&pp);
3345    ok(!ret, "function was expected to fail\n");
3346    ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %x\n",(UINT)GetLastError());
3347    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3348    ok(compare(pp,pp_compare),"Difference Found\n");
3349
3350    pGPP_original->user.SleepButtonDc.Action=PowerActionNone-1;
3351     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3352     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3353         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3354     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3355    ret = ValidatePowerPolicies(&gpp,&pp);
3356    ok(!ret, "function was expected to fail\n");
3357    ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %x\n",(UINT)GetLastError());
3358    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3359    ok(compare(pp,pp_compare),"Difference Found\n");
3360
3361    pGPP_original->user.SleepButtonDc.Action=PowerActionNone;
3362     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3363     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3364         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3365     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3366    ret = ValidatePowerPolicies(&gpp,&pp);
3367    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
3368    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3369    ok(compare(pp,pp_compare),"Difference Found\n");
3370
3371    pGPP_original->user.SleepButtonDc.Action=PowerActionReserved;
3372     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3373     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3374         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3375     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3376    ret = ValidatePowerPolicies(&gpp,&pp);
3377    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
3378    gpp_compare.user.SleepButtonDc.Action=2;
3379    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3380    ok(compare(pp,pp_compare),"Difference Found\n");
3381
3382    pGPP_original->user.SleepButtonDc.Action=PowerActionSleep;
3383     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3384     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3385         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3386     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3387    ret = ValidatePowerPolicies(&gpp,&pp);
3388    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
3389    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3390    ok(compare(pp,pp_compare),"Difference Found\n");
3391
3392    pGPP_original->user.SleepButtonDc.Action=PowerActionHibernate;
3393     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3394     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3395         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3396     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3397    ret = ValidatePowerPolicies(&gpp,&pp);
3398    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
3399    gpp_compare.user.SleepButtonDc.Action=2;
3400    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3401    ok(compare(pp,pp_compare),"Difference Found\n");
3402
3403    pGPP_original->user.SleepButtonDc.Action=PowerActionShutdown;
3404     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3405     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3406         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3407     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3408    ret = ValidatePowerPolicies(&gpp,&pp);
3409    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
3410    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3411    ok(compare(pp,pp_compare),"Difference Found\n");
3412
3413    pGPP_original->user.SleepButtonDc.Action=PowerActionShutdownReset;
3414     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3415     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3416         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3417     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3418    ret = ValidatePowerPolicies(&gpp,&pp);
3419    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
3420    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3421    ok(compare(pp,pp_compare),"Difference Found\n");
3422
3423    pGPP_original->user.SleepButtonDc.Action=PowerActionShutdownOff;
3424     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3425     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3426         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3427     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3428    ret = ValidatePowerPolicies(&gpp,&pp);
3429    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
3430    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3431    ok(compare(pp,pp_compare),"Difference Found\n");
3432
3433    pGPP_original->user.SleepButtonDc.Action=PowerActionWarmEject;
3434     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3435     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3436         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3437     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3438    ret = ValidatePowerPolicies(&gpp,&pp);
3439    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
3440    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3441    ok(compare(pp,pp_compare),"Difference Found\n");
3442
3443    pGPP_original->user.SleepButtonDc.Action=PowerActionWarmEject+1;
3444     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3445     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3446         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3447     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3448    ret = ValidatePowerPolicies(&gpp,&pp);
3449    ok(!ret, "function was expected to fail\n");
3450    ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %i\n",(UINT)GetLastError());
3451    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3452    ok(compare(pp,pp_compare),"Difference Found\n");
3453
3454    pGPP_original->user.SleepButtonDc.Action=PowerActionWarmEject+2;
3455     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3456     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3457         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3458     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3459    ret = ValidatePowerPolicies(&gpp,&pp);
3460    ok(!ret, "function was expected to fail\n");
3461    ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %i\n",(UINT)GetLastError());
3462    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3463    ok(compare(pp,pp_compare),"Difference Found\n");
3464   pGPP_original->user.SleepButtonDc.Action=PowerActionWarmEject;
3465
3466
3467    pPP_original->mach.MinSleepAc=PowerSystemUnspecified-2;
3468     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3469     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3470         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3471     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3472    ret = ValidatePowerPolicies(&gpp,&pp);
3473    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
3474    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3475    pp_compare.mach.MinSleepAc=4;
3476    ok(compare(pp,pp_compare),"Difference Found\n");
3477
3478    pPP_original->mach.MinSleepAc=PowerSystemUnspecified-1;
3479     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3480     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3481         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3482     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3483    ret = ValidatePowerPolicies(&gpp,&pp);
3484    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
3485    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3486    pp_compare.mach.MinSleepAc=4;
3487    ok(compare(pp,pp_compare),"Difference Found\n");
3488
3489    pPP_original->mach.MinSleepAc=PowerSystemUnspecified;
3490     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3491     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3492         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3493     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3494    ret = ValidatePowerPolicies(&gpp,&pp);
3495    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
3496    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3497    pp_compare.mach.MinSleepAc=4;
3498    ok(compare(pp,pp_compare),"Difference Found\n");
3499
3500    pPP_original->mach.MinSleepAc=PowerSystemWorking;
3501     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3502     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3503         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3504     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3505    ret = ValidatePowerPolicies(&gpp,&pp);
3506    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
3507    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3508    pp_compare.mach.MinSleepAc=4;
3509    ok(compare(pp,pp_compare),"Difference Found\n");
3510
3511    pPP_original->mach.MinSleepAc=PowerSystemSleeping1;
3512     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3513     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3514         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3515     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3516    ret = ValidatePowerPolicies(&gpp,&pp);
3517    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
3518    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3519    pp_compare.mach.MinSleepAc=4;
3520    ok(compare(pp,pp_compare),"Difference Found\n");
3521
3522    pPP_original->mach.MinSleepAc=PowerSystemSleeping2;
3523     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3524     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3525         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3526     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3527    ret = ValidatePowerPolicies(&gpp,&pp);
3528    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
3529    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3530    pp_compare.mach.MinSleepAc=4;
3531    ok(compare(pp,pp_compare),"Difference Found\n");
3532
3533    pPP_original->mach.MinSleepAc=PowerSystemSleeping3;
3534     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3535     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3536         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3537     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3538    ret = ValidatePowerPolicies(&gpp,&pp);
3539    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
3540    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3541    ok(compare(pp,pp_compare),"Difference Found\n");
3542
3543    pPP_original->mach.MinSleepAc=PowerSystemHibernate;
3544     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3545     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3546         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3547     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3548    ret = ValidatePowerPolicies(&gpp,&pp);
3549    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
3550    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3551    pp_compare.mach.MinSleepAc=4;
3552    ok(compare(pp,pp_compare),"Difference Found\n");
3553
3554    pPP_original->mach.MinSleepAc=PowerSystemShutdown;
3555     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3556     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3557         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3558     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3559    ret = ValidatePowerPolicies(&gpp,&pp);
3560    ok(!ret, "function was expected to fail\n");
3561    ok(GetLastError() == ERROR_GEN_FAILURE, "expected ERROR_GEN_FAILURE but got %i\n",(UINT)GetLastError());
3562    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3563    ok(compare(pp,pp_compare),"Difference Found\n");
3564
3565    pPP_original->mach.MinSleepAc=PowerSystemMaximum;
3566     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3567     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3568         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3569     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3570    ret = ValidatePowerPolicies(&gpp,&pp);
3571    ok(!ret, "function was expected to fail\n");
3572    ok(GetLastError() == ERROR_GEN_FAILURE, "expected ERROR_GEN_FAILURE but got %i\n",(UINT)GetLastError());
3573    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3574    ok(compare(pp,pp_compare),"Difference Found\n");
3575
3576    pPP_original->mach.MinSleepAc=PowerSystemMaximum+1;
3577     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3578     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3579         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3580     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3581    ret = ValidatePowerPolicies(&gpp,&pp);
3582    ok(!ret, "function was expected to fail\n");
3583    ok(GetLastError() == ERROR_GEN_FAILURE, "expected ERROR_GEN_FAILURE but got %i\n",(UINT)GetLastError());
3584    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3585    ok(compare(pp,pp_compare),"Difference Found\n");
3586
3587    pPP_original->mach.MinSleepAc=PowerSystemMaximum+2;
3588     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3589     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3590         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3591     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3592    ret = ValidatePowerPolicies(&gpp,&pp);
3593    ok(!ret, "function was expected to fail\n");
3594    ok(GetLastError() == ERROR_GEN_FAILURE, "expected ERROR_GEN_FAILURE but got %i\n",(UINT)GetLastError());
3595    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3596    ok(compare(pp,pp_compare),"Difference Found\n");
3597   pPP_original->mach.MinSleepAc=PowerSystemSleeping3;
3598
3599
3600    pPP_original->mach.MinSleepDc=PowerSystemUnspecified-2;
3601     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3602     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3603         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3604     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3605    ret = ValidatePowerPolicies(&gpp,&pp);
3606    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
3607    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3608    pp_compare.mach.MinSleepDc=4;
3609    ok(compare(pp,pp_compare),"Difference Found\n");
3610
3611    pPP_original->mach.MinSleepDc=PowerSystemUnspecified-1;
3612     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3613     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3614         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3615     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3616    ret = ValidatePowerPolicies(&gpp,&pp);
3617    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
3618    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3619    pp_compare.mach.MinSleepDc=4;
3620    ok(compare(pp,pp_compare),"Difference Found\n");
3621
3622    pPP_original->mach.MinSleepDc=PowerSystemUnspecified;
3623     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3624     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3625         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3626     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3627    ret = ValidatePowerPolicies(&gpp,&pp);
3628    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
3629    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3630    pp_compare.mach.MinSleepDc=4;
3631    ok(compare(pp,pp_compare),"Difference Found\n");
3632
3633    pPP_original->mach.MinSleepDc=PowerSystemWorking;
3634     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3635     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3636         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3637     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3638    ret = ValidatePowerPolicies(&gpp,&pp);
3639    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
3640    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3641    pp_compare.mach.MinSleepDc=4;
3642    ok(compare(pp,pp_compare),"Difference Found\n");
3643
3644    pPP_original->mach.MinSleepDc=PowerSystemSleeping1;
3645     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3646     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3647         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3648     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3649    ret = ValidatePowerPolicies(&gpp,&pp);
3650    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
3651    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3652    pp_compare.mach.MinSleepDc=4;
3653    ok(compare(pp,pp_compare),"Difference Found\n");
3654
3655    pPP_original->mach.MinSleepDc=PowerSystemSleeping2;
3656     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3657     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3658         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3659     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3660    ret = ValidatePowerPolicies(&gpp,&pp);
3661    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
3662    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3663    pp_compare.mach.MinSleepDc=4;
3664    ok(compare(pp,pp_compare),"Difference Found\n");
3665
3666    pPP_original->mach.MinSleepDc=PowerSystemSleeping3;
3667     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3668     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3669         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3670     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3671    ret = ValidatePowerPolicies(&gpp,&pp);
3672    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
3673    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3674    ok(compare(pp,pp_compare),"Difference Found\n");
3675
3676    pPP_original->mach.MinSleepDc=PowerSystemHibernate;
3677     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3678     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3679         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3680     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3681    ret = ValidatePowerPolicies(&gpp,&pp);
3682    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
3683    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3684    pp_compare.mach.MinSleepDc=4;
3685    ok(compare(pp,pp_compare),"Difference Found\n");
3686
3687    pPP_original->mach.MinSleepDc=PowerSystemShutdown;
3688     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3689     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3690         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3691     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3692    ret = ValidatePowerPolicies(&gpp,&pp);
3693    ok(!ret, "function was expected to fail\n");
3694    ok(GetLastError() == ERROR_GEN_FAILURE, "expected ERROR_GEN_FAILURE but got %i\n",(UINT)GetLastError());
3695    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3696    ok(compare(pp,pp_compare),"Difference Found\n");
3697
3698    pPP_original->mach.MinSleepDc=PowerSystemMaximum;
3699     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3700     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3701         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3702     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3703    ret = ValidatePowerPolicies(&gpp,&pp);
3704    ok(!ret, "function was expected to fail\n");
3705    ok(GetLastError() == ERROR_GEN_FAILURE, "expected ERROR_GEN_FAILURE but got %i\n",(UINT)GetLastError());
3706    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3707    ok(compare(pp,pp_compare),"Difference Found\n");
3708
3709    pPP_original->mach.MinSleepDc=PowerSystemMaximum+1;
3710     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3711     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3712         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3713     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3714    ret = ValidatePowerPolicies(&gpp,&pp);
3715    ok(!ret, "function was expected to fail\n");
3716    ok(GetLastError() == ERROR_GEN_FAILURE, "expected ERROR_GEN_FAILURE but got %i\n",(UINT)GetLastError());
3717    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3718    ok(compare(pp,pp_compare),"Difference Found\n");
3719
3720    pPP_original->mach.MinSleepDc=PowerSystemMaximum+2;
3721     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3722     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3723         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3724     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3725    ret = ValidatePowerPolicies(&gpp,&pp);
3726    ok(!ret, "function was expected to fail\n");
3727    ok(GetLastError() == ERROR_GEN_FAILURE, "expected ERROR_GEN_FAILURE but got %i\n",(UINT)GetLastError());
3728    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3729    ok(compare(pp,pp_compare),"Difference Found\n");
3730   pPP_original->mach.MinSleepDc=PowerSystemSleeping3;
3731
3732
3733    pPP_original->mach.OverThrottledAc.Action=PowerActionNone-2;
3734     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3735     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3736         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3737     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3738    ret = ValidatePowerPolicies(&gpp,&pp);
3739    ok(!ret, "function was expected to fail\n");
3740    ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %i\n",(UINT)GetLastError());
3741    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3742    //pp_compare.mach.OverThrottledAc.Action=4;
3743    ok(compare(pp,pp_compare),"Difference Found\n");
3744
3745    pPP_original->mach.OverThrottledAc.Action=PowerActionNone-1;
3746     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3747     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3748         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3749     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3750    ret = ValidatePowerPolicies(&gpp,&pp);
3751    ok(!ret, "function was expected to fail\n");
3752    ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %i\n",(UINT)GetLastError());
3753    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3754    //pp_compare.mach.OverThrottledAc.Action=4;
3755    ok(compare(pp,pp_compare),"Difference Found\n");
3756
3757    pPP_original->mach.OverThrottledAc.Action=PowerActionNone;
3758     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3759     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3760         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3761     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3762    ret = ValidatePowerPolicies(&gpp,&pp);
3763    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
3764    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3765    //pp_compare.mach.OverThrottledAc.Action=4;
3766    ok(compare(pp,pp_compare),"Difference Found\n");
3767
3768    pPP_original->mach.OverThrottledAc.Action=PowerActionReserved;
3769     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3770     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3771         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3772     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3773    ret = ValidatePowerPolicies(&gpp,&pp);
3774    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
3775    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3776    //pp_compare.mach.OverThrottledAc.Action=4;
3777    pp_compare.mach.OverThrottledAc.Action=2;
3778    pp_compare.mach.pad1[2]=2;
3779    ok(compare(pp,pp_compare),"Difference Found\n");
3780
3781    pPP_original->mach.OverThrottledAc.Action=PowerActionSleep;
3782     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3783     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3784         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3785     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3786    ret = ValidatePowerPolicies(&gpp,&pp);
3787    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
3788    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3789    //pp_compare.mach.OverThrottledAc.Action=4;
3790    ok(compare(pp,pp_compare),"Difference Found\n");
3791
3792    pPP_original->mach.OverThrottledAc.Action=PowerActionHibernate;
3793     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3794     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3795         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3796     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3797    ret = ValidatePowerPolicies(&gpp,&pp);
3798    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
3799    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3800    pp_compare.mach.OverThrottledAc.Action=2;
3801    pp_compare.mach.pad1[2]=2;
3802    ok(compare(pp,pp_compare),"Difference Found\n");
3803
3804    pPP_original->mach.OverThrottledAc.Action=PowerActionShutdown;
3805     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3806     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3807         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3808     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3809    ret = ValidatePowerPolicies(&gpp,&pp);
3810    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
3811    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3812    ok(compare(pp,pp_compare),"Difference Found\n");
3813
3814    pPP_original->mach.OverThrottledAc.Action=PowerActionShutdownReset;
3815     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3816     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3817         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3818     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3819    ret = ValidatePowerPolicies(&gpp,&pp);
3820    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
3821    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3822    //pp_compare.mach.OverThrottledAc.Action=4;
3823    ok(compare(pp,pp_compare),"Difference Found\n");
3824
3825    pPP_original->mach.OverThrottledAc.Action=PowerActionShutdownOff;
3826     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3827     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3828         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3829     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3830    ret = ValidatePowerPolicies(&gpp,&pp);
3831    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
3832    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3833    ok(compare(pp,pp_compare),"Difference Found\n");
3834
3835    pPP_original->mach.OverThrottledAc.Action=PowerActionWarmEject;
3836     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3837     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3838         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3839     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3840    ret = ValidatePowerPolicies(&gpp,&pp);
3841    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
3842    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3843    ok(compare(pp,pp_compare),"Difference Found\n");
3844
3845    pPP_original->mach.OverThrottledAc.Action=PowerActionWarmEject+1;
3846     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3847     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3848         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3849     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3850    ret = ValidatePowerPolicies(&gpp,&pp);
3851    ok(!ret, "function was expected to fail\n");
3852    ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %i\n",(UINT)GetLastError());
3853    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3854    ok(compare(pp,pp_compare),"Difference Found\n");
3855
3856    pPP_original->mach.OverThrottledAc.Action=PowerActionWarmEject+2;
3857     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3858     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3859         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3860     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3861    ret = ValidatePowerPolicies(&gpp,&pp);
3862    ok(!ret, "function was expected to fail\n");
3863    ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %i\n",(UINT)GetLastError());
3864    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3865    ok(compare(pp,pp_compare),"Difference Found\n");
3866   pPP_original->mach.OverThrottledAc.Action=PowerActionNone;
3867
3868
3869    pPP_original->mach.OverThrottledDc.Action=PowerActionNone-2;
3870     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3871     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3872         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3873     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3874    ret = ValidatePowerPolicies(&gpp,&pp);
3875    ok(!ret, "function was expected to fail\n");
3876    ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %i\n",(UINT)GetLastError());
3877    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3878    //pp_compare.mach.OverThrottledDc.Action=4;
3879    ok(compare(pp,pp_compare),"Difference Found\n");
3880
3881    pPP_original->mach.OverThrottledDc.Action=PowerActionNone-1;
3882     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3883     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3884         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3885     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3886    ret = ValidatePowerPolicies(&gpp,&pp);
3887    ok(!ret, "function was expected to fail\n");
3888    ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %i\n",(UINT)GetLastError());
3889    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3890    //pp_compare.mach.OverThrottledDc.Action=4;
3891    ok(compare(pp,pp_compare),"Difference Found\n");
3892
3893    pPP_original->mach.OverThrottledDc.Action=PowerActionNone;
3894     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3895     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3896         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3897     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3898    ret = ValidatePowerPolicies(&gpp,&pp);
3899    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
3900    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3901    //pp_compare.mach.OverThrottledDc.Action=4;
3902    ok(compare(pp,pp_compare),"Difference Found\n");
3903
3904    pPP_original->mach.OverThrottledDc.Action=PowerActionReserved;
3905     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3906     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3907         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3908     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3909    ret = ValidatePowerPolicies(&gpp,&pp);
3910    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
3911    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3912    //pp_compare.mach.OverThrottledDc.Action=4;
3913    pp_compare.mach.OverThrottledDc.Action=2;
3914    pp_compare.mach.OverThrottledAc.Action=0;
3915    pp_compare.mach.pad1[2]=0;
3916    ok(compare(pp,pp_compare),"Difference Found\n");
3917
3918    pPP_original->mach.OverThrottledDc.Action=PowerActionSleep;
3919     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3920     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3921         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3922     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3923    ret = ValidatePowerPolicies(&gpp,&pp);
3924    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
3925    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3926    //pp_compare.mach.OverThrottledDc.Action=4;
3927    ok(compare(pp,pp_compare),"Difference Found\n");
3928
3929    pPP_original->mach.OverThrottledDc.Action=PowerActionHibernate;
3930     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3931     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3932         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3933     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3934    ret = ValidatePowerPolicies(&gpp,&pp);
3935    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
3936    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3937    pp_compare.mach.OverThrottledDc.Action=2;
3938    pp_compare.mach.OverThrottledAc.Action=0;
3939    pp_compare.mach.pad1[2]=0;
3940    ok(compare(pp,pp_compare),"Difference Found\n");
3941
3942    pPP_original->mach.OverThrottledDc.Action=PowerActionShutdown;
3943     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3944     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3945         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3946     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3947    ret = ValidatePowerPolicies(&gpp,&pp);
3948    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
3949    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3950    ok(compare(pp,pp_compare),"Difference Found\n");
3951
3952    pPP_original->mach.OverThrottledDc.Action=PowerActionShutdownReset;
3953     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3954     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3955         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3956     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3957    ret = ValidatePowerPolicies(&gpp,&pp);
3958    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
3959    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3960    //pp_compare.mach.OverThrottledDc.Action=4;
3961    ok(compare(pp,pp_compare),"Difference Found\n");
3962
3963    pPP_original->mach.OverThrottledDc.Action=PowerActionShutdownOff;
3964     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3965     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3966         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3967     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3968    ret = ValidatePowerPolicies(&gpp,&pp);
3969    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
3970    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3971    ok(compare(pp,pp_compare),"Difference Found\n");
3972
3973    pPP_original->mach.OverThrottledDc.Action=PowerActionWarmEject;
3974     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3975     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3976         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3977     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3978    ret = ValidatePowerPolicies(&gpp,&pp);
3979    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
3980    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3981    ok(compare(pp,pp_compare),"Difference Found\n");
3982
3983    pPP_original->mach.OverThrottledDc.Action=PowerActionWarmEject+1;
3984     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3985     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3986         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3987     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3988    ret = ValidatePowerPolicies(&gpp,&pp);
3989    ok(!ret, "function was expected to fail\n");
3990    ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %i\n",(UINT)GetLastError());
3991    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
3992    ok(compare(pp,pp_compare),"Difference Found\n");
3993
3994    pPP_original->mach.OverThrottledDc.Action=PowerActionWarmEject+2;
3995     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3996     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
3997         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
3998     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
3999    ret = ValidatePowerPolicies(&gpp,&pp);
4000    ok(!ret, "function was expected to fail\n");
4001    ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %i\n",(UINT)GetLastError());
4002    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4003    ok(compare(pp,pp_compare),"Difference Found\n");
4004   pPP_original->mach.OverThrottledDc.Action=PowerActionNone;
4005
4006
4007      pPP_original->mach.ReducedLatencySleepAc=PowerSystemUnspecified-2;
4008     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4009     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4010         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4011     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4012    ret = ValidatePowerPolicies(&gpp,&pp);
4013    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
4014    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4015    //pp_compare.mach.ReducedLatencySleepAc=4;
4016    ok(compare(pp,pp_compare),"Difference Found\n");
4017
4018    pPP_original->mach.ReducedLatencySleepAc=PowerSystemUnspecified-1;
4019     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4020     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4021         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4022     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4023    ret = ValidatePowerPolicies(&gpp,&pp);
4024    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
4025    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4026    //pp_compare.mach.ReducedLatencySleepAc=4;
4027    ok(compare(pp,pp_compare),"Difference Found\n");
4028
4029    pPP_original->mach.ReducedLatencySleepAc=PowerSystemUnspecified;
4030     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4031     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4032         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4033     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4034    ret = ValidatePowerPolicies(&gpp,&pp);
4035    ok(!ret, "function was expected to fail\n");
4036    ok(GetLastError() == ERROR_GEN_FAILURE, "expected ERROR_GEN_FAILURE but got %x\n",(UINT)GetLastError());
4037    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4038    //pp_compare.mach.ReducedLatencySleepAc=4;
4039    ok(compare(pp,pp_compare),"Difference Found\n");
4040
4041    pPP_original->mach.ReducedLatencySleepAc=PowerSystemWorking;
4042     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4043     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4044         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4045     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4046    ret = ValidatePowerPolicies(&gpp,&pp);
4047    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
4048    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4049    //pp_compare.mach.ReducedLatencySleepAc=4;
4050    ok(compare(pp,pp_compare),"Difference Found\n");
4051
4052    pPP_original->mach.ReducedLatencySleepAc=PowerSystemSleeping1;
4053     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4054     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4055         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4056     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4057    ret = ValidatePowerPolicies(&gpp,&pp);
4058    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
4059    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4060    pp_compare.mach.ReducedLatencySleepAc=4;
4061    ok(compare(pp,pp_compare),"Difference Found\n");
4062
4063    pPP_original->mach.ReducedLatencySleepAc=PowerSystemSleeping2;
4064     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4065     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4066         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4067     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4068    ret = ValidatePowerPolicies(&gpp,&pp);
4069    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
4070    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4071    pp_compare.mach.ReducedLatencySleepAc=4;
4072    ok(compare(pp,pp_compare),"Difference Found\n");
4073
4074    pPP_original->mach.ReducedLatencySleepAc=PowerSystemSleeping3;
4075     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4076     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4077         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4078     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4079    ret = ValidatePowerPolicies(&gpp,&pp);
4080    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
4081    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4082    ok(compare(pp,pp_compare),"Difference Found\n");
4083
4084    pPP_original->mach.ReducedLatencySleepAc=PowerSystemHibernate;
4085     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4086     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4087         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4088     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4089    ret = ValidatePowerPolicies(&gpp,&pp);
4090    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
4091    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4092    pp_compare.mach.ReducedLatencySleepAc=4;
4093    ok(compare(pp,pp_compare),"Difference Found\n");
4094
4095    pPP_original->mach.ReducedLatencySleepAc=PowerSystemShutdown;
4096     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4097     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4098         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4099     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4100    ret = ValidatePowerPolicies(&gpp,&pp);
4101    ok(!ret, "function was expected to fail\n");
4102    ok(GetLastError() == ERROR_GEN_FAILURE, "expected ERROR_GEN_FAILURE but got %x\n",(UINT)GetLastError());
4103    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4104    ok(compare(pp,pp_compare),"Difference Found\n");
4105
4106    pPP_original->mach.ReducedLatencySleepAc=PowerSystemMaximum;
4107     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4108     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4109         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4110     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4111    ret = ValidatePowerPolicies(&gpp,&pp);
4112    ok(!ret, "function was expected to fail\n");
4113    ok(GetLastError() == ERROR_GEN_FAILURE, "expected ERROR_GEN_FAILURE but got %x\n",(UINT)GetLastError());
4114    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4115    ok(compare(pp,pp_compare),"Difference Found\n");
4116
4117    pPP_original->mach.ReducedLatencySleepAc=PowerSystemMaximum+1;
4118     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4119     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4120         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4121     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4122    ret = ValidatePowerPolicies(&gpp,&pp);
4123    ok(!ret, "function was expected to fail\n");
4124    ok(GetLastError() == ERROR_GEN_FAILURE, "expected ERROR_GEN_FAILURE but got %x\n",(UINT)GetLastError());
4125    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4126    ok(compare(pp,pp_compare),"Difference Found\n");
4127
4128    pPP_original->mach.ReducedLatencySleepAc=PowerSystemMaximum+2;
4129     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4130     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4131         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4132     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4133    ret = ValidatePowerPolicies(&gpp,&pp);
4134    ok(!ret, "function was expected to fail\n");
4135    ok(GetLastError() == ERROR_GEN_FAILURE, "expected ERROR_GEN_FAILURE but got %x\n",(UINT)GetLastError());
4136    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4137    ok(compare(pp,pp_compare),"Difference Found\n");
4138   pPP_original->mach.ReducedLatencySleepAc=PowerSystemWorking;
4139
4140
4141      pPP_original->mach.ReducedLatencySleepDc=PowerSystemUnspecified-2;
4142     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4143     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4144         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4145     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4146    ret = ValidatePowerPolicies(&gpp,&pp);
4147    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
4148    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4149    //pp_compare.mach.ReducedLatencySleepDc=4;
4150    ok(compare(pp,pp_compare),"Difference Found\n");
4151
4152    pPP_original->mach.ReducedLatencySleepDc=PowerSystemUnspecified-1;
4153     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4154     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4155         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4156     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4157    ret = ValidatePowerPolicies(&gpp,&pp);
4158    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
4159    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4160    //pp_compare.mach.ReducedLatencySleepDc=4;
4161    ok(compare(pp,pp_compare),"Difference Found\n");
4162
4163    pPP_original->mach.ReducedLatencySleepDc=PowerSystemUnspecified;
4164     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4165     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4166         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4167     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4168    ret = ValidatePowerPolicies(&gpp,&pp);
4169    ok(!ret, "function was expected to fail\n");
4170    ok(GetLastError() == ERROR_GEN_FAILURE, "expected ERROR_GEN_FAILURE but got %x\n",(UINT)GetLastError());
4171    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4172    //pp_compare.mach.ReducedLatencySleepDc=4;
4173    ok(compare(pp,pp_compare),"Difference Found\n");
4174
4175    pPP_original->mach.ReducedLatencySleepDc=PowerSystemWorking;
4176     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4177     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4178         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4179     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4180    ret = ValidatePowerPolicies(&gpp,&pp);
4181    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
4182    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4183    //pp_compare.mach.ReducedLatencySleepDc=4;
4184    ok(compare(pp,pp_compare),"Difference Found\n");
4185
4186    pPP_original->mach.ReducedLatencySleepDc=PowerSystemSleeping1;
4187     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4188     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4189         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4190     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4191    ret = ValidatePowerPolicies(&gpp,&pp);
4192    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
4193    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4194    pp_compare.mach.ReducedLatencySleepDc=4;
4195    ok(compare(pp,pp_compare),"Difference Found\n");
4196
4197    pPP_original->mach.ReducedLatencySleepDc=PowerSystemSleeping2;
4198     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4199     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4200         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4201     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4202    ret = ValidatePowerPolicies(&gpp,&pp);
4203    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
4204    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4205    pp_compare.mach.ReducedLatencySleepDc=4;
4206    ok(compare(pp,pp_compare),"Difference Found\n");
4207
4208    pPP_original->mach.ReducedLatencySleepDc=PowerSystemSleeping3;
4209     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4210     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4211         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4212     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4213    ret = ValidatePowerPolicies(&gpp,&pp);
4214    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
4215    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4216    ok(compare(pp,pp_compare),"Difference Found\n");
4217
4218    pPP_original->mach.ReducedLatencySleepDc=PowerSystemHibernate;
4219     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4220     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4221         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4222     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4223    ret = ValidatePowerPolicies(&gpp,&pp);
4224    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
4225    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4226    pp_compare.mach.ReducedLatencySleepDc=4;
4227    ok(compare(pp,pp_compare),"Difference Found\n");
4228
4229    pPP_original->mach.ReducedLatencySleepDc=PowerSystemShutdown;
4230     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4231     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4232         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4233     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4234    ret = ValidatePowerPolicies(&gpp,&pp);
4235    ok(!ret, "function was expected to fail\n");
4236    ok(GetLastError() == ERROR_GEN_FAILURE, "expected ERROR_GEN_FAILURE but got %x\n",(UINT)GetLastError());
4237    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4238    ok(compare(pp,pp_compare),"Difference Found\n");
4239
4240    pPP_original->mach.ReducedLatencySleepDc=PowerSystemMaximum;
4241     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4242     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4243         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4244     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4245    ret = ValidatePowerPolicies(&gpp,&pp);
4246    ok(!ret, "function was expected to fail\n");
4247    ok(GetLastError() == ERROR_GEN_FAILURE, "expected ERROR_GEN_FAILURE but got %x\n",(UINT)GetLastError());
4248    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4249    ok(compare(pp,pp_compare),"Difference Found\n");
4250
4251    pPP_original->mach.ReducedLatencySleepDc=PowerSystemMaximum+1;
4252     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4253     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4254         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4255     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4256    ret = ValidatePowerPolicies(&gpp,&pp);
4257    ok(!ret, "function was expected to fail\n");
4258    ok(GetLastError() == ERROR_GEN_FAILURE, "expected ERROR_GEN_FAILURE but got %x\n",(UINT)GetLastError());
4259    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4260    ok(compare(pp,pp_compare),"Difference Found\n");
4261
4262    pPP_original->mach.ReducedLatencySleepDc=PowerSystemMaximum+2;
4263     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4264     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4265         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4266     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4267    ret = ValidatePowerPolicies(&gpp,&pp);
4268    ok(!ret, "function was expected to fail\n");
4269    ok(GetLastError() == ERROR_GEN_FAILURE, "expected ERROR_GEN_FAILURE but got %x\n",(UINT)GetLastError());
4270    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4271    ok(compare(pp,pp_compare),"Difference Found\n");
4272   pPP_original->mach.ReducedLatencySleepDc=PowerSystemWorking;
4273
4274
4275    pPP_original->user.IdleAc.Action=PowerActionNone-2;
4276     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4277     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4278         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4279     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4280    ret = ValidatePowerPolicies(&gpp,&pp);
4281    ok(!ret, "function was expected to fail\n");
4282    ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %i\n",(UINT)GetLastError());
4283    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4284    //pp_compare.user.IdleAc.Action=4;
4285    ok(compare(pp,pp_compare),"Difference Found\n");
4286
4287    pPP_original->user.IdleAc.Action=PowerActionNone-1;
4288     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4289     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4290         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4291     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4292    ret = ValidatePowerPolicies(&gpp,&pp);
4293    ok(!ret, "function was expected to fail\n");
4294    ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %i\n",(UINT)GetLastError());
4295    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4296    //pp_compare.user.IdleAc.Action=4;
4297    ok(compare(pp,pp_compare),"Difference Found\n");
4298
4299    pPP_original->user.IdleAc.Action=PowerActionNone;
4300     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4301     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4302         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4303     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4304    ret = ValidatePowerPolicies(&gpp,&pp);
4305    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
4306    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4307    //pp_compare.user.IdleAc.Action=4;
4308    ok(compare(pp,pp_compare),"Difference Found\n");
4309
4310    pPP_original->user.IdleAc.Action=PowerActionReserved;
4311     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4312     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4313         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4314     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4315    ret = ValidatePowerPolicies(&gpp,&pp);
4316    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
4317    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4318    //pp_compare.user.IdleAc.Action=4;
4319    pp_compare.user.IdleAc.Action=2;
4320    //pp_compare.user.pad1[2]=2;
4321    ok(compare(pp,pp_compare),"Difference Found\n");
4322
4323    pPP_original->user.IdleAc.Action=PowerActionSleep;
4324     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4325     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4326         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4327     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4328    ret = ValidatePowerPolicies(&gpp,&pp);
4329    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
4330    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4331    //pp_compare.user.IdleAc.Action=4;
4332    ok(compare(pp,pp_compare),"Difference Found\n");
4333
4334    pPP_original->user.IdleAc.Action=PowerActionHibernate;
4335     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4336     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4337         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4338     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4339    ret = ValidatePowerPolicies(&gpp,&pp);
4340    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
4341    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4342    pp_compare.user.IdleAc.Action=2;
4343    //pp_compare.user.pad1[2]=2;
4344    ok(compare(pp,pp_compare),"Difference Found\n");
4345
4346    pPP_original->user.IdleAc.Action=PowerActionShutdown;
4347     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4348     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4349         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4350     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4351    ret = ValidatePowerPolicies(&gpp,&pp);
4352    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
4353    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4354    ok(compare(pp,pp_compare),"Difference Found\n");
4355
4356    pPP_original->user.IdleAc.Action=PowerActionShutdownReset;
4357     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4358     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4359         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4360     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4361    ret = ValidatePowerPolicies(&gpp,&pp);
4362    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
4363    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4364    //pp_compare.user.IdleAc.Action=4;
4365    ok(compare(pp,pp_compare),"Difference Found\n");
4366
4367    pPP_original->user.IdleAc.Action=PowerActionShutdownOff;
4368     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4369     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4370         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4371     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4372    ret = ValidatePowerPolicies(&gpp,&pp);
4373    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
4374    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4375    ok(compare(pp,pp_compare),"Difference Found\n");
4376
4377    pPP_original->user.IdleAc.Action=PowerActionWarmEject;
4378     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4379     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4380         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4381     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4382    ret = ValidatePowerPolicies(&gpp,&pp);
4383    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
4384    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4385    ok(compare(pp,pp_compare),"Difference Found\n");
4386
4387    pPP_original->user.IdleAc.Action=PowerActionWarmEject+1;
4388     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4389     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4390         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4391     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4392    ret = ValidatePowerPolicies(&gpp,&pp);
4393    ok(!ret, "function was expected to fail\n");
4394    ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %i\n",(UINT)GetLastError());
4395    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4396    ok(compare(pp,pp_compare),"Difference Found\n");
4397
4398    pPP_original->user.IdleAc.Action=PowerActionWarmEject+2;
4399     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4400     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4401         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4402     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4403    ret = ValidatePowerPolicies(&gpp,&pp);
4404    ok(!ret, "function was expected to fail\n");
4405    ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %i\n",(UINT)GetLastError());
4406    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4407    ok(compare(pp,pp_compare),"Difference Found\n");
4408   pPP_original->user.IdleAc.Action=PowerActionNone;
4409
4410
4411
4412    pPP_original->user.IdleDc.Action=PowerActionNone-2;
4413     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4414     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4415         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4416     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4417    ret = ValidatePowerPolicies(&gpp,&pp);
4418    ok(!ret, "function was expected to fail\n");
4419    ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %i\n",(UINT)GetLastError());
4420    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4421    //pp_compare.user.IdleDc.Action=4;
4422    ok(compare(pp,pp_compare),"Difference Found\n");
4423
4424    pPP_original->user.IdleDc.Action=PowerActionNone-1;
4425     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4426     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4427         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4428     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4429    ret = ValidatePowerPolicies(&gpp,&pp);
4430    ok(!ret, "function was expected to fail\n");
4431    ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %i\n",(UINT)GetLastError());
4432    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4433    //pp_compare.user.IdleDc.Action=4;
4434    ok(compare(pp,pp_compare),"Difference Found\n");
4435
4436    pPP_original->user.IdleDc.Action=PowerActionNone;
4437     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4438     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4439         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4440     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4441    ret = ValidatePowerPolicies(&gpp,&pp);
4442    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
4443    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4444    //pp_compare.user.IdleDc.Action=4;
4445    ok(compare(pp,pp_compare),"Difference Found\n");
4446
4447    pPP_original->user.IdleDc.Action=PowerActionReserved;
4448     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4449     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4450         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4451     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4452    ret = ValidatePowerPolicies(&gpp,&pp);
4453    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
4454    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4455    //pp_compare.user.IdleDc.Action=4;
4456    pp_compare.user.IdleDc.Action=2;
4457 //   pp_compare.user.pad1[2]=2;
4458    ok(compare(pp,pp_compare),"Difference Found\n");
4459
4460    pPP_original->user.IdleDc.Action=PowerActionSleep;
4461     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4462     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4463         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4464     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4465    ret = ValidatePowerPolicies(&gpp,&pp);
4466    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
4467    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4468    //pp_compare.user.IdleDc.Action=4;
4469    ok(compare(pp,pp_compare),"Difference Found\n");
4470
4471    pPP_original->user.IdleDc.Action=PowerActionHibernate;
4472     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4473     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4474         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4475     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4476    ret = ValidatePowerPolicies(&gpp,&pp);
4477    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
4478    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4479    pp_compare.user.IdleDc.Action=2;
4480 //   pp_compare.user.pad1[2]=2;
4481    ok(compare(pp,pp_compare),"Difference Found\n");
4482
4483    pPP_original->user.IdleDc.Action=PowerActionShutdown;
4484     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4485     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4486         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4487     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4488    ret = ValidatePowerPolicies(&gpp,&pp);
4489    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
4490    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4491    ok(compare(pp,pp_compare),"Difference Found\n");
4492
4493    pPP_original->user.IdleDc.Action=PowerActionShutdownReset;
4494     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4495     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4496         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4497     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4498    ret = ValidatePowerPolicies(&gpp,&pp);
4499    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
4500    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4501    //pp_compare.user.IdleDc.Action=4;
4502    ok(compare(pp,pp_compare),"Difference Found\n");
4503
4504    pPP_original->user.IdleDc.Action=PowerActionShutdownOff;
4505     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4506     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4507         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4508     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4509    ret = ValidatePowerPolicies(&gpp,&pp);
4510    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
4511    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4512    ok(compare(pp,pp_compare),"Difference Found\n");
4513
4514    pPP_original->user.IdleDc.Action=PowerActionWarmEject;
4515     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4516     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4517         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4518     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4519    ret = ValidatePowerPolicies(&gpp,&pp);
4520    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
4521    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4522    ok(compare(pp,pp_compare),"Difference Found\n");
4523
4524    pPP_original->user.IdleDc.Action=PowerActionWarmEject+1;
4525     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4526     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4527         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4528     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4529    ret = ValidatePowerPolicies(&gpp,&pp);
4530    ok(!ret, "function was expected to fail\n");
4531    ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %i\n",(UINT)GetLastError());
4532    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4533    ok(compare(pp,pp_compare),"Difference Found\n");
4534
4535    pPP_original->user.IdleDc.Action=PowerActionWarmEject+2;
4536     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4537     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4538         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4539     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4540    ret = ValidatePowerPolicies(&gpp,&pp);
4541    ok(!ret, "function was expected to fail\n");
4542    ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %i\n",(UINT)GetLastError());
4543    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4544    ok(compare(pp,pp_compare),"Difference Found\n");
4545   pPP_original->user.IdleDc.Action=PowerActionNone;
4546
4547
4548    pPP_original->user.MaxSleepAc=PowerSystemUnspecified-2;
4549     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4550     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4551         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4552     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4553    ret = ValidatePowerPolicies(&gpp,&pp);
4554    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
4555    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4556    pp_compare.user.MaxSleepAc=4;
4557    ok(compare(pp,pp_compare),"Difference Found\n");
4558
4559    pPP_original->user.MaxSleepAc=PowerSystemUnspecified-1;
4560     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4561     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4562         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4563     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4564    ret = ValidatePowerPolicies(&gpp,&pp);
4565    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
4566    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4567    pp_compare.user.MaxSleepAc=4;
4568    ok(compare(pp,pp_compare),"Difference Found\n");
4569
4570    pPP_original->user.MaxSleepAc=PowerSystemUnspecified;
4571     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4572     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4573         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4574     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4575    ret = ValidatePowerPolicies(&gpp,&pp);
4576    ok(!ret, "function was expected to fail\n");
4577    ok(GetLastError() == ERROR_GEN_FAILURE, "expected ERROR_GEN_FAILURE but got %i\n",(UINT)GetLastError());
4578    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4579    //pp_compare.user.MaxSleepAc=4;
4580    ok(compare(pp,pp_compare),"Difference Found\n");
4581
4582    pPP_original->user.MaxSleepAc=PowerSystemWorking;
4583     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4584     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4585         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4586     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4587    ret = ValidatePowerPolicies(&gpp,&pp);
4588    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
4589    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4590    pp_compare.user.MaxSleepAc=4;
4591    ok(compare(pp,pp_compare),"Difference Found\n");
4592
4593    pPP_original->user.MaxSleepAc=PowerSystemSleeping1;
4594     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4595     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4596         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4597     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4598    ret = ValidatePowerPolicies(&gpp,&pp);
4599    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
4600    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4601    pp_compare.user.MaxSleepAc=4;
4602    ok(compare(pp,pp_compare),"Difference Found\n");
4603
4604    pPP_original->user.MaxSleepAc=PowerSystemSleeping2;
4605     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4606     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4607         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4608     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4609    ret = ValidatePowerPolicies(&gpp,&pp);
4610    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
4611    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4612    pp_compare.user.MaxSleepAc=4;
4613    ok(compare(pp,pp_compare),"Difference Found\n");
4614
4615    pPP_original->user.MaxSleepAc=PowerSystemSleeping3;
4616     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4617     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4618         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4619     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4620    ret = ValidatePowerPolicies(&gpp,&pp);
4621    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
4622    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4623    ok(compare(pp,pp_compare),"Difference Found\n");
4624
4625    pPP_original->user.MaxSleepAc=PowerSystemHibernate;
4626     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4627     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4628         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4629     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4630    ret = ValidatePowerPolicies(&gpp,&pp);
4631    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
4632    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4633    pp_compare.user.MaxSleepAc=4;
4634    pp_compare.user.MaxSleepAc=4;
4635    ok(compare(pp,pp_compare),"Difference Found\n");
4636
4637    pPP_original->user.MaxSleepAc=PowerSystemShutdown;
4638     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4639     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4640         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4641     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4642    ret = ValidatePowerPolicies(&gpp,&pp);
4643    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
4644    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4645    pp_compare.user.MaxSleepAc=4;
4646    ok(compare(pp,pp_compare),"Difference Found\n");
4647
4648    pPP_original->user.MaxSleepAc=PowerSystemMaximum;
4649     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4650     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4651         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4652     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4653    ret = ValidatePowerPolicies(&gpp,&pp);
4654    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
4655    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4656    pp_compare.user.MaxSleepAc=4;
4657    ok(compare(pp,pp_compare),"Difference Found\n");
4658
4659    pPP_original->user.MaxSleepAc=PowerSystemMaximum+1;
4660     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4661     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4662         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4663     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4664    ret = ValidatePowerPolicies(&gpp,&pp);
4665    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
4666    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4667    pp_compare.user.MaxSleepAc=4;
4668    ok(compare(pp,pp_compare),"Difference Found\n");
4669
4670    pPP_original->user.MaxSleepAc=PowerSystemMaximum+2;
4671     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4672     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4673         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4674     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4675    ret = ValidatePowerPolicies(&gpp,&pp);
4676    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
4677    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4678    pp_compare.user.MaxSleepAc=4;
4679    ok(compare(pp,pp_compare),"Difference Found\n");
4680   pPP_original->user.MaxSleepAc=PowerSystemSleeping3;
4681
4682
4683    pPP_original->user.MaxSleepDc=PowerSystemUnspecified-2;
4684     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4685     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4686         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4687     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4688    ret = ValidatePowerPolicies(&gpp,&pp);
4689    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
4690    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4691    pp_compare.user.MaxSleepDc=4;
4692    ok(compare(pp,pp_compare),"Difference Found\n");
4693
4694    pPP_original->user.MaxSleepDc=PowerSystemUnspecified-1;
4695     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4696     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4697         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4698     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4699    ret = ValidatePowerPolicies(&gpp,&pp);
4700    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
4701    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4702    pp_compare.user.MaxSleepDc=4;
4703    ok(compare(pp,pp_compare),"Difference Found\n");
4704
4705    pPP_original->user.MaxSleepDc=PowerSystemUnspecified;
4706     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4707     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4708         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4709     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4710    ret = ValidatePowerPolicies(&gpp,&pp);
4711    ok(!ret, "function was expected to fail\n");
4712    ok(GetLastError() == ERROR_GEN_FAILURE, "expected ERROR_GEN_FAILURE but got %i\n",(UINT)GetLastError());
4713    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4714    //pp_compare.user.MaxSleepDc=4;
4715    ok(compare(pp,pp_compare),"Difference Found\n");
4716
4717    pPP_original->user.MaxSleepDc=PowerSystemWorking;
4718     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4719     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4720         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4721     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4722    ret = ValidatePowerPolicies(&gpp,&pp);
4723    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
4724    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4725    pp_compare.user.MaxSleepDc=4;
4726    ok(compare(pp,pp_compare),"Difference Found\n");
4727
4728    pPP_original->user.MaxSleepDc=PowerSystemSleeping1;
4729     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4730     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4731         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4732     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4733    ret = ValidatePowerPolicies(&gpp,&pp);
4734    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
4735    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4736    pp_compare.user.MaxSleepDc=4;
4737    ok(compare(pp,pp_compare),"Difference Found\n");
4738
4739    pPP_original->user.MaxSleepDc=PowerSystemSleeping2;
4740     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4741     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4742         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4743     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4744    ret = ValidatePowerPolicies(&gpp,&pp);
4745    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
4746    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4747    pp_compare.user.MaxSleepDc=4;
4748    ok(compare(pp,pp_compare),"Difference Found\n");
4749
4750    pPP_original->user.MaxSleepDc=PowerSystemSleeping3;
4751     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4752     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4753         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4754     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4755    ret = ValidatePowerPolicies(&gpp,&pp);
4756    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
4757    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4758    ok(compare(pp,pp_compare),"Difference Found\n");
4759
4760    pPP_original->user.MaxSleepDc=PowerSystemHibernate;
4761     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4762     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4763         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4764     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4765    ret = ValidatePowerPolicies(&gpp,&pp);
4766    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
4767    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4768    pp_compare.user.MaxSleepDc=4;
4769    ok(compare(pp,pp_compare),"Difference Found\n");
4770
4771    pPP_original->user.MaxSleepDc=PowerSystemShutdown;
4772     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4773     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4774         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4775     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4776    ret = ValidatePowerPolicies(&gpp,&pp);
4777    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
4778    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4779    pp_compare.user.MaxSleepDc=4;
4780    ok(compare(pp,pp_compare),"Difference Found\n");
4781
4782    pPP_original->user.MaxSleepDc=PowerSystemMaximum;
4783     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4784     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4785         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4786     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4787    ret = ValidatePowerPolicies(&gpp,&pp);
4788    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
4789    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4790    pp_compare.user.MaxSleepDc=4;
4791    ok(compare(pp,pp_compare),"Difference Found\n");
4792
4793    pPP_original->user.MaxSleepDc=PowerSystemMaximum+1;
4794     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4795     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4796         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4797     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4798    ret = ValidatePowerPolicies(&gpp,&pp);
4799    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
4800    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4801    pp_compare.user.MaxSleepDc=4;
4802    ok(compare(pp,pp_compare),"Difference Found\n");
4803
4804    pPP_original->user.MaxSleepDc=PowerSystemMaximum+2;
4805     memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4806     memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY));
4807         memcpy(&pp, pPP_original, sizeof(POWER_POLICY));
4808     memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY));
4809    ret = ValidatePowerPolicies(&gpp,&pp);
4810    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
4811    ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
4812    pp_compare.user.MaxSleepDc=4;
4813    ok(compare(pp,pp_compare),"Difference Found\n");
4814   pPP_original->user.MaxSleepDc=PowerSystemSleeping3;
4815
4816 }
4817
4818 void test_WriteGlobalPwrPolicy(void)
4819 {
4820 //      WriteGlobalPwrPolicy(&gpp);
4821 }
4822
4823 void test_WriteProcessorPwrScheme(void)
4824 {
4825 //      WriteProcessorPwrScheme(0,&mppp);
4826 }
4827
4828 void test_WritePwrScheme(void)
4829 {
4830    DWORD retval;
4831    HKEY hSubKey;
4832    LONG lSize;
4833    LONG Err;
4834    WCHAR szPath[MAX_PATH];
4835    static const WCHAR szTestSchemeName[] = {'P','o','w','r','p','r','o','f',0};
4836    static const WCHAR szTestSchemeDesc[] = {'P','o','w','r','p','r','o','f',' ','S','c','h','e','m','e',0};
4837
4838    /*
4839     * create a temporarly profile, will be deleted in test_DeletePwrScheme
4840     */
4841
4842    retval = WritePwrScheme(&g_TempPwrScheme, (LPWSTR)szTestSchemeName, (LPWSTR)szTestSchemeDesc, &g_PowerPolicy);
4843    ok(retval, "Warning: function should have succeeded\n");
4844    if (RegOpenKeyW(HKEY_LOCAL_MACHINE, szMachPowerPoliciesSubKey, &hSubKey) == ERROR_SUCCESS)
4845    {
4846            lSize = MAX_PATH * sizeof(WCHAR);
4847            Err = RegQueryValueW(hSubKey, szTempPwrScheme, szPath, &lSize);
4848            if (Err != STATUS_SUCCESS)
4849          printf("#1 failed to query subkey %i (testentry)\n", g_TempPwrScheme);
4850       RegCloseKey(hSubKey);
4851    }
4852
4853 }
4854
4855 void func_power(void)
4856 {
4857    if (1)
4858       skip("CallNtPowerInformation test is broken and fails on Windows\n");
4859    else
4860       test_CallNtPowerInformation();
4861    test_CanUserWritePwrScheme();
4862    test_EnumPwrSchemes();
4863    test_GetSetActivePwrScheme();
4864    test_ReadPwrScheme();
4865    test_WritePwrScheme();
4866    test_DeletePwrScheme();
4867    test_GetPwrDiskSpindownRange();
4868
4869    test_GetCurrentPowerPolicies();
4870
4871    test_GetPwrCapabilities();
4872    test_IsAdminOverrideActive();
4873    test_IsPwrHibernateAllowed();
4874    test_IsPwrShutdownAllowed();
4875    test_IsPwrSuspendAllowed();
4876    test_ReadGlobalPwrPolicy();
4877    test_ReadProcessorPwrScheme();
4878    test_SetSuspendState();
4879    if (1)
4880       skip("ValidatePowerPolicies tests are broken and fail on Windows\n");
4881    else
4882    {
4883       test_ValidatePowerPolicies_Old();
4884       test_ValidatePowerPolicies();
4885    }
4886    test_WriteGlobalPwrPolicy();
4887    test_WriteProcessorPwrScheme();
4888
4889 }