rostests/winetests/powrprof/pwrprof.c

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