+ pp_original.mach.MinSleepAc=PowerSystemUnspecified-1;
+ memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
+ memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
+ ret = ValidatePowerPolicies(0,&pp);
+ ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
+ pp_compare.mach.MinSleepAc=4;
+ pp_compare.mach.MinSleepDc=4;
+ pp_compare.user.MaxSleepAc=4;
+ pp_compare.user.MaxSleepDc=4;
+ pp_compare.user.OptimizeForPowerAc=1;
+ pp_compare.user.OptimizeForPowerDc=1;
+ ok(compare(pp,pp_compare),"Difference Found\n");
+
+ pp_original.mach.MinSleepDc=PowerSystemUnspecified-1;
+ memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
+ memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
+ ret = ValidatePowerPolicies(0,&pp);
+ ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
+ pp_compare.mach.MinSleepAc=4;
+ pp_compare.mach.MinSleepDc=4;
+ pp_compare.user.MaxSleepAc=4;
+ pp_compare.user.MaxSleepDc=4;
+ pp_compare.user.OptimizeForPowerAc=1;
+ pp_compare.user.OptimizeForPowerDc=1;
+ ok(compare(pp,pp_compare),"Difference Found\n");
+
+ pp_original.user.MaxSleepAc=PowerSystemUnspecified-1;
+ memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
+ memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
+ ret = ValidatePowerPolicies(0,&pp);
+ ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
+ pp_compare.mach.MinSleepAc=4;
+ pp_compare.mach.MinSleepDc=4;
+ pp_compare.user.MaxSleepAc=4;
+ pp_compare.user.MaxSleepDc=4;
+ pp_compare.user.OptimizeForPowerAc=1;
+ pp_compare.user.OptimizeForPowerDc=1;
+ ok(compare(pp,pp_compare),"Difference Found\n");
+
+ pp_original.user.MaxSleepDc=PowerSystemUnspecified-1;
+ memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
+ memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
+ ret = ValidatePowerPolicies(0,&pp);
+ ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
+ pp_compare.mach.MinSleepAc=4;
+ pp_compare.mach.MinSleepDc=4;
+ pp_compare.user.MaxSleepAc=4;
+ pp_compare.user.MaxSleepDc=4;
+ pp_compare.user.OptimizeForPowerAc=1;
+ pp_compare.user.OptimizeForPowerDc=1;
+ ok(compare(pp,pp_compare),"Difference Found\n");
+
+ pp_original.mach.MinSleepAc=PowerSystemUnspecified;
+ memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
+ memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
+ ret = ValidatePowerPolicies(0,&pp);
+ ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
+ pp_compare.mach.MinSleepAc=4;
+ pp_compare.mach.MinSleepDc=4;
+ pp_compare.user.MaxSleepAc=4;
+ pp_compare.user.MaxSleepDc=4;
+ pp_compare.user.OptimizeForPowerAc=1;
+ pp_compare.user.OptimizeForPowerDc=1;
+ ok(compare(pp,pp_compare),"Difference Found\n");
+
+ pp_original.mach.MinSleepDc=PowerSystemUnspecified;
+ memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
+ memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
+ ret = ValidatePowerPolicies(0,&pp);
+ ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
+ pp_compare.mach.MinSleepAc=4;
+ pp_compare.mach.MinSleepDc=4;
+ pp_compare.user.MaxSleepAc=4;
+ pp_compare.user.MaxSleepDc=4;
+ pp_compare.user.OptimizeForPowerAc=1;
+ pp_compare.user.OptimizeForPowerDc=1;
+ ok(compare(pp,pp_compare),"Difference Found\n");
+
+ pp_original.user.MaxSleepAc=PowerSystemUnspecified;
+ memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
+ memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
+ ret = ValidatePowerPolicies(0,&pp);
+ ok(!ret, "function was expected to fail\n");
+ ok(GetLastError() == ERROR_GEN_FAILURE,"function was expected to fail with ERROR_GEN_FAILURE, but error :%i\n",(UINT)GetLastError());
+ ok(compare(pp,pp_compare),"Difference Found\n");
+
+ pp_original.user.MaxSleepDc=PowerSystemUnspecified;
+ memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
+ memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
+ ret = ValidatePowerPolicies(0,&pp);
+ ok(!ret, "function was expected to fail\n");
+ ok(GetLastError() == ERROR_GEN_FAILURE,"function was expected to fail with ERROR_GEN_FAILURE, but error :%i\n",(UINT)GetLastError());
+ ok(compare(pp,pp_compare),"Difference Found\n");
+
+ pp_original.mach.MinSleepAc=PowerSystemWorking;
+ memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
+ memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
+ ret = ValidatePowerPolicies(0,&pp);
+ ok(!ret, "function was expected to fail\n");
+ ok(GetLastError() == ERROR_GEN_FAILURE,"function was expected to fail with ERROR_GEN_FAILURE, but error :%i\n",(UINT)GetLastError());
+ //pp_compare.mach.MinSleepAc=4;
+ //pp_compare.mach.MinSleepDc=4;
+ //pp_compare.user.MaxSleepAc=4;
+ //pp_compare.user.MaxSleepDc=4;
+ ok(compare(pp,pp_compare),"Difference Found\n");
+
+ pp_original.mach.MinSleepDc=PowerSystemWorking;
+ memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
+ memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
+ ret = ValidatePowerPolicies(0,&pp);
+ ok(!ret, "function was expected to fail\n");
+ ok(GetLastError() == ERROR_GEN_FAILURE,"function was expected to fail with ERROR_GEN_FAILURE, but error :%i\n",(UINT)GetLastError());
+ //pp_compare.mach.MinSleepAc=4;
+ //pp_compare.mach.MinSleepDc=4;
+ //pp_compare.user.MaxSleepAc=4;
+ //pp_compare.user.MaxSleepDc=4;
+ ok(compare(pp,pp_compare),"Difference Found\n");
+
+ pp_original.user.MaxSleepAc=PowerSystemWorking;
+ memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
+ memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
+ ret = ValidatePowerPolicies(0,&pp);
+ ok(!ret, "function was expected to fail\n");
+ ok(GetLastError() == ERROR_GEN_FAILURE,"function was expected to fail with ERROR_GEN_FAILURE, but error :%i\n",(UINT)GetLastError());
+ //pp_compare.mach.MinSleepAc=4;
+ //pp_compare.mach.MinSleepDc=4;
+ //pp_compare.user.MaxSleepAc=4;
+ //pp_compare.user.MaxSleepDc=4;
+ //pp_compare.user.OptimizeForPowerAc=1;
+ //pp_compare.user.OptimizeForPowerDc=1;
+ ok(compare(pp,pp_compare),"Difference Found\n");
+
+ pp_original.user.MaxSleepDc=PowerSystemWorking;
+ memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
+ memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
+ ret = ValidatePowerPolicies(0,&pp);
+ ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
+ pp_compare.mach.MinSleepAc=4;
+ pp_compare.mach.MinSleepDc=4;
+ pp_compare.user.MaxSleepAc=4;
+ pp_compare.user.MaxSleepDc=4;
+ pp_compare.user.OptimizeForPowerAc=1;
+ pp_compare.user.OptimizeForPowerDc=1;
+ ok(compare(pp,pp_compare),"Difference Found\n");
+
+ pp_original.mach.MinSleepAc=PowerSystemSleeping1;
+ memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
+ memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
+ ret = ValidatePowerPolicies(0,&pp);
+ ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
+ pp_compare.mach.MinSleepAc=4;
+ pp_compare.mach.MinSleepDc=4;
+ pp_compare.user.MaxSleepAc=4;
+ pp_compare.user.MaxSleepDc=4;
+ pp_compare.user.OptimizeForPowerAc=1;
+ pp_compare.user.OptimizeForPowerDc=1;
+ ok(compare(pp,pp_compare),"Difference Found\n");
+
+ pp_original.mach.MinSleepDc=PowerSystemSleeping1;
+ memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
+ memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
+ ret = ValidatePowerPolicies(0,&pp);
+ ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
+ pp_compare.mach.MinSleepAc=4;
+ pp_compare.mach.MinSleepDc=4;
+ pp_compare.user.MaxSleepAc=4;
+ pp_compare.user.MaxSleepDc=4;
+ pp_compare.user.OptimizeForPowerAc=1;
+ pp_compare.user.OptimizeForPowerDc=1;
+ ok(compare(pp,pp_compare),"Difference Found\n");
+
+ pp_original.user.MaxSleepAc=PowerSystemSleeping1;
+ memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
+ memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
+ ret = ValidatePowerPolicies(0,&pp);
+ ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
+ pp_compare.mach.MinSleepAc=4;
+ pp_compare.mach.MinSleepDc=4;
+ pp_compare.user.MaxSleepAc=4;
+ pp_compare.user.MaxSleepDc=4;
+ pp_compare.user.OptimizeForPowerAc=1;
+ pp_compare.user.OptimizeForPowerDc=1;
+ ok(compare(pp,pp_compare),"Difference Found\n");
+
+ pp_original.user.MaxSleepDc=PowerSystemSleeping1;
+ memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
+ memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
+ ret = ValidatePowerPolicies(0,&pp);
+ ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
+ pp_compare.mach.MinSleepAc=4;
+ pp_compare.mach.MinSleepDc=4;
+ pp_compare.user.MaxSleepAc=4;
+ pp_compare.user.MaxSleepDc=4;
+ pp_compare.user.OptimizeForPowerAc=1;
+ pp_compare.user.OptimizeForPowerDc=1;
+ ok(compare(pp,pp_compare),"Difference Found\n");
+
+ pp_original.mach.MinSleepAc=PowerSystemSleeping2;
+ memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
+ memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
+ ret = ValidatePowerPolicies(0,&pp);
+ ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
+ pp_compare.mach.MinSleepAc=4;
+ pp_compare.mach.MinSleepDc=4;
+ pp_compare.user.MaxSleepAc=4;
+ pp_compare.user.MaxSleepDc=4;
+ pp_compare.user.OptimizeForPowerAc=1;
+ pp_compare.user.OptimizeForPowerDc=1;
+ ok(compare(pp,pp_compare),"Difference Found\n");
+
+ pp_original.mach.MinSleepDc=PowerSystemSleeping2;
+ memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
+ memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
+ ret = ValidatePowerPolicies(0,&pp);
+ ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
+ pp_compare.mach.MinSleepAc=4;
+ pp_compare.mach.MinSleepDc=4;
+ pp_compare.user.MaxSleepAc=4;
+ pp_compare.user.MaxSleepDc=4;
+ pp_compare.user.OptimizeForPowerAc=1;
+ pp_compare.user.OptimizeForPowerDc=1;
+ ok(compare(pp,pp_compare),"Difference Found\n");
+
+ pp_original.user.MaxSleepAc=PowerSystemSleeping2;
+ memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
+ memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
+ ret = ValidatePowerPolicies(0,&pp);
+ ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
+ pp_compare.mach.MinSleepAc=4;
+ pp_compare.mach.MinSleepDc=4;
+ pp_compare.user.MaxSleepAc=4;
+ pp_compare.user.MaxSleepDc=4;
+ pp_compare.user.OptimizeForPowerAc=1;
+ pp_compare.user.OptimizeForPowerDc=1;
+ ok(compare(pp,pp_compare),"Difference Found\n");
+
+ pp_original.user.MaxSleepDc=PowerSystemSleeping2;
+ memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
+ memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
+ ret = ValidatePowerPolicies(0,&pp);
+ ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
+ pp_compare.mach.MinSleepAc=4;
+ pp_compare.mach.MinSleepDc=4;
+ pp_compare.user.MaxSleepAc=4;
+ pp_compare.user.MaxSleepDc=4;
+ pp_compare.user.OptimizeForPowerAc=1;
+ pp_compare.user.OptimizeForPowerDc=1;
+ ok(compare(pp,pp_compare),"Difference Found\n");
+
+ pp_original.mach.MinSleepAc=PowerSystemSleeping3;
+ memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
+ memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
+ ret = ValidatePowerPolicies(0,&pp);
+ ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
+ pp_compare.mach.MinSleepDc=4;
+ pp_compare.user.MaxSleepAc=4;
+ pp_compare.user.MaxSleepDc=4;
+ pp_compare.user.OptimizeForPowerAc=1;
+ pp_compare.user.OptimizeForPowerDc=1;
+ ok(compare(pp,pp_compare),"Difference Found\n");
+
+ pp_original.mach.MinSleepDc=PowerSystemSleeping3;
+ memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
+ memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
+ ret = ValidatePowerPolicies(0,&pp);
+ ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
+ pp_compare.user.MaxSleepAc=4;
+ pp_compare.user.MaxSleepDc=4;
+ pp_compare.user.OptimizeForPowerAc=1;
+ pp_compare.user.OptimizeForPowerDc=1;
+ ok(compare(pp,pp_compare),"Difference Found\n");
+
+ pp_original.user.MaxSleepAc=PowerSystemSleeping3;
+ memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
+ memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
+ ret = ValidatePowerPolicies(0,&pp);
+ ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
+ pp_compare.user.MaxSleepDc=4;
+ pp_compare.user.OptimizeForPowerAc=1;
+ pp_compare.user.OptimizeForPowerDc=1;
+ ok(compare(pp,pp_compare),"Difference Found\n");
+
+ pp_original.user.MaxSleepDc=PowerSystemSleeping3;
+ memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
+ memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
+ ret = ValidatePowerPolicies(0,&pp);
+ ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
+ pp_compare.user.OptimizeForPowerAc=1;
+ pp_compare.user.OptimizeForPowerDc=1;
+ ok(compare(pp,pp_compare),"Difference Found\n");
+
+ pp_original.mach.MinSleepAc=PowerSystemHibernate;
+ memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
+ memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
+ ret = ValidatePowerPolicies(0,&pp);
+ ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
+ pp_compare.mach.MinSleepAc=4;
+ pp_compare.mach.MinSleepDc=4;
+ pp_compare.user.MaxSleepAc=4;
+ pp_compare.user.MaxSleepDc=4;
+ pp_compare.user.OptimizeForPowerAc=1;
+ pp_compare.user.OptimizeForPowerDc=1;
+ ok(compare(pp,pp_compare),"Difference Found\n");
+
+ pp_original.mach.MinSleepDc=PowerSystemHibernate;
+ memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
+ memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
+ ret = ValidatePowerPolicies(0,&pp);
+ ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
+ pp_compare.mach.MinSleepAc=4;
+ pp_compare.mach.MinSleepDc=4;
+ pp_compare.user.MaxSleepAc=4;
+ pp_compare.user.MaxSleepDc=4;
+ pp_compare.user.OptimizeForPowerAc=1;
+ pp_compare.user.OptimizeForPowerDc=1;
+ ok(compare(pp,pp_compare),"Difference Found\n");
+
+ pp_original.user.MaxSleepAc=PowerSystemHibernate;
+ memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
+ memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
+ ret = ValidatePowerPolicies(0,&pp);
+ ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
+ pp_compare.mach.MinSleepAc=4;
+ pp_compare.mach.MinSleepDc=4;
+ pp_compare.user.MaxSleepAc=4;
+ pp_compare.user.MaxSleepDc=4;
+ pp_compare.user.OptimizeForPowerAc=1;
+ pp_compare.user.OptimizeForPowerDc=1;
+ ok(compare(pp,pp_compare),"Difference Found\n");
+
+ pp_original.user.MaxSleepDc=PowerSystemHibernate;
+ memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
+ memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
+ ret = ValidatePowerPolicies(0,&pp);
+ ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
+ pp_compare.mach.MinSleepAc=4;
+ pp_compare.mach.MinSleepDc=4;
+ pp_compare.user.MaxSleepAc=4;
+ pp_compare.user.MaxSleepDc=4;
+ pp_compare.user.OptimizeForPowerAc=1;
+ pp_compare.user.OptimizeForPowerDc=1;
+ ok(compare(pp,pp_compare),"Difference Found\n");
+
+ pp_original.mach.MinSleepAc=PowerSystemShutdown;
+ memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
+ memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
+ ret = ValidatePowerPolicies(0,&pp);
+ ok(!ret, "function was expected to fail\n");
+ ok(GetLastError() == ERROR_GEN_FAILURE,"function was expected to fail with ERROR_GEN_FAILURE, but error :%i\n",(UINT)GetLastError());
+ ok(compare(pp,pp_compare),"Difference Found\n");
+
+ pp_original.mach.MinSleepDc=PowerSystemShutdown;
+ memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
+ memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
+ ret = ValidatePowerPolicies(0,&pp);
+ ok(!ret, "function was expected to fail\n");
+ ok(GetLastError() == ERROR_GEN_FAILURE,"function was expected to fail with ERROR_GEN_FAILURE, but error :%i\n",(UINT)GetLastError());
+ ok(compare(pp,pp_compare),"Difference Found\n");
+
+ pp_original.user.MaxSleepAc=PowerSystemShutdown;
+ memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
+ memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
+ ret = ValidatePowerPolicies(0,&pp);
+ ok(!ret, "function was expected to fail\n");
+ ok(GetLastError() == ERROR_GEN_FAILURE,"function was expected to fail with ERROR_GEN_FAILURE, but error :%i\n",(UINT)GetLastError());
+ ok(compare(pp,pp_compare),"Difference Found\n");
+
+ pp_original.user.MaxSleepDc=PowerSystemShutdown;
+ memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
+ memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
+ ret = ValidatePowerPolicies(0,&pp);
+ ok(!ret, "function was expected to fail\n");
+ ok(GetLastError() == ERROR_GEN_FAILURE,"function was expected to fail with ERROR_GEN_FAILURE, but error :%i\n",(UINT)GetLastError());
+ ok(compare(pp,pp_compare),"Difference Found\n");
+
+ pp_original.mach.MinSleepAc=PowerSystemMaximum;
+ memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
+ memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
+ ret = ValidatePowerPolicies(0,&pp);
+ ok(!ret, "function was expected to fail\n");
+ ok(GetLastError() == ERROR_GEN_FAILURE,"function was expected to fail with ERROR_GEN_FAILURE, but error :%i\n",(UINT)GetLastError());
+ ok(compare(pp,pp_compare),"Difference Found\n");
+
+ pp_original.mach.MinSleepDc=PowerSystemMaximum;
+ memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
+ memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
+ ret = ValidatePowerPolicies(0,&pp);
+ ok(!ret, "function was expected to fail\n");
+ ok(GetLastError() == ERROR_GEN_FAILURE,"function was expected to fail with ERROR_GEN_FAILURE, but error :%i\n",(UINT)GetLastError());
+ ok(compare(pp,pp_compare),"Difference Found\n");
+
+ pp_original.user.MaxSleepAc=PowerSystemMaximum;
+ memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
+ memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
+ ret = ValidatePowerPolicies(0,&pp);
+ ok(!ret, "function was expected to fail\n");
+ ok(GetLastError() == ERROR_GEN_FAILURE,"function was expected to fail with ERROR_GEN_FAILURE, but error :%i\n",(UINT)GetLastError());
+ ok(compare(pp,pp_compare),"Difference Found\n");
+
+ pp_original.user.MaxSleepDc=PowerSystemMaximum;
+ memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
+ memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
+ ret = ValidatePowerPolicies(0,&pp);
+ ok(!ret, "function was expected to fail\n");
+ ok(GetLastError() == ERROR_GEN_FAILURE,"function was expected to fail with ERROR_GEN_FAILURE, but error :%i\n",(UINT)GetLastError());
+ ok(compare(pp,pp_compare),"Difference Found\n");
+
+ pp_original.mach.MinSleepAc=PowerSystemMaximum+1;
+ memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
+ memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
+ ret = ValidatePowerPolicies(0,&pp);
+ ok(!ret, "function was expected to fail\n");
+ ok(GetLastError() == ERROR_GEN_FAILURE,"function was expected to fail with ERROR_GEN_FAILURE, but error :%i\n",(UINT)GetLastError());
+ ok(compare(pp,pp_compare),"Difference Found\n");
+
+ pp_original.mach.MinSleepDc=PowerSystemMaximum+1;
+ memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
+ memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
+ ret = ValidatePowerPolicies(0,&pp);
+ ok(!ret, "function was expected to fail\n");
+ ok(GetLastError() == ERROR_GEN_FAILURE,"function was expected to fail with ERROR_GEN_FAILURE, but error :%i\n",(UINT)GetLastError());
+ ok(compare(pp,pp_compare),"Difference Found\n");
+
+ pp_original.user.MaxSleepAc=PowerSystemMaximum+1;
+ memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
+ memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
+ ret = ValidatePowerPolicies(0,&pp);
+ ok(!ret, "function was expected to fail\n");
+ ok(GetLastError() == ERROR_GEN_FAILURE,"function was expected to fail with ERROR_GEN_FAILURE, but error :%i\n",(UINT)GetLastError());
+ ok(compare(pp,pp_compare),"Difference Found\n");
+
+ pp_original.user.MaxSleepDc=PowerSystemMaximum+1;
+ memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
+ memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
+ ret = ValidatePowerPolicies(0,&pp);
+ ok(!ret, "function was expected to fail\n");
+ ok(GetLastError() == ERROR_GEN_FAILURE,"function was expected to fail with ERROR_GEN_FAILURE, but error :%i\n",(UINT)GetLastError());
+ ok(compare(pp,pp_compare),"Difference Found\n");
+
+ pp_original.mach.MinSleepAc=PowerSystemWorking;
+ pp_original.mach.MinSleepDc=PowerSystemWorking;
+ pp_original.user.MaxSleepAc=PowerSystemWorking;
+ pp_original.user.MaxSleepDc=PowerSystemWorking;
+
+
+ test_ValidatePowerPolicies_Next(&gpp_original,&pp_original);
+
+
+ // memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ // memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ //memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
+ // memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
+ ret = GetCurrentPowerPolicies(&gpp_original,&pp_original);
+ ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
+ //gpp_compare.mach.BroadcastCapacityResolution = 3;
+ //gpp_compare.user.PowerButtonAc.Action = 2;
+ //gpp_compare.user.PowerButtonAc.Flags=3;
+ //gpp_compare.user.PowerButtonDc.EventCode=16;
+ //gpp_compare.user.PowerButtonDc.Flags=3;
+ //gpp_compare.user.SleepButtonAc.Action=2;
+ //gpp_compare.user.SleepButtonAc.Flags=3;
+ //gpp_compare.user.SleepButtonDc.Action=2;
+ //gpp_compare.user.SleepButtonDc.Flags=3;
+ //gpp_compare.user.LidCloseAc.EventCode=-2147483648;
+ //gpp_compare.user.LidCloseAc.Flags=1;
+ //gpp_compare.user.LidCloseDc.EventCode=-2147483648;
+ //gpp_compare.user.LidCloseDc.Flags=1;
+
+ //gpp_compare.user.DischargePolicy[0].Enable=1;
+ ////gpp_compare.user.DischargePolicy[0].Spare[0]=3;
+ //gpp_compare.user.DischargePolicy[0].Spare[3]=3;
+ //gpp_compare.user.DischargePolicy[0].BatteryLevel=3;
+ //gpp_compare.user.DischargePolicy[0].PowerPolicy.Action=2;
+ //gpp_compare.user.DischargePolicy[0].PowerPolicy.Flags=-1073741820;
+ //gpp_compare.user.DischargePolicy[0].PowerPolicy.EventCode=1;
+ //gpp_compare.user.DischargePolicy[0].MinSystemState=4;
+
+ //gpp_compare.user.DischargePolicy[1].Enable=1;
+ ////gpp_compare.user.DischargePolicy[1].Spare[0]=3;
+ //gpp_compare.user.DischargePolicy[1].Spare[3]=10;
+ //gpp_compare.user.DischargePolicy[1].BatteryLevel=10;
+ ////gpp_compare.user.DischargePolicy[1].PowerPolicy.Action=3;
+ //gpp_compare.user.DischargePolicy[1].PowerPolicy.Flags=3;
+ //gpp_compare.user.DischargePolicy[1].PowerPolicy.EventCode=65537;
+ //gpp_compare.user.DischargePolicy[1].MinSystemState=1;
+ //
+ //gpp_compare.user.DischargePolicy[2].PowerPolicy.EventCode=131072;
+ //gpp_compare.user.DischargePolicy[3].PowerPolicy.EventCode=196608;
+ //gpp_compare.user.GlobalFlags=20;
+
+ //ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
+ //pp_compare.mach.MinSleepAc=4;
+ //pp_compare.mach.MinSleepDc=4;
+ //pp_compare.mach.ReducedLatencySleepAc=4;
+ //pp_compare.mach.ReducedLatencySleepDc=4;
+ //pp_compare.mach.OverThrottledAc.Action=2;
+ //pp_compare.mach.OverThrottledAc.Flags=-1073741820;
+ //pp_compare.mach.OverThrottledDc.Action=2;
+ //pp_compare.mach.OverThrottledDc.Flags=-1073741820;
+ //pp_compare.mach.pad1[2]=2;
+ //pp_compare.user.IdleAc.Flags=1;
+ //pp_compare.user.IdleDc.Flags=1;
+ //pp_compare.user.IdleSensitivityAc=50;
+ //pp_compare.user.IdleSensitivityDc=50;
+ //pp_compare.user.ThrottlePolicyAc=3;
+ //pp_compare.user.ThrottlePolicyDc=3;
+ //pp_compare.user.Reserved[2]=1200;
+ //pp_compare.user.VideoTimeoutAc=1200;
+ //pp_compare.user.VideoTimeoutDc=600;
+ //pp_compare.user.SpindownTimeoutAc=2700;
+ //pp_compare.user.SpindownTimeoutDc=600;
+ //pp_compare.user.FanThrottleToleranceAc=100;
+ //pp_compare.user.FanThrottleToleranceDc=80;
+ //pp_compare.user.ForcedThrottleAc=100;
+ //pp_compare.user.ForcedThrottleDc=100;
+ //pp_compare.user.MaxSleepAc=4;
+ //pp_compare.user.MaxSleepDc=4;
+ //pp_compare.user.OptimizeForPowerAc=1;
+ //pp_compare.user.OptimizeForPowerDc=1;
+ //ok(compare(pp,pp_compare),"Difference Found\n");
+
+ memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
+ memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
+ ret = ValidatePowerPolicies(&gpp,0);
+ ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
+ //gpp_compare.mach.BroadcastCapacityResolution=100;
+ //gpp_compare.user.DischargePolicy[1].PowerPolicy.EventCode = 65536;
+ //gpp_compare.user.DischargePolicy[2].PowerPolicy.EventCode = 131072;
+ //gpp_compare.user.DischargePolicy[3].PowerPolicy.EventCode = 196608;
+ ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
+
+ memcpy(&gpp, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&gpp_compare, &gpp_original, sizeof(GLOBAL_POWER_POLICY));
+ memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
+ memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
+ ret = ValidatePowerPolicies(0,&pp);
+ ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
+ //pp_compare.mach.MinSleepAc=4;
+ //pp_compare.mach.MinSleepDc=4;
+ //pp_compare.user.MaxSleepAc=4;
+ //pp_compare.user.MaxSleepDc=4;
+ //pp_compare.user.OptimizeForPowerAc=1;
+ //pp_compare.user.OptimizeForPowerDc=1;
+ ok(compare(pp,pp_compare),"Difference Found\n");
+
+ memcpy(&pp, &pp_original, sizeof(POWER_POLICY));
+ memcpy(&pp_compare, &pp_original, sizeof(POWER_POLICY));
+ ret = ValidatePowerPolicies(&gpp,&pp);
+ ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
+ //gpp_compare.mach.BroadcastCapacityResolution=100;
+ //gpp_compare.user.DischargePolicy[1].PowerPolicy.EventCode = 65536;
+ //gpp_compare.user.DischargePolicy[2].PowerPolicy.EventCode = 131072;
+ //gpp_compare.user.DischargePolicy[3].PowerPolicy.EventCode = 196608;
+ ok(globalcompare(gpp,gpp_compare),"Difference Found\n");
+ pp_compare.mach.MinSleepAc=4;
+ pp_compare.mach.MinSleepDc=4;
+ pp_compare.user.MaxSleepAc=4;
+ pp_compare.user.MaxSleepDc=4;
+ //pp_compare.user.OptimizeForPowerAc=1;
+ //pp_compare.user.OptimizeForPowerDc=1;
+ ok(compare(pp,pp_compare),"Difference Found\n");
+
+}
+
+void test_ValidatePowerPolicies_Next(PGLOBAL_POWER_POLICY pGPP_original,PPOWER_POLICY pPP_original)
+{
+ GLOBAL_POWER_POLICY gpp, gpp_compare;
+ POWER_POLICY pp, pp_compare;
+ BOOLEAN ret;
+
+ //printf("Old: %i\n",pGPP_original->mach.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);
+}
+
+void test_WriteProcessorPwrScheme(void)
+{
+// WriteProcessorPwrScheme(0,&mppp);
+}
+
+void test_WritePwrScheme(void)
+{
+ DWORD retval;
+ HKEY hSubKey;
+ LONG lSize;
+ 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};
+
+ /*
+ * create a temporarly profile, will be deleted in test_DeletePwrScheme
+ */
+
+ 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)
+ {
+ lSize = MAX_PATH * sizeof(WCHAR);
+ Err = RegQueryValueW(hSubKey, szTempPwrScheme, szPath, &lSize);
+ if (Err != STATUS_SUCCESS)
+ printf("#1 failed to query subkey %i (testentry)\n", g_TempPwrScheme);
+ RegCloseKey(hSubKey);
+ }
+
+}
+
+void func_power(void)
+{
+ test_CallNtPowerInformation();
+ test_CanUserWritePwrScheme();
+ test_EnumPwrSchemes();
+ test_GetSetActivePwrScheme();
+ test_ReadPwrScheme();
+ test_WritePwrScheme();
+ test_DeletePwrScheme();
+ test_GetPwrDiskSpindownRange();
+
+ test_GetCurrentPowerPolicies();
+
+ test_GetPwrCapabilities();
+ test_IsAdminOverrideActive();
+ test_IsPwrHibernateAllowed();
+ test_IsPwrShutdownAllowed();
+ test_IsPwrSuspendAllowed();
+ test_ReadGlobalPwrPolicy();
+ test_ReadProcessorPwrScheme();
+ test_SetSuspendState();
+ test_ValidatePowerPolicies_Old();
+ test_ValidatePowerPolicies();
+ test_WriteGlobalPwrPolicy();
+ test_WriteProcessorPwrScheme();