Index: winetests/powrprof/pwrprof.c =================================================================== --- winetests/powrprof/pwrprof.c (revision 34091) +++ winetests/powrprof/pwrprof.c (working copy) @@ -8,7 +8,7 @@ #include "winbase.h" #include "powrprof.h" #include "assert.h" - +#include "winnt.h" #include "wine/unicode.h" /* LONG WINAPI RegOpenCurrentUser(REGSAM a,PHKEY b) @@ -69,7 +69,7 @@ retval = CallNtPowerInformation(AdministratorPowerPolicy, 0, 0, &apolicy, sizeof(ADMINISTRATOR_POWER_POLICY)); ok(retval == STATUS_SUCCESS, "function expected STATUS_SUCCESS but got %d\n", (UINT)retval); retval = CallNtPowerInformation(AdministratorPowerPolicy, &apolicy, sizeof(ADMINISTRATOR_POWER_POLICY), 0, 0); - ok(retval != STATUS_PRIVILEGE_NOT_HELD, "Privileg not held!!!! more errors to expect"); + ok(retval != STATUS_PRIVILEGE_NOT_HELD, "Privileg not held!!!! more errors to expect\n"); ok(retval == STATUS_SUCCESS, "function expected STATUS_SUCCESS but got %d\n", (UINT)retval); /* LastSleepTime tests */ @@ -385,7 +385,7 @@ if (RegOpenKeyW(HKEY_LOCAL_MACHINE, szMachPowerPoliciesSubKey, &hSubKey) == ERROR_SUCCESS) { if (RegDeleteKeyW(hSubKey, szTempPwrScheme) != STATUS_SUCCESS) - printf("failed to delete subkey %i (testentry)\n", g_TempPwrScheme); + printf("#1 failed to delete subkey %i (testentry)\n", g_TempPwrScheme); RegCloseKey(hSubKey); } @@ -490,22 +490,22 @@ ok(ret, "function was expected to succeed, error %x\n",(UINT)GetLastError()); ret = SetActivePwrScheme(0, &gpp, 0); - ok(!ret, "function was expected to fail, error %x\n",(UINT)GetLastError()); + ok(!ret, "function was expected to fail\n"); ret = SetActivePwrScheme(0, 0, &pp); - ok(!ret, "function was expected to fail, error %x\n",(UINT)GetLastError()); + ok(!ret, "function was expected to fail\n"); ret = SetActivePwrScheme(0, &gpp, &pp); - ok(!ret, "function was expected to fail, error %x\n",(UINT)GetLastError()); + ok(!ret, "function was expected to fail\n"); ret = SetActivePwrScheme(current_scheme, &gpp, 0); - ok(!ret, "function was expected to fail, error %x\n",(UINT)GetLastError()); + ok(!ret, "function was expected to fail\n"); ret = SetActivePwrScheme(current_scheme, 0, &pp); - ok(!ret, "function was expected to fail, error %x\n",(UINT)GetLastError()); + ok(!ret, "function was expected to fail\n"); ret = SetActivePwrScheme(current_scheme, &gpp, &pp); - ok(!ret, "function was expected to fail, error %x\n",(UINT)GetLastError()); + ok(!ret, "function was expected to fail\n"); ret = SetActivePwrScheme(g_ActivePwrScheme, 0, 0); ok(ret, "Warning: failed to restore old active power scheme %d\n", (UINT)g_ActivePwrScheme); @@ -521,10 +521,10 @@ ret = GetCurrentPowerPolicies(&gpp,&pp); ok(ret, "function was expected to succeed, error %x\n",(UINT)GetLastError()); - ok(gpp.mach.Revision == 1,"Global Mach Revision was expected to be 1 got %i",(UINT)gpp.mach.Revision); - ok(gpp.user.Revision == 1,"Global User Revision was expected to be 1 got %i",(UINT)gpp.mach.Revision); - ok(pp.mach.Revision == 1,"Mach Revision was expected to be 1 got %i",(UINT)gpp.mach.Revision); - ok(pp.user.Revision == 1,"User Revision was expected to be 1 got %i",(UINT)gpp.mach.Revision); + ok(gpp.mach.Revision == 1,"Global Mach Revision was expected to be 1 got %i\n",(UINT)gpp.mach.Revision); + ok(gpp.user.Revision == 1,"Global User Revision was expected to be 1 got %i\n",(UINT)gpp.mach.Revision); + ok(pp.mach.Revision == 1,"Mach Revision was expected to be 1 got %i\n",(UINT)gpp.mach.Revision); + ok(pp.user.Revision == 1,"User Revision was expected to be 1 got %i\n",(UINT)gpp.mach.Revision); ret = GetActivePwrScheme(&g_ActivePwrScheme); @@ -605,10 +605,10 @@ BOOLEAN ret; ret = IsAdminOverrideActive(0); - ok(!ret, "function was expected to fail, error %x\n",(UINT)GetLastError()); + ok(!ret, "function was expected to fail\n"); ret = IsAdminOverrideActive(&app); - ok(!ret, "function was expected to fail, error %x\n",(UINT)GetLastError()); + ok(!ret, "function was expected to fail\n"); app.MinSleep = 0; app.MaxSleep = 0; @@ -618,7 +618,7 @@ app.MaxSpindownTimeout = 0; ret = IsAdminOverrideActive(&app); - ok(!ret, "function was expected to fail, error %x\n",(UINT)GetLastError()); + ok(!ret, "function was expected to fail\n"); app.MinSleep = 1; app.MaxSleep = 2; @@ -628,7 +628,7 @@ app.MaxSpindownTimeout = 6; ret = IsAdminOverrideActive(&app); - ok(!ret, "function was expected to fail, error %x\n",(UINT)GetLastError()); + ok(!ret, "function was expected to fail\n"); } @@ -638,7 +638,7 @@ BOOLEAN ret; ret = IsPwrHibernateAllowed(); - ok(!ret, "function was expected to fail, error %x\n",(UINT)GetLastError()); + ok(!ret, "function was expected to fail\n"); */ } @@ -669,8 +669,8 @@ ret = ReadGlobalPwrPolicy(&gpp); ok(ret, "function was expected to succeed, error %x\n",(UINT)GetLastError()); - ok(gpp.mach.Revision == 1,"Global Mach Revision was expected to be 1 got %i",(UINT)gpp.mach.Revision); - ok(gpp.user.Revision == 1,"Global User Revision was expected to be 1 got %i",(UINT)gpp.mach.Revision); + ok(gpp.mach.Revision == 1,"Global Mach Revision was expected to be 1 got %i\n",(UINT)gpp.mach.Revision); + ok(gpp.user.Revision == 1,"Global User Revision was expected to be 1 got %i\n",(UINT)gpp.mach.Revision); @@ -689,9 +689,9 @@ ret = ReadProcessorPwrScheme(i,&mppp); if (ret) { - ok(mppp.Revision == 1,"Main Revision was expected to be 1 got %i",(UINT)mppp.Revision); - ok(mppp.ProcessorPolicyAc.Revision == 1,"PowerAC Revision was expected to be 1 got %i",(UINT)mppp.ProcessorPolicyAc.Revision); - ok(mppp.ProcessorPolicyDc.Revision == 1,"PowerDC Revision was expected to be 1 got %i",(UINT)mppp.ProcessorPolicyDc.Revision); + ok(mppp.Revision == 1,"Main Revision was expected to be 1 got %i\n",(UINT)mppp.Revision); + ok(mppp.ProcessorPolicyAc.Revision == 1,"PowerAC Revision was expected to be 1 got %i\n",(UINT)mppp.ProcessorPolicyAc.Revision); + ok(mppp.ProcessorPolicyDc.Revision == 1,"PowerDC Revision was expected to be 1 got %i\n",(UINT)mppp.ProcessorPolicyDc.Revision); } else { @@ -739,12 +739,441 @@ // SetSuspendState(FALSE,FALSE,FALSE) } -void test_ValidatePowerPolicies(void) + +BOOLEAN globalcompare(GLOBAL_POWER_POLICY gpp, GLOBAL_POWER_POLICY gpp_compare) { + //return TRUE; + int i,j; + BOOLEAN ret; + + ret = TRUE; + if (gpp.mach.BroadcastCapacityResolution != gpp_compare.mach.BroadcastCapacityResolution) + { + printf("mach.BroadcastCapacityResolution failed %i != %i\n",gpp.mach.BroadcastCapacityResolution,gpp_compare.mach.BroadcastCapacityResolution); + ret = FALSE; + } + if (gpp.mach.LidOpenWakeAc != gpp_compare.mach.LidOpenWakeAc) + { + printf("mach.LidOpenWakeAc failed %i != %i\n",gpp.mach.LidOpenWakeAc,gpp_compare.mach.LidOpenWakeAc); + ret = FALSE; + } + if (gpp.mach.LidOpenWakeDc != gpp_compare.mach.LidOpenWakeDc) + { + printf("mach.LidOpenWakeDc failed %i != %i\n",gpp.mach.LidOpenWakeDc,gpp_compare.mach.LidOpenWakeDc); + ret = FALSE; + } + if (gpp.mach.Revision != gpp_compare.mach.Revision) + { + printf("mach.Revision failed %i != %i\n",gpp.mach.Revision,gpp_compare.mach.Revision); + ret = FALSE; + } + + if (gpp.user.PowerButtonAc.Action != gpp_compare.user.PowerButtonAc.Action) + { + printf("user.PowerButtonAc.Action failed %i != %i\n",gpp.user.PowerButtonAc.Action,gpp_compare.user.PowerButtonAc.Action); + ret = FALSE; + } + if (gpp.user.PowerButtonAc.EventCode != gpp_compare.user.PowerButtonAc.EventCode) + { + printf("user.PowerButtonAc.EventCode failed %i != %i\n",gpp.user.PowerButtonAc.EventCode,gpp_compare.user.PowerButtonAc.EventCode); + ret = FALSE; + } + if (gpp.user.PowerButtonAc.Flags != gpp_compare.user.PowerButtonAc.Flags) + { + printf("user.PowerButtonAc.Flags failed %i != %i\n",gpp.user.PowerButtonAc.Flags,gpp_compare.user.PowerButtonAc.Flags); + ret = FALSE; + } + if (gpp.user.PowerButtonDc.Action != gpp_compare.user.PowerButtonDc.Action) + { + printf("user.PowerButtonDc.Action failed %i != %i\n",gpp.user.PowerButtonDc.Action,gpp_compare.user.PowerButtonDc.Action); + ret = FALSE; + } + if (gpp.user.PowerButtonDc.EventCode != gpp_compare.user.PowerButtonDc.EventCode) + { + printf("user.PowerButtonDc.EventCode failed %i != %i\n",gpp.user.PowerButtonDc.EventCode,gpp_compare.user.PowerButtonDc.EventCode); + ret = FALSE; + } + if (gpp.user.PowerButtonDc.Flags != gpp_compare.user.PowerButtonDc.Flags) + { + printf("user.PowerButtonDc.Flags failed %i != %i\n",gpp.user.PowerButtonDc.Flags,gpp_compare.user.PowerButtonDc.Flags); + ret = FALSE; + } + if (gpp.user.SleepButtonAc.Action != gpp_compare.user.SleepButtonAc.Action) + { + printf("user.SleepButtonAc.Action failed %i != %i\n",gpp.user.SleepButtonAc.Action,gpp_compare.user.SleepButtonAc.Action); + ret = FALSE; + } + if (gpp.user.SleepButtonAc.EventCode != gpp_compare.user.SleepButtonAc.EventCode) + { + printf("user.SleepButtonAc.EventCode failed %i != %i\n",gpp.user.SleepButtonAc.EventCode,gpp_compare.user.SleepButtonAc.EventCode); + ret = FALSE; + } + if (gpp.user.SleepButtonAc.Flags != gpp_compare.user.SleepButtonAc.Flags) + { + printf("user.SleepButtonAc.Flags failed %i != %i\n",gpp.user.SleepButtonAc.Flags,gpp_compare.user.SleepButtonAc.Flags); + ret = FALSE; + } + if (gpp.user.SleepButtonDc.Action != gpp_compare.user.SleepButtonDc.Action) + { + printf("user.SleepButtonDc.Action failed %i != %i\n",gpp.user.SleepButtonDc.Action,gpp_compare.user.SleepButtonDc.Action); + ret = FALSE; + } + if (gpp.user.SleepButtonDc.EventCode != gpp_compare.user.SleepButtonDc.EventCode) + { + printf("user.SleepButtonDc.EventCode failed %i != %i\n",gpp.user.SleepButtonDc.EventCode,gpp_compare.user.SleepButtonDc.EventCode); + ret = FALSE; + } + if (gpp.user.SleepButtonDc.Flags != gpp_compare.user.SleepButtonDc.Flags) + { + printf("user.SleepButtonDc.Flags failed %i != %i\n",gpp.user.SleepButtonDc.Flags,gpp_compare.user.SleepButtonDc.Flags); + ret = FALSE; + } + if (gpp.user.LidCloseAc.Action != gpp_compare.user.LidCloseAc.Action) + { + printf("user.LidCloseAc.Action failed %i != %i\n",gpp.user.LidCloseAc.Action,gpp_compare.user.LidCloseAc.Action); + ret = FALSE; + } + if (gpp.user.LidCloseAc.EventCode != gpp_compare.user.LidCloseAc.EventCode) + { + printf("user.LidCloseAc.EventCode failed %i != %i\n",gpp.user.LidCloseAc.EventCode,gpp_compare.user.LidCloseAc.EventCode); + ret = FALSE; + } + if (gpp.user.LidCloseAc.Flags != gpp_compare.user.LidCloseAc.Flags) + { + printf("user.LidCloseAc.Flags failed %i != %i\n",gpp.user.LidCloseAc.Flags,gpp_compare.user.LidCloseAc.Flags); + ret = FALSE; + } + if (gpp.user.LidCloseDc.Action != gpp_compare.user.LidCloseDc.Action) + { + printf("user.LidCloseDc.Action failed %i != %i\n",gpp.user.LidCloseDc.Action,gpp_compare.user.LidCloseDc.Action); + ret = FALSE; + } + if (gpp.user.LidCloseDc.EventCode != gpp_compare.user.LidCloseDc.EventCode) + { + printf("user.LidCloseDc.EventCode failed %i != %i\n",gpp.user.LidCloseDc.EventCode,gpp_compare.user.LidCloseDc.EventCode); + ret = FALSE; + } + if (gpp.user.LidCloseDc.Flags != gpp_compare.user.LidCloseDc.Flags) + { + printf("user.LidCloseDc.Flags failed %i != %i\n",gpp.user.LidCloseDc.Flags,gpp_compare.user.LidCloseDc.Flags); + ret = FALSE; + } + + for(i=0;imach.LidOpenWakeAc);//1 + //printf("Old: %i\n",pGPP_original->mach.LidOpenWakeDc);//1 + //printf("Old: %i,%i,%i \n",pGPP_original->user.LidCloseAc.Action,pGPP_original->user.LidCloseAc.EventCode,pGPP_original->user.LidCloseAc.Flags);//7 + //printf("Old: %i,%i,%i \n",pGPP_original->user.LidCloseDc.Action,pGPP_original->user.LidCloseDc.EventCode,pGPP_original->user.LidCloseDc.Flags);//7 + //printf("Old: %i,%i,%i \n",pGPP_original->user.PowerButtonAc.Action,pGPP_original->user.PowerButtonAc.EventCode,pGPP_original->user.PowerButtonAc.Flags);//0,0,0 + //printf("Old: %i,%i,%i \n",pGPP_original->user.PowerButtonDc.Action,pGPP_original->user.PowerButtonDc.EventCode,pGPP_original->user.PowerButtonDc.Flags);//7,0,0 + //printf("Old: %i,%i,%i \n",pGPP_original->user.SleepButtonAc.Action,pGPP_original->user.SleepButtonAc.EventCode,pGPP_original->user.SleepButtonAc.Flags);//7,0,0 + //printf("Old: %i,%i,%i \n",pGPP_original->user.SleepButtonDc.Action,pGPP_original->user.SleepButtonDc.EventCode,pGPP_original->user.SleepButtonDc.Flags);//7,0,0 + //printf("Old: %i \n",pPP_original->mach.DozeS4TimeoutAc);//0 + //printf("Old: %i \n",pPP_original->mach.DozeS4TimeoutDc);//0 + //printf("Old: %i \n",pPP_original->mach.DozeTimeoutAc);//0 + //printf("Old: %i \n",pPP_original->mach.DozeTimeoutDc);//0 + //printf("Old: %i \n",pPP_original->mach.MinSleepAc);//1 + //printf("Old: %i \n",pPP_original->mach.MinSleepDc);//1 + //printf("Old: %i \n",pPP_original->mach.MinThrottleAc);//0 + //printf("Old: %i \n",pPP_original->mach.MinThrottleDc);//0 + //printf("Old: %i,%i,%i \n",pPP_original->mach.OverThrottledAc.Action,pPP_original->mach.OverThrottledAc.EventCode,pPP_original->mach.OverThrottledAc.Flags);//0,0,0 + //printf("Old: %i,%i,%i \n",pPP_original->mach.OverThrottledDc.Action,pPP_original->mach.OverThrottledDc.EventCode,pPP_original->mach.OverThrottledDc.Flags);//0,0,0 + //printf("Old: %i \n",pPP_original->mach.ReducedLatencySleepAc);//1 + //printf("Old: %i \n",pPP_original->mach.ReducedLatencySleepDc);//1 + //printf("Old: %i \n",pPP_original->user.FanThrottleToleranceAc);//0 + //printf("Old: %i \n",pPP_original->user.FanThrottleToleranceDc);//0 + //printf("Old: %i \n",pPP_original->user.ForcedThrottleAc);//0 + //printf("Old: %i \n",pPP_original->user.ForcedThrottleDc);//0 + //printf("Old: %i,%i,%i \n",pPP_original->user.IdleAc.Action,pPP_original->user.IdleAc.EventCode,pPP_original->user.IdleAc.Flags);//0,0,0 + //printf("Old: %i,%i,%i \n",pPP_original->user.IdleDc.Action,pPP_original->user.IdleDc.EventCode,pPP_original->user.IdleDc.Flags);//0,0,0 + //printf("Old: %i \n",pPP_original->user.IdleSensitivityAc);//0 + //printf("Old: %i \n",pPP_original->user.IdleSensitivityDc);//0 + //printf("Old: %i \n",pPP_original->user.IdleTimeoutAc);//0 + //printf("Old: %i \n",pPP_original->user.IdleTimeoutDc);//0 + //printf("Old: %i \n",pPP_original->user.MaxSleepAc);//1 + //printf("Old: %i \n",pPP_original->user.MaxSleepDc);//1 + //printf("Old: %i \n",pPP_original->user.OptimizeForPowerAc);//0 + //printf("Old: %i \n",pPP_original->user.OptimizeForPowerDc);//0 + //printf("Old: %i \n",pPP_original->user.SpindownTimeoutAc);//0 + //printf("Old: %i \n",pPP_original->user.SpindownTimeoutDc);//0 + //printf("Old: %i \n",pPP_original->user.ThrottlePolicyAc);//0 + //printf("Old: %i \n",pPP_original->user.ThrottlePolicyDc);//0 + //printf("Old: %i \n",pPP_original->user.VideoTimeoutAc);//0 + //printf("Old: %i \n",pPP_original->user.VideoTimeoutDc);//0 + + pPP_original->mach.MinSleepAc=4; +pPP_original->mach.MinSleepDc=4; +pPP_original->user.MaxSleepAc=4; +pPP_original->user.MaxSleepDc=4; +pPP_original->user.OptimizeForPowerAc=1; +pPP_original->user.OptimizeForPowerDc=1; + + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ok(compare(pp,pp_compare),"Difference Found\n"); + + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->mach.LidOpenWakeAc=PowerSystemUnspecified-2; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->mach.LidOpenWakeAc=PowerSystemUnspecified-1; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->mach.LidOpenWakeAc=PowerSystemUnspecified; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(!ret, "function was expected to fail\n"); + ok(GetLastError() == ERROR_GEN_FAILURE, "expected ERROR_GEN_FAILURE but got %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->mach.LidOpenWakeAc=PowerSystemWorking; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->mach.LidOpenWakeAc=PowerSystemSleeping1; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + gpp_compare.mach.LidOpenWakeAc=4; + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->mach.LidOpenWakeAc=PowerSystemSleeping2; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + gpp_compare.mach.LidOpenWakeAc=4; + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->mach.LidOpenWakeAc=PowerSystemSleeping3; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->mach.LidOpenWakeAc=PowerSystemHibernate; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + gpp_compare.mach.LidOpenWakeAc=4; + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->mach.LidOpenWakeAc=PowerSystemShutdown; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(!ret, "function was expected to fail\n"); + ok(GetLastError() == ERROR_GEN_FAILURE, "expected ERROR_GEN_FAILURE but got %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->mach.LidOpenWakeAc=PowerSystemMaximum; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(!ret, "function was expected to fail\n"); + ok(GetLastError() == ERROR_GEN_FAILURE, "expected ERROR_GEN_FAILURE but got %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->mach.LidOpenWakeAc=PowerSystemMaximum+1; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(!ret, "function was expected to fail\n"); + ok(GetLastError() == ERROR_GEN_FAILURE, "expected ERROR_GEN_FAILURE but got %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->mach.LidOpenWakeAc=PowerSystemMaximum+2; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(!ret, "function was expected to fail\n"); + ok(GetLastError() == ERROR_GEN_FAILURE, "expected ERROR_GEN_FAILURE but got %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + pGPP_original->mach.LidOpenWakeAc=PowerSystemWorking; + + + pGPP_original->mach.LidOpenWakeDc=PowerSystemUnspecified-2; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->mach.LidOpenWakeDc=PowerSystemUnspecified-1; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->mach.LidOpenWakeDc=PowerSystemUnspecified; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(!ret, "function was expected to fail\n"); + ok(GetLastError() == ERROR_GEN_FAILURE, "expected ERROR_GEN_FAILURE but got %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->mach.LidOpenWakeDc=PowerSystemWorking; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->mach.LidOpenWakeDc=PowerSystemSleeping1; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + gpp_compare.mach.LidOpenWakeDc=4; + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->mach.LidOpenWakeDc=PowerSystemSleeping2; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + gpp_compare.mach.LidOpenWakeDc=4; + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->mach.LidOpenWakeDc=PowerSystemSleeping3; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->mach.LidOpenWakeDc=PowerSystemHibernate; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + gpp_compare.mach.LidOpenWakeDc=4; + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->mach.LidOpenWakeDc=PowerSystemShutdown; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(!ret, "function was expected to fail\n"); + ok(GetLastError() == ERROR_GEN_FAILURE, "expected ERROR_GEN_FAILURE but got %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->mach.LidOpenWakeDc=PowerSystemMaximum; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(!ret, "function was expected to fail\n"); + ok(GetLastError() == ERROR_GEN_FAILURE, "expected ERROR_GEN_FAILURE but got %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->mach.LidOpenWakeDc=PowerSystemMaximum+1; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(!ret, "function was expected to fail\n"); + ok(GetLastError() == ERROR_GEN_FAILURE, "expected ERROR_GEN_FAILURE but got %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->mach.LidOpenWakeDc=PowerSystemMaximum+2; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(!ret, "function was expected to fail\n"); + ok(GetLastError() == ERROR_GEN_FAILURE, "expected ERROR_GEN_FAILURE but got %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + pGPP_original->mach.LidOpenWakeDc=PowerSystemWorking; + + pGPP_original->user.LidCloseAc.Action=PowerActionNone-2; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(!ret, "function was expected to fail\n"); + ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %x\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->user.LidCloseAc.Action=PowerActionNone-1; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(!ret, "function was expected to fail\n"); + ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %x\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->user.LidCloseAc.Action=PowerActionNone; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->user.LidCloseAc.Action=PowerActionReserved; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + gpp_compare.user.LidCloseAc.Action=2; + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->user.LidCloseAc.Action=PowerActionSleep; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->user.LidCloseAc.Action=PowerActionHibernate; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + gpp_compare.user.LidCloseAc.Action=2; + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->user.LidCloseAc.Action=PowerActionShutdown; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->user.LidCloseAc.Action=PowerActionShutdownReset; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->user.LidCloseAc.Action=PowerActionShutdownOff; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->user.LidCloseAc.Action=PowerActionWarmEject; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->user.LidCloseAc.Action=PowerActionWarmEject+1; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(!ret, "function was expected to fail\n"); + ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->user.LidCloseAc.Action=PowerActionWarmEject+2; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(!ret, "function was expected to fail\n"); + ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + pGPP_original->user.LidCloseAc.Action=PowerActionWarmEject; + + + pGPP_original->user.LidCloseDc.Action=PowerActionNone-2; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(!ret, "function was expected to fail\n"); + ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %x\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->user.LidCloseDc.Action=PowerActionNone-1; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(!ret, "function was expected to fail\n"); + ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %x\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->user.LidCloseDc.Action=PowerActionNone; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->user.LidCloseDc.Action=PowerActionReserved; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + gpp_compare.user.LidCloseDc.Action=2; + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->user.LidCloseDc.Action=PowerActionSleep; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->user.LidCloseDc.Action=PowerActionHibernate; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + gpp_compare.user.LidCloseDc.Action=2; + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->user.LidCloseDc.Action=PowerActionShutdown; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->user.LidCloseDc.Action=PowerActionShutdownReset; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->user.LidCloseDc.Action=PowerActionShutdownOff; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->user.LidCloseDc.Action=PowerActionWarmEject; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->user.LidCloseDc.Action=PowerActionWarmEject+1; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(!ret, "function was expected to fail\n"); + ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->user.LidCloseDc.Action=PowerActionWarmEject+2; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(!ret, "function was expected to fail\n"); + ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + pGPP_original->user.LidCloseDc.Action=PowerActionWarmEject; + + + pGPP_original->user.PowerButtonAc.Action=PowerActionNone-2; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(!ret, "function was expected to fail\n"); + ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %x\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->user.PowerButtonAc.Action=PowerActionNone-1; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(!ret, "function was expected to fail\n"); + ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %x\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->user.PowerButtonAc.Action=PowerActionNone; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->user.PowerButtonAc.Action=PowerActionReserved; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + gpp_compare.user.PowerButtonAc.Action=2; + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->user.PowerButtonAc.Action=PowerActionSleep; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->user.PowerButtonAc.Action=PowerActionHibernate; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + gpp_compare.user.PowerButtonAc.Action=2; + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->user.PowerButtonAc.Action=PowerActionShutdown; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->user.PowerButtonAc.Action=PowerActionShutdownReset; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->user.PowerButtonAc.Action=PowerActionShutdownOff; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->user.PowerButtonAc.Action=PowerActionWarmEject; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->user.PowerButtonAc.Action=PowerActionWarmEject+1; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(!ret, "function was expected to fail\n"); + ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->user.PowerButtonAc.Action=PowerActionWarmEject+2; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(!ret, "function was expected to fail\n"); + ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + pGPP_original->user.PowerButtonAc.Action=PowerActionNone; + + + pGPP_original->user.PowerButtonDc.Action=PowerActionNone-2; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(!ret, "function was expected to fail\n"); + ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %x\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->user.PowerButtonDc.Action=PowerActionNone-1; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(!ret, "function was expected to fail\n"); + ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %x\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->user.PowerButtonDc.Action=PowerActionNone; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->user.PowerButtonDc.Action=PowerActionReserved; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + gpp_compare.user.PowerButtonDc.Action=2; + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->user.PowerButtonDc.Action=PowerActionSleep; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->user.PowerButtonDc.Action=PowerActionHibernate; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + gpp_compare.user.PowerButtonDc.Action=2; + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->user.PowerButtonDc.Action=PowerActionShutdown; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->user.PowerButtonDc.Action=PowerActionShutdownReset; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->user.PowerButtonDc.Action=PowerActionShutdownOff; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->user.PowerButtonDc.Action=PowerActionWarmEject; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->user.PowerButtonDc.Action=PowerActionWarmEject+1; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(!ret, "function was expected to fail\n"); + ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->user.PowerButtonDc.Action=PowerActionWarmEject+2; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(!ret, "function was expected to fail\n"); + ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + pGPP_original->user.PowerButtonDc.Action=PowerActionWarmEject; + + + pGPP_original->user.SleepButtonAc.Action=PowerActionNone-2; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(!ret, "function was expected to fail\n"); + ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %x\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->user.SleepButtonAc.Action=PowerActionNone-1; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(!ret, "function was expected to fail\n"); + ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %x\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->user.SleepButtonAc.Action=PowerActionNone; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->user.SleepButtonAc.Action=PowerActionReserved; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + gpp_compare.user.SleepButtonAc.Action=2; + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->user.SleepButtonAc.Action=PowerActionSleep; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->user.SleepButtonAc.Action=PowerActionHibernate; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + gpp_compare.user.SleepButtonAc.Action=2; + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->user.SleepButtonAc.Action=PowerActionShutdown; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->user.SleepButtonAc.Action=PowerActionShutdownReset; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->user.SleepButtonAc.Action=PowerActionShutdownOff; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->user.SleepButtonAc.Action=PowerActionWarmEject; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->user.SleepButtonAc.Action=PowerActionWarmEject+1; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(!ret, "function was expected to fail\n"); + ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->user.SleepButtonAc.Action=PowerActionWarmEject+2; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(!ret, "function was expected to fail\n"); + ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + pGPP_original->user.SleepButtonAc.Action=PowerActionWarmEject; + + + pGPP_original->user.SleepButtonDc.Action=PowerActionNone-2; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(!ret, "function was expected to fail\n"); + ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %x\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->user.SleepButtonDc.Action=PowerActionNone-1; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(!ret, "function was expected to fail\n"); + ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %x\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->user.SleepButtonDc.Action=PowerActionNone; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->user.SleepButtonDc.Action=PowerActionReserved; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + gpp_compare.user.SleepButtonDc.Action=2; + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->user.SleepButtonDc.Action=PowerActionSleep; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->user.SleepButtonDc.Action=PowerActionHibernate; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + gpp_compare.user.SleepButtonDc.Action=2; + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->user.SleepButtonDc.Action=PowerActionShutdown; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->user.SleepButtonDc.Action=PowerActionShutdownReset; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->user.SleepButtonDc.Action=PowerActionShutdownOff; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->user.SleepButtonDc.Action=PowerActionWarmEject; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->user.SleepButtonDc.Action=PowerActionWarmEject+1; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(!ret, "function was expected to fail\n"); + ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pGPP_original->user.SleepButtonDc.Action=PowerActionWarmEject+2; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(!ret, "function was expected to fail\n"); + ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + pGPP_original->user.SleepButtonDc.Action=PowerActionWarmEject; + + + pPP_original->mach.MinSleepAc=PowerSystemUnspecified-2; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + pp_compare.mach.MinSleepAc=4; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->mach.MinSleepAc=PowerSystemUnspecified-1; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + pp_compare.mach.MinSleepAc=4; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->mach.MinSleepAc=PowerSystemUnspecified; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + pp_compare.mach.MinSleepAc=4; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->mach.MinSleepAc=PowerSystemWorking; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + pp_compare.mach.MinSleepAc=4; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->mach.MinSleepAc=PowerSystemSleeping1; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + pp_compare.mach.MinSleepAc=4; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->mach.MinSleepAc=PowerSystemSleeping2; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + pp_compare.mach.MinSleepAc=4; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->mach.MinSleepAc=PowerSystemSleeping3; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->mach.MinSleepAc=PowerSystemHibernate; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + pp_compare.mach.MinSleepAc=4; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->mach.MinSleepAc=PowerSystemShutdown; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(!ret, "function was expected to fail\n"); + ok(GetLastError() == ERROR_GEN_FAILURE, "expected ERROR_GEN_FAILURE but got %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->mach.MinSleepAc=PowerSystemMaximum; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(!ret, "function was expected to fail\n"); + ok(GetLastError() == ERROR_GEN_FAILURE, "expected ERROR_GEN_FAILURE but got %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->mach.MinSleepAc=PowerSystemMaximum+1; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(!ret, "function was expected to fail\n"); + ok(GetLastError() == ERROR_GEN_FAILURE, "expected ERROR_GEN_FAILURE but got %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->mach.MinSleepAc=PowerSystemMaximum+2; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(!ret, "function was expected to fail\n"); + ok(GetLastError() == ERROR_GEN_FAILURE, "expected ERROR_GEN_FAILURE but got %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + pPP_original->mach.MinSleepAc=PowerSystemSleeping3; + + + pPP_original->mach.MinSleepDc=PowerSystemUnspecified-2; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + pp_compare.mach.MinSleepDc=4; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->mach.MinSleepDc=PowerSystemUnspecified-1; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + pp_compare.mach.MinSleepDc=4; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->mach.MinSleepDc=PowerSystemUnspecified; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + pp_compare.mach.MinSleepDc=4; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->mach.MinSleepDc=PowerSystemWorking; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + pp_compare.mach.MinSleepDc=4; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->mach.MinSleepDc=PowerSystemSleeping1; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + pp_compare.mach.MinSleepDc=4; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->mach.MinSleepDc=PowerSystemSleeping2; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + pp_compare.mach.MinSleepDc=4; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->mach.MinSleepDc=PowerSystemSleeping3; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->mach.MinSleepDc=PowerSystemHibernate; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + pp_compare.mach.MinSleepDc=4; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->mach.MinSleepDc=PowerSystemShutdown; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(!ret, "function was expected to fail\n"); + ok(GetLastError() == ERROR_GEN_FAILURE, "expected ERROR_GEN_FAILURE but got %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->mach.MinSleepDc=PowerSystemMaximum; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(!ret, "function was expected to fail\n"); + ok(GetLastError() == ERROR_GEN_FAILURE, "expected ERROR_GEN_FAILURE but got %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->mach.MinSleepDc=PowerSystemMaximum+1; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(!ret, "function was expected to fail\n"); + ok(GetLastError() == ERROR_GEN_FAILURE, "expected ERROR_GEN_FAILURE but got %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->mach.MinSleepDc=PowerSystemMaximum+2; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(!ret, "function was expected to fail\n"); + ok(GetLastError() == ERROR_GEN_FAILURE, "expected ERROR_GEN_FAILURE but got %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + pPP_original->mach.MinSleepDc=PowerSystemSleeping3; + + + pPP_original->mach.OverThrottledAc.Action=PowerActionNone-2; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(!ret, "function was expected to fail\n"); + ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + //pp_compare.mach.OverThrottledAc.Action=4; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->mach.OverThrottledAc.Action=PowerActionNone-1; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(!ret, "function was expected to fail\n"); + ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + //pp_compare.mach.OverThrottledAc.Action=4; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->mach.OverThrottledAc.Action=PowerActionNone; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + //pp_compare.mach.OverThrottledAc.Action=4; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->mach.OverThrottledAc.Action=PowerActionReserved; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + //pp_compare.mach.OverThrottledAc.Action=4; + pp_compare.mach.OverThrottledAc.Action=2; + pp_compare.mach.pad1[2]=2; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->mach.OverThrottledAc.Action=PowerActionSleep; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + //pp_compare.mach.OverThrottledAc.Action=4; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->mach.OverThrottledAc.Action=PowerActionHibernate; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + pp_compare.mach.OverThrottledAc.Action=2; + pp_compare.mach.pad1[2]=2; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->mach.OverThrottledAc.Action=PowerActionShutdown; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->mach.OverThrottledAc.Action=PowerActionShutdownReset; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + //pp_compare.mach.OverThrottledAc.Action=4; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->mach.OverThrottledAc.Action=PowerActionShutdownOff; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->mach.OverThrottledAc.Action=PowerActionWarmEject; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->mach.OverThrottledAc.Action=PowerActionWarmEject+1; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(!ret, "function was expected to fail\n"); + ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->mach.OverThrottledAc.Action=PowerActionWarmEject+2; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(!ret, "function was expected to fail\n"); + ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + pPP_original->mach.OverThrottledAc.Action=PowerActionNone; + + + pPP_original->mach.OverThrottledDc.Action=PowerActionNone-2; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(!ret, "function was expected to fail\n"); + ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + //pp_compare.mach.OverThrottledDc.Action=4; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->mach.OverThrottledDc.Action=PowerActionNone-1; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(!ret, "function was expected to fail\n"); + ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + //pp_compare.mach.OverThrottledDc.Action=4; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->mach.OverThrottledDc.Action=PowerActionNone; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + //pp_compare.mach.OverThrottledDc.Action=4; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->mach.OverThrottledDc.Action=PowerActionReserved; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + //pp_compare.mach.OverThrottledDc.Action=4; + pp_compare.mach.OverThrottledDc.Action=2; + pp_compare.mach.OverThrottledAc.Action=0; + pp_compare.mach.pad1[2]=0; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->mach.OverThrottledDc.Action=PowerActionSleep; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + //pp_compare.mach.OverThrottledDc.Action=4; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->mach.OverThrottledDc.Action=PowerActionHibernate; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + pp_compare.mach.OverThrottledDc.Action=2; + pp_compare.mach.OverThrottledAc.Action=0; + pp_compare.mach.pad1[2]=0; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->mach.OverThrottledDc.Action=PowerActionShutdown; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->mach.OverThrottledDc.Action=PowerActionShutdownReset; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + //pp_compare.mach.OverThrottledDc.Action=4; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->mach.OverThrottledDc.Action=PowerActionShutdownOff; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->mach.OverThrottledDc.Action=PowerActionWarmEject; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->mach.OverThrottledDc.Action=PowerActionWarmEject+1; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(!ret, "function was expected to fail\n"); + ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->mach.OverThrottledDc.Action=PowerActionWarmEject+2; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(!ret, "function was expected to fail\n"); + ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + pPP_original->mach.OverThrottledDc.Action=PowerActionNone; + + + pPP_original->mach.ReducedLatencySleepAc=PowerSystemUnspecified-2; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + //pp_compare.mach.ReducedLatencySleepAc=4; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->mach.ReducedLatencySleepAc=PowerSystemUnspecified-1; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + //pp_compare.mach.ReducedLatencySleepAc=4; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->mach.ReducedLatencySleepAc=PowerSystemUnspecified; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(!ret, "function was expected to fail\n"); + ok(GetLastError() == ERROR_GEN_FAILURE, "expected ERROR_GEN_FAILURE but got %x\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + //pp_compare.mach.ReducedLatencySleepAc=4; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->mach.ReducedLatencySleepAc=PowerSystemWorking; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + //pp_compare.mach.ReducedLatencySleepAc=4; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->mach.ReducedLatencySleepAc=PowerSystemSleeping1; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + pp_compare.mach.ReducedLatencySleepAc=4; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->mach.ReducedLatencySleepAc=PowerSystemSleeping2; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + pp_compare.mach.ReducedLatencySleepAc=4; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->mach.ReducedLatencySleepAc=PowerSystemSleeping3; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->mach.ReducedLatencySleepAc=PowerSystemHibernate; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + pp_compare.mach.ReducedLatencySleepAc=4; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->mach.ReducedLatencySleepAc=PowerSystemShutdown; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(!ret, "function was expected to fail\n"); + ok(GetLastError() == ERROR_GEN_FAILURE, "expected ERROR_GEN_FAILURE but got %x\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->mach.ReducedLatencySleepAc=PowerSystemMaximum; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(!ret, "function was expected to fail\n"); + ok(GetLastError() == ERROR_GEN_FAILURE, "expected ERROR_GEN_FAILURE but got %x\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->mach.ReducedLatencySleepAc=PowerSystemMaximum+1; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(!ret, "function was expected to fail\n"); + ok(GetLastError() == ERROR_GEN_FAILURE, "expected ERROR_GEN_FAILURE but got %x\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->mach.ReducedLatencySleepAc=PowerSystemMaximum+2; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(!ret, "function was expected to fail\n"); + ok(GetLastError() == ERROR_GEN_FAILURE, "expected ERROR_GEN_FAILURE but got %x\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + pPP_original->mach.ReducedLatencySleepAc=PowerSystemWorking; + + + pPP_original->mach.ReducedLatencySleepDc=PowerSystemUnspecified-2; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + //pp_compare.mach.ReducedLatencySleepDc=4; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->mach.ReducedLatencySleepDc=PowerSystemUnspecified-1; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + //pp_compare.mach.ReducedLatencySleepDc=4; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->mach.ReducedLatencySleepDc=PowerSystemUnspecified; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(!ret, "function was expected to fail\n"); + ok(GetLastError() == ERROR_GEN_FAILURE, "expected ERROR_GEN_FAILURE but got %x\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + //pp_compare.mach.ReducedLatencySleepDc=4; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->mach.ReducedLatencySleepDc=PowerSystemWorking; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + //pp_compare.mach.ReducedLatencySleepDc=4; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->mach.ReducedLatencySleepDc=PowerSystemSleeping1; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + pp_compare.mach.ReducedLatencySleepDc=4; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->mach.ReducedLatencySleepDc=PowerSystemSleeping2; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + pp_compare.mach.ReducedLatencySleepDc=4; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->mach.ReducedLatencySleepDc=PowerSystemSleeping3; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->mach.ReducedLatencySleepDc=PowerSystemHibernate; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + pp_compare.mach.ReducedLatencySleepDc=4; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->mach.ReducedLatencySleepDc=PowerSystemShutdown; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(!ret, "function was expected to fail\n"); + ok(GetLastError() == ERROR_GEN_FAILURE, "expected ERROR_GEN_FAILURE but got %x\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->mach.ReducedLatencySleepDc=PowerSystemMaximum; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(!ret, "function was expected to fail\n"); + ok(GetLastError() == ERROR_GEN_FAILURE, "expected ERROR_GEN_FAILURE but got %x\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->mach.ReducedLatencySleepDc=PowerSystemMaximum+1; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(!ret, "function was expected to fail\n"); + ok(GetLastError() == ERROR_GEN_FAILURE, "expected ERROR_GEN_FAILURE but got %x\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->mach.ReducedLatencySleepDc=PowerSystemMaximum+2; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(!ret, "function was expected to fail\n"); + ok(GetLastError() == ERROR_GEN_FAILURE, "expected ERROR_GEN_FAILURE but got %x\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + pPP_original->mach.ReducedLatencySleepDc=PowerSystemWorking; + + + pPP_original->user.IdleAc.Action=PowerActionNone-2; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(!ret, "function was expected to fail\n"); + ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + //pp_compare.user.IdleAc.Action=4; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->user.IdleAc.Action=PowerActionNone-1; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(!ret, "function was expected to fail\n"); + ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + //pp_compare.user.IdleAc.Action=4; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->user.IdleAc.Action=PowerActionNone; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + //pp_compare.user.IdleAc.Action=4; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->user.IdleAc.Action=PowerActionReserved; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + //pp_compare.user.IdleAc.Action=4; + pp_compare.user.IdleAc.Action=2; + //pp_compare.user.pad1[2]=2; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->user.IdleAc.Action=PowerActionSleep; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + //pp_compare.user.IdleAc.Action=4; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->user.IdleAc.Action=PowerActionHibernate; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + pp_compare.user.IdleAc.Action=2; + //pp_compare.user.pad1[2]=2; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->user.IdleAc.Action=PowerActionShutdown; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->user.IdleAc.Action=PowerActionShutdownReset; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + //pp_compare.user.IdleAc.Action=4; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->user.IdleAc.Action=PowerActionShutdownOff; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->user.IdleAc.Action=PowerActionWarmEject; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->user.IdleAc.Action=PowerActionWarmEject+1; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(!ret, "function was expected to fail\n"); + ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->user.IdleAc.Action=PowerActionWarmEject+2; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(!ret, "function was expected to fail\n"); + ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + pPP_original->user.IdleAc.Action=PowerActionNone; + + + + pPP_original->user.IdleDc.Action=PowerActionNone-2; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(!ret, "function was expected to fail\n"); + ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + //pp_compare.user.IdleDc.Action=4; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->user.IdleDc.Action=PowerActionNone-1; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(!ret, "function was expected to fail\n"); + ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + //pp_compare.user.IdleDc.Action=4; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->user.IdleDc.Action=PowerActionNone; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + //pp_compare.user.IdleDc.Action=4; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->user.IdleDc.Action=PowerActionReserved; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + //pp_compare.user.IdleDc.Action=4; + pp_compare.user.IdleDc.Action=2; +// pp_compare.user.pad1[2]=2; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->user.IdleDc.Action=PowerActionSleep; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + //pp_compare.user.IdleDc.Action=4; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->user.IdleDc.Action=PowerActionHibernate; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + pp_compare.user.IdleDc.Action=2; +// pp_compare.user.pad1[2]=2; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->user.IdleDc.Action=PowerActionShutdown; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->user.IdleDc.Action=PowerActionShutdownReset; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + //pp_compare.user.IdleDc.Action=4; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->user.IdleDc.Action=PowerActionShutdownOff; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->user.IdleDc.Action=PowerActionWarmEject; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->user.IdleDc.Action=PowerActionWarmEject+1; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(!ret, "function was expected to fail\n"); + ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->user.IdleDc.Action=PowerActionWarmEject+2; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(!ret, "function was expected to fail\n"); + ok(GetLastError() == ERROR_INVALID_DATA, "expected ERROR_INVALID_DATA but got %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + pPP_original->user.IdleDc.Action=PowerActionNone; + + + pPP_original->user.MaxSleepAc=PowerSystemUnspecified-2; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + pp_compare.user.MaxSleepAc=4; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->user.MaxSleepAc=PowerSystemUnspecified-1; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + pp_compare.user.MaxSleepAc=4; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->user.MaxSleepAc=PowerSystemUnspecified; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(!ret, "function was expected to fail\n"); + ok(GetLastError() == ERROR_GEN_FAILURE, "expected ERROR_GEN_FAILURE but got %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + //pp_compare.user.MaxSleepAc=4; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->user.MaxSleepAc=PowerSystemWorking; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + pp_compare.user.MaxSleepAc=4; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->user.MaxSleepAc=PowerSystemSleeping1; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + pp_compare.user.MaxSleepAc=4; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->user.MaxSleepAc=PowerSystemSleeping2; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + pp_compare.user.MaxSleepAc=4; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->user.MaxSleepAc=PowerSystemSleeping3; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->user.MaxSleepAc=PowerSystemHibernate; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + pp_compare.user.MaxSleepAc=4; + pp_compare.user.MaxSleepAc=4; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->user.MaxSleepAc=PowerSystemShutdown; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + pp_compare.user.MaxSleepAc=4; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->user.MaxSleepAc=PowerSystemMaximum; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + pp_compare.user.MaxSleepAc=4; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->user.MaxSleepAc=PowerSystemMaximum+1; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + pp_compare.user.MaxSleepAc=4; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->user.MaxSleepAc=PowerSystemMaximum+2; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + pp_compare.user.MaxSleepAc=4; + ok(compare(pp,pp_compare),"Difference Found\n"); + pPP_original->user.MaxSleepAc=PowerSystemSleeping3; + + + pPP_original->user.MaxSleepDc=PowerSystemUnspecified-2; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + pp_compare.user.MaxSleepDc=4; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->user.MaxSleepDc=PowerSystemUnspecified-1; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + pp_compare.user.MaxSleepDc=4; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->user.MaxSleepDc=PowerSystemUnspecified; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(!ret, "function was expected to fail\n"); + ok(GetLastError() == ERROR_GEN_FAILURE, "expected ERROR_GEN_FAILURE but got %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + //pp_compare.user.MaxSleepDc=4; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->user.MaxSleepDc=PowerSystemWorking; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + pp_compare.user.MaxSleepDc=4; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->user.MaxSleepDc=PowerSystemSleeping1; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + pp_compare.user.MaxSleepDc=4; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->user.MaxSleepDc=PowerSystemSleeping2; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + pp_compare.user.MaxSleepDc=4; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->user.MaxSleepDc=PowerSystemSleeping3; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->user.MaxSleepDc=PowerSystemHibernate; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + pp_compare.user.MaxSleepDc=4; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->user.MaxSleepDc=PowerSystemShutdown; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + pp_compare.user.MaxSleepDc=4; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->user.MaxSleepDc=PowerSystemMaximum; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + pp_compare.user.MaxSleepDc=4; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->user.MaxSleepDc=PowerSystemMaximum+1; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + pp_compare.user.MaxSleepDc=4; + ok(compare(pp,pp_compare),"Difference Found\n"); + + pPP_original->user.MaxSleepDc=PowerSystemMaximum+2; + memcpy(&gpp, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&gpp_compare, pGPP_original, sizeof(GLOBAL_POWER_POLICY)); + memcpy(&pp, pPP_original, sizeof(POWER_POLICY)); + memcpy(&pp_compare, pPP_original, sizeof(POWER_POLICY)); + ret = ValidatePowerPolicies(&gpp,&pp); + ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError()); + ok(globalcompare(gpp,gpp_compare),"Difference Found\n"); + pp_compare.user.MaxSleepDc=4; + ok(compare(pp,pp_compare),"Difference Found\n"); + pPP_original->user.MaxSleepDc=PowerSystemSleeping3; + +} + void test_WriteGlobalPwrPolicy(void) { // WriteGlobalPwrPolicy(&gpp); @@ -867,6 +4850,10 @@ void test_WritePwrScheme(void) { DWORD retval; + HKEY hSubKey; + DWORD dwSize; + LONG Err; + WCHAR szPath[MAX_PATH]; static const WCHAR szTestSchemeName[] = {'P','o','w','r','p','r','o','f',0}; static const WCHAR szTestSchemeDesc[] = {'P','o','w','r','p','r','o','f',' ','S','c','h','e','m','e',0}; @@ -876,6 +4863,15 @@ retval = WritePwrScheme(&g_TempPwrScheme, (LPWSTR)szTestSchemeName, (LPWSTR)szTestSchemeDesc, &g_PowerPolicy); ok(retval, "Warning: function should have succeeded\n"); + if (RegOpenKeyW(HKEY_LOCAL_MACHINE, szMachPowerPoliciesSubKey, &hSubKey) == ERROR_SUCCESS) + { + dwSize = MAX_PATH * sizeof(WCHAR); + Err=RegQueryValueW(hSubKey, szTempPwrScheme, szPath, &dwSize); + if (Err != STATUS_SUCCESS) + printf("#1 failed to query subkey %i (testentry)\n", g_TempPwrScheme); + RegCloseKey(hSubKey); + } + } void func_power(void) @@ -899,197 +4895,9 @@ test_ReadGlobalPwrPolicy(); test_ReadProcessorPwrScheme(); test_SetSuspendState(); + test_ValidatePowerPolicies_Old(); test_ValidatePowerPolicies(); test_WriteGlobalPwrPolicy(); test_WriteProcessorPwrScheme(); } - -void func_ros_init(void) -{ - HKEY hUser, hKeyPowrCfg, hKeyGlobalPowrPol, hKeyPowerPolicies, hKeytmp; - DWORD err; - GLOBAL_USER_POWER_POLICY gupp; - GLOBAL_MACHINE_POWER_POLICY gmpp; - USER_POWER_POLICY upp; - MACHINE_POWER_POLICY mpp; - MACHINE_PROCESSOR_POWER_POLICY mppp; - GLOBAL_POWER_POLICY gpp; - POWER_POLICY pp; - - int i; - - static const WCHAR szUserPowrCfgKey[] = { 'C', 'o', 'n', 't', 'r', 'o', 'l', ' ', - 'P', 'a', 'n', 'e', 'l', '\\', 'P', 'o', 'w', 'e', 'r', 'C', 'f', 'g', 0}; - - static const WCHAR szCurrentPowerPolicy[] = {'C', 'u', 'r', 'r', 'e', 'n', 't', 'P', - 'o', 'w', 'e', 'r', 'P', 'o', 'l', 'i', 'c', 'y', 0}; - static const WCHAR szcpp[] = {'3', 0 }; - - static const WCHAR szGlobalPowerPolicy[] = { 'G', 'l', 'o', 'b', 'a', 'l', 'P', 'o', - 'w', 'e', 'r', 'P', 'o', 'l', 'i', 'c', 'y', 0}; - static const WCHAR szPolicies[] = {'P', 'o', 'l', 'i', 'c', 'i', 'e', 's', 0}; - static const WCHAR szPowerPolicies[] = { 'P', 'o', 'w', 'e', 'r', 'P', 'o', 'l', 'i', - 'c', 'i', 'e', 's', 0}; - - static const WCHAR szProcessorPolicies[] = { 'P', 'r', 'o', 'c', 'e', 's', 's', 'o', 'r', - 'P', 'o', 'l', 'i', 'c', 'i', 'e', 's', 0}; - - static const WCHAR szcName[] = {'N', 'a', 'm', 'e', 0}; - static const WCHAR szcDescription[] = {'D', 'e', 's', 'c', 'r', 'i', 'p', 't', 'i', 'o', 'n', 0}; - - static WCHAR szName[] = {'N', 'a', 'm', 'e', '(', '0', ')', 0}; - static WCHAR szDescription[] = {'D', 'e', 's', 'c', 'r', 'i', 'p', 't', 'i', 'o', 'n', '(', '0', ')', 0}; - - static const WCHAR szMachPowrCfgKey[] = {'S', 'O', 'F', 'T', 'W', 'A', 'R', 'E', '\\', 'M', 'i', - 'c', 'r', 'o', 's', 'o', 'f', 't', '\\', 'W', 'i', 'n', 'd', 'o', 'w', 's', '\\', 'C', 'u', - 'r', 'r', 'e', 'n', 't', 'V', 'e', 'r', 's', 'i', 'o', 'n', '\\', 'C', 'o', 'n', 't', 'r', - 'o', 'l', 's', ' ', 'F', 'o', 'l', 'd', 'e', 'r', '\\', 'P', 'o', 'w', 'e', 'r', 'C', 'f', 'g', 0}; - - static const WCHAR szLastID[] = {'L', 'a', 's', 't', 'I', 'D', 0}; - static const WCHAR szDiskSpinDownMax[] = {'D', 'i', 's', 'k', 'S', 'p', 'i', 'n', 'D', 'o', 'w', 'n', 'M', 'a', 'x', 0}; - static const WCHAR szDiskSpinDownMin[] = {'D', 'i', 's', 'k', 'S', 'p', 'i', 'n', 'D', 'o', 'w', 'n', 'M', 'i', 'n', 0}; - - static const WCHAR szLastIDValue[] = {'5', 0}; - static const WCHAR szDiskSpinDownMaxValue[] = {'3', '6', '0', '0', 0}; - static const WCHAR szDiskSpinDownMinValue[] = {'3', 0}; - - WCHAR tmp[20]; - /* - * Erstelle die Registry-struktur und Daten, welche dafür erforderlich ist damit diese Tests funktionieren - */ - - /* - * User - */ - err = RegOpenCurrentUser(KEY_ALL_ACCESS,&hUser); - ok(err == ERROR_SUCCESS,"Öffnen des Aktuellen Users Fehlgeschlagen\n"); - if (err == ERROR_SUCCESS) - { - err = RegCreateKey(hUser,szUserPowrCfgKey,&hKeyPowrCfg); - ok(err == ERROR_SUCCESS,"Create Key UserPowrCfg failed with error %i\n",(UINT)err); - ok(hKeyPowrCfg != NULL,"Erstellen des Eintrages Powercfg fehlgeschalgen\n"); - err = RegSetValueExW(hKeyPowrCfg,szCurrentPowerPolicy,(DWORD)NULL,REG_SZ,(CONST BYTE *)szcpp,strlenW(szcpp)*sizeof(WCHAR)); - ok(err == ERROR_SUCCESS,"Set Value CurrentPowerPolicy failed with error %i\n",(UINT)err); - err = RegCreateKey(hKeyPowrCfg,szGlobalPowerPolicy,&hKeyGlobalPowrPol); - ok(err == ERROR_SUCCESS,"Create Key GlobalPowerPolicy failed with error %i\n",(UINT)err); - gupp.Revision = 1; - gupp.PowerButtonAc.Action = PowerActionNone; - gupp.PowerButtonDc.Action = PowerActionNone; - gupp.SleepButtonAc.Action = PowerActionNone; - gupp.SleepButtonDc.Action = PowerActionNone; - gupp.LidCloseAc.Action = PowerActionNone; - gupp.LidCloseDc.Action = PowerActionNone; - for (i=0; i