rostests/apitests/powrprof/power.c

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