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