rostests/winetests/powrprof/pwrprof.c

   1 #include<stdarg.h>
   2 #include "ntstatus.h"
   3 #define WIN32_NO_STATUS
   4 #define STANDALONE
   5 #include "wine/test.h"
   6 #include "winternl.h"
   7 #include "windef.h"
   8 #include "winbase.h"
   9 #include "powrprof.h"
  10 #include "assert.h"
  11
  12 #include "wine/unicode.h"
  13 /*
  14    LONG WINAPI RegOpenCurrentUser(REGSAM a,PHKEY b)
  15    {
  16       *b = HKEY_CURRENT_USER;
  17       return ERROR_SUCCESS;
  18    }
  19  */
  20 unsigned int g_NumPwrSchemes = 0;
  21 unsigned int g_NumPwrSchemesEnumerated = 0;
  22 unsigned int g_ActivePwrScheme = 3;
  23 unsigned int g_TempPwrScheme = 99;
  24
  25 #if 0 // FIXME: needed to build. Please update pwrprof winetest.
  26 typedef struct _PROCESSOR_POWER_INFORMATION {
  27    ULONG Number;
  28    ULONG MaxMhz;
  29    ULONG CurrentMhz;
  30    ULONG MhzLimit;
  31    ULONG MaxIdleState;
  32    ULONG CurrentIdleState;
  33 } PROCESSOR_POWER_INFORMATION,
  34 *PPROCESSOR_POWER_INFORMATION;
  35 #endif
  36
  37 POWER_POLICY g_PowerPolicy;
  38
  39 static const WCHAR szMachPowerPoliciesSubKey[] = { 'S', 'O', 'F', 'T', 'W', 'A', 'R',
  40                                                    'E', '\\', 'M', 'i', 'c', 'r', 'o', 's', 'o', 'f', 't', '\\', 'W', 'i', 'n', 'd',
  41                                                    'o', 'w', 's', '\\', 'C', 'u', 'r', 'r', 'e', 'n', 't', 'V', 'e', 'r', 's', 'i',
  42                                                    'o', 'n', '\\', 'C', 'o', 'n', 't', 'r', 'o', 'l', 's', ' ', 'F', 'o', 'l', 'd',
  43                                                    'e', 'r', '\\', 'P', 'o', 'w', 'e', 'r', 'C', 'f', 'g', '\\', 'P', 'o', 'w', 'e',
  44                                                    'r', 'P', 'o', 'l', 'i', 'c', 'i', 'e', 's', 0};
  45
  46 static const WCHAR szTempPwrScheme[] = { '9', '9', 0 };
  47
  48 ULONG DbgPrint(PCCH X,...)
  49 {
  50    return (ULONG)NULL;
  51 }
  52
  53 void test_CallNtPowerInformation(void)
  54 {
  55    DWORD retval;
  56    ADMINISTRATOR_POWER_POLICY apolicy;
  57    ULONGLONG atime, ctime;
  58    PROCESSOR_POWER_INFORMATION ppi, *pppi;
  59    PROCESSOR_POWER_POLICY ppp;
  60    SYSTEM_BATTERY_STATE sbs;
  61    SYSTEM_POWER_CAPABILITIES spc;
  62    SYSTEM_POWER_INFORMATION spi;
  63    SYSTEM_POWER_POLICY spp;
  64    HANDLE x=NULL;
  65
  66    /* AdministratorPowerPolicy tests */
  67    retval = CallNtPowerInformation(AdministratorPowerPolicy, 0, 0, 0, 0);
  68    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
  69    retval = CallNtPowerInformation(AdministratorPowerPolicy, 0, 0, &apolicy, sizeof(ADMINISTRATOR_POWER_POLICY));
  70    ok(retval == STATUS_SUCCESS, "function expected STATUS_SUCCESS but got %d\n", (UINT)retval);
  71    retval = CallNtPowerInformation(AdministratorPowerPolicy, &apolicy, sizeof(ADMINISTRATOR_POWER_POLICY), 0, 0);
  72    ok(retval != STATUS_PRIVILEGE_NOT_HELD, "Privileg not held!!!! more errors to expect");
  73    ok(retval == STATUS_SUCCESS, "function expected STATUS_SUCCESS but got %d\n", (UINT)retval);
  74
  75    /* LastSleepTime tests */
  76    retval = CallNtPowerInformation(LastSleepTime, 0, 0, 0, 0);
  77    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
  78    retval = CallNtPowerInformation(LastSleepTime, &atime, sizeof(sizeof(ULONGLONG)), 0, 0);
  79    ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
  80    retval = CallNtPowerInformation(LastSleepTime, &atime, sizeof(ULONGLONG), &ctime, sizeof(ULONGLONG));
  81    ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
  82    retval = CallNtPowerInformation(LastSleepTime, 0, 0, &atime, sizeof(ULONGLONG));
  83    ok(retval == STATUS_SUCCESS, "function expected STATUS_SUCCESS but got %d\n",(UINT)retval);
  84
  85    /* LastWakeTime tests */
  86    retval = CallNtPowerInformation(LastWakeTime, 0, 0, 0, 0);
  87    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
  88    retval = CallNtPowerInformation(LastWakeTime, &atime, sizeof(sizeof(ULONGLONG)), 0, 0);
  89    ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
  90    retval = CallNtPowerInformation(LastWakeTime, &atime, sizeof(ULONGLONG), &ctime, sizeof(ULONGLONG));
  91    ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
  92    retval = CallNtPowerInformation(LastWakeTime, 0, 0, &atime, sizeof(ULONGLONG));
  93    ok(retval == STATUS_SUCCESS, "function expected STATUS_SUCCESS but got %d\n",(UINT)retval);
  94
  95    /* ProcessorInformation tests */
  96    retval = CallNtPowerInformation(ProcessorInformation, 0, 0, 0, 0);
  97    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
  98    retval = CallNtPowerInformation(ProcessorInformation, 0, 0, &ppi, sizeof(PROCESSOR_POWER_INFORMATION));
  99    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 100    retval = CallNtPowerInformation(ProcessorInformation, &ppi, sizeof(PROCESSOR_POWER_INFORMATION), 0, 0);
 101    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 102    retval = CallNtPowerInformation(ProcessorInformation, &ppi, sizeof(PROCESSOR_POWER_INFORMATION), &ppi, sizeof(PROCESSOR_POWER_INFORMATION));
 103
 104    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 105    retval = CallNtPowerInformation(ProcessorInformation, 0, 0, &pppi, sizeof(PPROCESSOR_POWER_INFORMATION));
 106    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 107    retval = CallNtPowerInformation(ProcessorInformation, &pppi, sizeof(PPROCESSOR_POWER_INFORMATION), 0, 0);
 108    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 109    retval = CallNtPowerInformation(ProcessorInformation, &pppi, sizeof(PPROCESSOR_POWER_INFORMATION), &pppi, sizeof(PPROCESSOR_POWER_INFORMATION));
 110    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 111
 112    /* ProcessorPowerPolicyAc tests */
 113    retval = CallNtPowerInformation(ProcessorPowerPolicyAc, 0, 0, 0, 0);
 114    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 115    retval = CallNtPowerInformation(ProcessorPowerPolicyAc, 0, 0, &ppp, sizeof(PROCESSOR_POWER_POLICY));
 116    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 117    retval = CallNtPowerInformation(ProcessorPowerPolicyAc, &ppp, sizeof(PROCESSOR_POWER_POLICY), 0, 0);
 118    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 119    retval = CallNtPowerInformation(ProcessorPowerPolicyAc, &ppp, sizeof(PROCESSOR_POWER_POLICY), &ppp, sizeof(PROCESSOR_POWER_POLICY));
 120    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 121
 122    /* ProcessorPowerPolicyCurrent tests */
 123    retval = CallNtPowerInformation(ProcessorPowerPolicyCurrent, 0, 0, 0, 0);
 124    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 125    retval = CallNtPowerInformation(ProcessorPowerPolicyCurrent, 0, 0, &ppp, sizeof(PROCESSOR_POWER_POLICY));
 126    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 127    retval = CallNtPowerInformation(ProcessorPowerPolicyCurrent, &ppp, sizeof(PROCESSOR_POWER_POLICY), 0, 0);
 128    ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
 129    retval = CallNtPowerInformation(ProcessorPowerPolicyCurrent, &ppp, sizeof(PROCESSOR_POWER_POLICY), &ppp, sizeof(PROCESSOR_POWER_POLICY));
 130    ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
 131
 132    /* ProcessorPowerPolicyDc tests */
 133    retval = CallNtPowerInformation(ProcessorPowerPolicyDc, 0, 0, 0, 0);
 134    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 135    retval = CallNtPowerInformation(ProcessorPowerPolicyDc, 0, 0, &ppp, sizeof(PROCESSOR_POWER_POLICY));
 136    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 137    retval = CallNtPowerInformation(ProcessorPowerPolicyDc, &ppp, sizeof(PROCESSOR_POWER_POLICY), 0, 0);
 138    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 139    retval = CallNtPowerInformation(ProcessorPowerPolicyDc, &ppp, sizeof(PROCESSOR_POWER_POLICY), &ppp, sizeof(PROCESSOR_POWER_POLICY));
 140    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 141
 142    /* SystemBatteryState tests */
 143    retval = CallNtPowerInformation(SystemBatteryState, 0, 0, 0, 0);
 144    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 145    retval = CallNtPowerInformation(SystemBatteryState, 0, 0, &sbs, sizeof(SYSTEM_BATTERY_STATE));
 146    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 147    retval = CallNtPowerInformation(SystemBatteryState, &sbs, sizeof(SYSTEM_BATTERY_STATE), 0, 0);
 148    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 149    retval = CallNtPowerInformation(SystemBatteryState, &sbs, sizeof(SYSTEM_BATTERY_STATE), &sbs, sizeof(SYSTEM_BATTERY_STATE));
 150    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 151
 152    /* SystemExecutionState tests */
 153    retval = CallNtPowerInformation(SystemExecutionState, 0, 0, 0, 0);
 154    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 155
 156    /* SystemPowerCapabilities tests */
 157    retval = CallNtPowerInformation(SystemPowerCapabilities, 0, 0, 0, 0);
 158    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 159    retval = CallNtPowerInformation(SystemPowerCapabilities, 0, 0, &spc, sizeof(SYSTEM_POWER_CAPABILITIES));
 160    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 161    retval = CallNtPowerInformation(SystemPowerCapabilities, &spc, sizeof(SYSTEM_POWER_CAPABILITIES), 0, 0);
 162    ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
 163    retval = CallNtPowerInformation(SystemPowerCapabilities, &spc, sizeof(SYSTEM_POWER_CAPABILITIES), &spc, sizeof(SYSTEM_POWER_CAPABILITIES));
 164    ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
 165
 166    /* SystemPowerInformation tests */
 167    retval = CallNtPowerInformation(SystemPowerInformation, 0, 0, 0, 0);
 168    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 169    retval = CallNtPowerInformation(SystemPowerInformation, 0, 0, &spi, sizeof(SYSTEM_POWER_INFORMATION));
 170    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 171    retval = CallNtPowerInformation(SystemPowerInformation, &spi, sizeof(SYSTEM_POWER_INFORMATION), 0, 0);
 172    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 173    retval = CallNtPowerInformation(SystemPowerInformation, &spi, sizeof(SYSTEM_POWER_INFORMATION), &spi, sizeof(SYSTEM_POWER_INFORMATION));
 174    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 175    retval = CallNtPowerInformation(SystemPowerInformation, &spp, sizeof(SYSTEM_POWER_POLICY), 0, 0);
 176    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 177    retval = CallNtPowerInformation(SystemPowerInformation, &spp, sizeof(SYSTEM_POWER_POLICY), &spi, sizeof(SYSTEM_POWER_INFORMATION));
 178    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 179
 180    /* SystemPowerPolicyAc tests */
 181    retval = CallNtPowerInformation(SystemPowerPolicyAc, 0, 0, 0, 0);
 182    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 183    retval = CallNtPowerInformation(SystemPowerPolicyAc, 0, 0, &spp, sizeof(SYSTEM_POWER_POLICY));
 184    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 185    retval = CallNtPowerInformation(SystemPowerPolicyAc, &spp, sizeof(SYSTEM_POWER_POLICY), 0, 0);
 186    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 187    retval = CallNtPowerInformation(SystemPowerPolicyAc, &spp, sizeof(SYSTEM_POWER_POLICY), &spp, sizeof(SYSTEM_POWER_POLICY));
 188    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 189
 190    /* SystemPowerPolicyCurrent tests */
 191    retval = CallNtPowerInformation(SystemPowerPolicyCurrent, 0, 0, 0, 0);
 192    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 193    retval = CallNtPowerInformation(SystemPowerPolicyCurrent, 0, 0, &spp, sizeof(SYSTEM_POWER_POLICY));
 194    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 195    retval = CallNtPowerInformation(SystemPowerPolicyCurrent, &spp, sizeof(SYSTEM_POWER_POLICY), 0, 0);
 196    ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
 197    retval = CallNtPowerInformation(SystemPowerPolicyCurrent, &spp, sizeof(SYSTEM_POWER_POLICY), &spp, sizeof(SYSTEM_POWER_POLICY));
 198    ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
 199
 200    /* SystemPowerPolicyDc tests */
 201    retval = CallNtPowerInformation(SystemPowerPolicyDc, 0, 0, 0, 0);
 202    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 203    retval = CallNtPowerInformation(SystemPowerPolicyDc, 0, 0, &spp, sizeof(SYSTEM_POWER_POLICY));
 204    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 205    retval = CallNtPowerInformation(SystemPowerPolicyDc, &spp, sizeof(SYSTEM_POWER_POLICY), 0, 0);
 206    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 207    retval = CallNtPowerInformation(SystemPowerPolicyDc, &spp, sizeof(SYSTEM_POWER_POLICY), &spp, sizeof(SYSTEM_POWER_POLICY));
 208    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 209
 210    /* SystemReserveHiberFile tests */
 211 /*
 212    retval = CallNtPowerInformation(SystemReserveHiberFile, 0, 0, 0, 0);
 213    ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected STATUS_INVALID_PARAMETER but got %ld\n", retval);
 214    bln=TRUE;
 215    retval = CallNtPowerInformation(SystemReserveHiberFile, &bln, sizeof(bln), 0, 0);
 216    ok(retval == STATUS_DISK_FULL, "function result wrong expected STATUS_DISK_FULL but got %ld\n", nret);
 217    bln=FALSE;
 218    retval = CallNtPowerInformation(SystemReserveHiberFile, &bln, sizeof(bln), 0, 0);
 219    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %ld\n", nret);
 220
 221    bln2=TRUE;
 222    nret = CallNtPowerInformation(SystemReserveHiberFile, 0, 0, &bln2, sizeof(bln2));
 223    ok(nret == STATUS_DATATYPE_MISALIGNMENT, "function result wrong expected STATUS_DATATYPE_MISALIGNMENT but got %ld\n", nret);
 224    bln2=FALSE;
 225    nret = CallNtPowerInformation(SystemReserveHiberFile, 0, 0, &bln2, sizeof(bln2));
 226    ok(nret == STATUS_DATATYPE_MISALIGNMENT, "function result wrong expected STATUS_DATATYPE_MISALIGNMENT but got %ld\n", nret);
 227
 228    bln=TRUE;
 229    bln2=TRUE;
 230    nret = CallNtPowerInformation(SystemReserveHiberFile, &bln, sizeof(bln), &bln2, sizeof(bln2));
 231    ok(nret == STATUS_DATATYPE_MISALIGNMENT, "function result wrong expected STATUS_DATATYPE_MISALIGNMENT but got %ld\n", nret);
 232    bln2=FALSE;
 233    nret = CallNtPowerInformation(SystemReserveHiberFile, &bln, sizeof(bln), &bln2, sizeof(bln2));
 234    ok(nret == STATUS_DATATYPE_MISALIGNMENT, "function result wrong expected STATUS_DATATYPE_MISALIGNMENT but got %ld\n", nret);
 235    bln=FALSE;
 236    bln2=TRUE;
 237    nret = CallNtPowerInformation(SystemReserveHiberFile, &bln, sizeof(bln), &bln2, sizeof(bln2));
 238    ok(nret == STATUS_DATATYPE_MISALIGNMENT, "function result wrong expected STATUS_DATATYPE_MISALIGNMENT but got %ld\n", nret);
 239    bln2=FALSE;
 240    nret = CallNtPowerInformation(SystemReserveHiberFile, &bln, sizeof(bln), &bln2, sizeof(bln2));
 241    ok(nret == STATUS_DATATYPE_MISALIGNMENT, "function result wrong expected STATUS_DATATYPE_MISALIGNMENT but got %ld\n", nret);
 242  */
 243
 244    /* VerifyProcessorPowerPolicyAc tests */
 245    retval = CallNtPowerInformation(VerifyProcessorPowerPolicyAc, 0, 0, 0, 0);
 246    ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
 247    retval = CallNtPowerInformation(VerifyProcessorPowerPolicyAc, 0, 0, &ppp, sizeof(PROCESSOR_POWER_POLICY));
 248    ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
 249    retval = CallNtPowerInformation(VerifyProcessorPowerPolicyAc, &ppp, sizeof(PROCESSOR_POWER_POLICY), 0, 0);
 250    ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
 251    retval = CallNtPowerInformation(VerifyProcessorPowerPolicyAc, &ppp, sizeof(PROCESSOR_POWER_POLICY), &ppp, sizeof(PROCESSOR_POWER_POLICY));
 252    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 253
 254    /* VerifyProcessorPowerPolicyDc tests */
 255    retval = CallNtPowerInformation(VerifyProcessorPowerPolicyDc, 0, 0, 0, 0);
 256    ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
 257    retval = CallNtPowerInformation(VerifyProcessorPowerPolicyDc, 0, 0, &ppp, sizeof(PROCESSOR_POWER_POLICY));
 258    ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
 259    retval = CallNtPowerInformation(VerifyProcessorPowerPolicyDc, &ppp, sizeof(PROCESSOR_POWER_POLICY), 0, 0);
 260    ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
 261    retval = CallNtPowerInformation(VerifyProcessorPowerPolicyDc, &ppp, sizeof(PROCESSOR_POWER_POLICY), &ppp, sizeof(PROCESSOR_POWER_POLICY));
 262    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 263
 264    /* VerifySystemPolicyAc tests */
 265    retval = CallNtPowerInformation(VerifySystemPolicyAc, 0, 0, 0, 0);
 266    ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
 267    retval = CallNtPowerInformation(VerifySystemPolicyAc, 0, 0, &spp, sizeof(SYSTEM_POWER_POLICY));
 268    ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
 269    retval = CallNtPowerInformation(VerifySystemPolicyAc, &spp, sizeof(SYSTEM_POWER_POLICY), 0, 0);
 270    ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
 271    retval = CallNtPowerInformation(VerifySystemPolicyAc, &spp, sizeof(SYSTEM_POWER_POLICY), &spp, sizeof(SYSTEM_POWER_POLICY));
 272    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 273
 274    /* VerifySystemPolicyDc tests */
 275    retval = CallNtPowerInformation(VerifySystemPolicyDc, 0, 0, 0, 0);
 276    ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
 277    retval = CallNtPowerInformation(VerifySystemPolicyDc, 0, 0, &spp, sizeof(SYSTEM_POWER_POLICY));
 278    ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
 279    retval = CallNtPowerInformation(VerifySystemPolicyDc, &spp, sizeof(SYSTEM_POWER_POLICY), 0, 0);
 280    ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
 281    retval = CallNtPowerInformation(VerifySystemPolicyDc, &spp, sizeof(SYSTEM_POWER_POLICY), &spp, sizeof(SYSTEM_POWER_POLICY));
 282    ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but got %d\n", (UINT)retval);
 283
 284    /* SystemPowerStateHandler tests */
 285    retval = CallNtPowerInformation(SystemPowerStateHandler, 0, 0, 0, 0);
 286    ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
 287    retval = CallNtPowerInformation(SystemPowerStateHandler, 0, 0, x, sizeof(HANDLE));
 288    ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
 289
 290    /* ProcessorStateHandler tests */
 291    retval = CallNtPowerInformation(ProcessorStateHandler, 0, 0, 0, 0);
 292    ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
 293    retval = CallNtPowerInformation(ProcessorStateHandler, 0, 0, x, sizeof(HANDLE));
 294    ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
 295
 296    /* ProcessorStateHandler2 tests */
 297    retval = CallNtPowerInformation(ProcessorStateHandler2, 0, 0, 0, 0);
 298    ok(retval == STATUS_ACCESS_DENIED, "function result wrong expected STATUS_ACCESS_DENIED but got %d\n", (UINT)retval);
 299    retval = CallNtPowerInformation(ProcessorStateHandler2, 0, 0, x, sizeof(HANDLE));
 300    ok(retval == STATUS_ACCESS_DENIED, "function result wrong expected STATUS_ACCESS_DENIED but got %d\n", (UINT)retval);
 301
 302    /* SystemPowerStateNotifyHandler tests */
 303    retval = CallNtPowerInformation(SystemPowerStateNotifyHandler, 0, 0, 0, 0);
 304    ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
 305    retval = CallNtPowerInformation(SystemPowerStateNotifyHandler, 0, 0, x, sizeof(HANDLE));
 306    ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
 307
 308 }
 309
 310 /*
 311    @implemented
 312  */
 313 void test_CanUserWritePwrScheme(void)
 314 {
 315    DWORD error, retval;
 316
 317    retval = CanUserWritePwrScheme();
 318
 319    error = GetLastError();
 320
 321    if (retval)
 322       ok(retval, "function failed?");
 323    else
 324       ok(error == ERROR_ACCESS_DENIED, "function last error wrong expected ERROR_ACCESS_DENIED but got %d\n", (UINT)error);
 325
 326 }
 327 BOOLEAN CALLBACK test_callback_EnumPwrScheme(UINT uiIndex, DWORD dwName, LPWSTR sName, DWORD dwDesc,
 328                                              LPWSTR sDesc, PPOWER_POLICY pp,LPARAM lParam )
 329 {
 330    ok(uiIndex == g_NumPwrSchemes, "expected power scheme index of %d but got %d\n", g_NumPwrSchemes, uiIndex);
 331    g_NumPwrSchemes++;
 332
 333    ok(lParam == 0xDEADBEEF, "expected function lParam to be 0xDEADBEEF but got %d\n", (UINT)lParam);
 334
 335    return TRUE;
 336 }
 337
 338 BOOLEAN CALLBACK test_callback_stop_EnumPwrScheme(UINT uiIndex, DWORD dwName, LPWSTR sName, DWORD dwDesc,
 339                                                   LPWSTR sDesc, PPOWER_POLICY pp,LPARAM lParam )
 340 {
 341    ok((!uiIndex || g_NumPwrSchemesEnumerated + 1 == uiIndex), "expected power scheme %d but got %d\n",g_NumPwrSchemesEnumerated+1, uiIndex);
 342    g_NumPwrSchemesEnumerated = uiIndex;
 343
 344    ok(uiIndex <= (UINT)lParam, "enumeration should have already been stopped at index %d current index %d\n", (UINT)lParam, uiIndex);
 345    if (uiIndex == (UINT)lParam)
 346       return FALSE;
 347    else
 348       return TRUE;
 349 }
 350
 351 void test_DeletePwrScheme(void)
 352 {
 353    DWORD retval;
 354    HKEY hSubKey = NULL;
 355
 356
 357    /*
 358     *  try inexistant profile number, should fail
 359     */
 360
 361    retval = DeletePwrScheme(0xFFFFFFFF);
 362    ok(!retval, "function should have failed error %x\n",(UINT)GetLastError());
 363
 364    /*
 365     *  delete active power scheme, should fail
 366     */
 367
 368    retval = GetActivePwrScheme(&g_ActivePwrScheme);
 369    ok(retval, "function was expected to succeed, error %x\n",(UINT)GetLastError());
 370
 371    retval = DeletePwrScheme(g_ActivePwrScheme);
 372    ok(!retval, "function should have failed\n");
 373    ok(GetLastError() == ERROR_ACCESS_DENIED, "function should have failed with ERROR_ACCESS_DENIED but got %x\n", (UINT)GetLastError());
 374
 375    /*
 376     * delete a temporarly created power scheme
 377     */
 378    retval = DeletePwrScheme(g_TempPwrScheme);
 379    ok(retval, "function should have succeeded\n");
 380
 381 /*
 382  *      clean up, delete illegal entry, witch was created for this test
 383  */
 384
 385    if (RegOpenKeyW(HKEY_LOCAL_MACHINE, szMachPowerPoliciesSubKey, &hSubKey) == ERROR_SUCCESS)
 386    {
 387       if (RegDeleteKeyW(hSubKey, szTempPwrScheme) != STATUS_SUCCESS)
 388          printf("failed to delete subkey %i (testentry)\n", g_TempPwrScheme);
 389       RegCloseKey(hSubKey);
 390    }
 391
 392 }
 393
 394 void test_EnumPwrSchemes(void)
 395 {
 396    BOOLEAN retval;
 397
 398    /*
 399     * test EnumPwrScheme with null pointer callback
 400     */
 401
 402    retval = EnumPwrSchemes(0, 0);
 403    ok(!retval, "function was expected to fail\n");
 404    ok(GetLastError() == ERROR_INVALID_PARAMETER, "expected ERROR_INVALID_PARAMETER but got %x\n",(UINT)GetLastError());
 405
 406    /*
 407     * enumerate power schemes, should succeed
 408     */
 409
 410    retval = EnumPwrSchemes(test_callback_EnumPwrScheme, 0xDEADBEEF);
 411    ok(retval, "function was expected to succeed %d\n",retval);
 412    ok(g_NumPwrSchemes, "Warning: no power schemes available\n");
 413
 414    /*
 415     * stop enumeration after first power scheme
 416     */
 417
 418    retval = EnumPwrSchemes(test_callback_stop_EnumPwrScheme, (LPARAM)0);
 419    ok(!retval, "function was expected to false\n");
 420
 421    /*
 422     *  enumerate half of all avalailble profiles
 423     */
 424
 425    g_NumPwrSchemesEnumerated = 0;
 426    retval = EnumPwrSchemes(test_callback_stop_EnumPwrScheme, (LPARAM)g_NumPwrSchemes / 2);
 427    ok(retval, "function was expected to succeed but got %i\n", (UINT)retval);
 428    ok(g_NumPwrSchemesEnumerated == g_NumPwrSchemes / 2, "function did not enumerate requested num of profiles %d enumerated %d\n", g_NumPwrSchemes / 2, g_NumPwrSchemesEnumerated);
 429
 430
 431 }
 432
 433 void test_GetSetActivePwrScheme(void)
 434 {
 435    DWORD retval;
 436    UINT current_scheme = 2;
 437    UINT temp_scheme = 0;
 438
 439    /*
 440     * read active power scheme
 441     */
 442
 443    retval = GetActivePwrScheme(&g_ActivePwrScheme);
 444
 445    ok(retval, "function was expected to succeed, error %x\n",(UINT)GetLastError());
 446    ok(retval <= g_NumPwrSchemes, "expected index lower as power scheme count %d but got %d\n", g_NumPwrSchemes, g_ActivePwrScheme);
 447
 448    /*
 449     *  sets active power scheme to inexistant profile
 450     * -> corrupts power scheme enumeration on Windows XP SP2
 451     */
 452    //corrupts registry
 453    //retval = SetActivePwrScheme(0xFFFFFFFF, 0, 0);
 454    //ok(!retval, "function was expected to fail");
 455    //current_scheme = min(active_scheme+1, g_NumPwrSchemes-1);
 456
 457    /*
 458     * sets the active power scheme to profile with index 0
 459     */
 460
 461    retval = SetActivePwrScheme(current_scheme, 0, 0);
 462    ok(retval, "function was expected to succeed, error %x\n",(UINT)GetLastError());
 463
 464    /*
 465     *  read back the active power scheme
 466     */
 467
 468    retval = GetActivePwrScheme(&temp_scheme);
 469    ok(retval, "function was expected to succeed, error %x\n",(UINT)GetLastError());
 470    ok(temp_scheme == current_scheme, "expected %d but got %d\n", (UINT)current_scheme, (UINT)temp_scheme);
 471
 472    /*
 473     * restore previous active power scheme
 474     */
 475
 476    retval = SetActivePwrScheme(g_ActivePwrScheme, 0, 0);
 477    ok(retval, "Warning: failed to restore old active power scheme %d\n", (UINT)g_ActivePwrScheme);
 478 }
 479
 480 void test_GetCurrentPowerPolicies(void)
 481 {
 482    GLOBAL_POWER_POLICY gpp;
 483    POWER_POLICY pp;
 484    BOOLEAN ret;
 485    UINT current_scheme = 2;
 486
 487    g_ActivePwrScheme=3;
 488    ret = GetActivePwrScheme(&g_ActivePwrScheme);
 489
 490    ok(ret, "function was expected to succeed, error %x\n",(UINT)GetLastError());
 491    ret = SetActivePwrScheme(0, &gpp, 0);
 492
 493    ok(!ret, "function was expected to fail, error %x\n",(UINT)GetLastError());
 494
 495    ret = SetActivePwrScheme(0, 0, &pp);
 496    ok(!ret, "function was expected to fail, error %x\n",(UINT)GetLastError());
 497
 498    ret = SetActivePwrScheme(0, &gpp, &pp);
 499    ok(!ret, "function was expected to fail, error %x\n",(UINT)GetLastError());
 500
 501    ret = SetActivePwrScheme(current_scheme, &gpp, 0);
 502    ok(!ret, "function was expected to fail, error %x\n",(UINT)GetLastError());
 503
 504    ret = SetActivePwrScheme(current_scheme, 0, &pp);
 505    ok(!ret, "function was expected to fail, error %x\n",(UINT)GetLastError());
 506
 507    ret = SetActivePwrScheme(current_scheme, &gpp, &pp);
 508    ok(!ret, "function was expected to fail, error %x\n",(UINT)GetLastError());
 509
 510    ret = SetActivePwrScheme(g_ActivePwrScheme, 0, 0);
 511    ok(ret, "Warning: failed to restore old active power scheme %d\n", (UINT)g_ActivePwrScheme);
 512
 513    ret = GetCurrentPowerPolicies(0,0);
 514    ok(ret, "function was expected to succeed, error %x\n",(UINT)GetLastError());
 515
 516    ret = GetCurrentPowerPolicies(&gpp,0);
 517    ok(ret, "function was expected to succeed, error %x\n",(UINT)GetLastError());
 518
 519    ret = GetCurrentPowerPolicies(0,&pp);
 520    ok(ret, "function was expected to succeed, error %x\n",(UINT)GetLastError());
 521
 522    ret = GetCurrentPowerPolicies(&gpp,&pp);
 523    ok(ret, "function was expected to succeed, error %x\n",(UINT)GetLastError());
 524    ok(gpp.mach.Revision  == 1,"Global Mach Revision was expected to be 1 got %i",(UINT)gpp.mach.Revision);
 525    ok(gpp.user.Revision  == 1,"Global User Revision was expected to be 1 got %i",(UINT)gpp.mach.Revision);
 526    ok(pp.mach.Revision  == 1,"Mach Revision was expected to be 1 got %i",(UINT)gpp.mach.Revision);
 527    ok(pp.user.Revision  == 1,"User Revision was expected to be 1 got %i",(UINT)gpp.mach.Revision);
 528
 529
 530    ret = GetActivePwrScheme(&g_ActivePwrScheme);
 531    ok(ret, "function was expected to succeed, error %x\n",(UINT)GetLastError());
 532
 533    ret = SetActivePwrScheme(0, &gpp, 0);
 534    ok(ret, "function was expected to succeed, error %x\n",(UINT)GetLastError());
 535
 536    ret = SetActivePwrScheme(0, 0, &pp);
 537    ok(ret, "function was expected to succeed, error %x\n",(UINT)GetLastError());
 538
 539    ret = SetActivePwrScheme(0, &gpp, &pp);
 540    ok(ret, "function was expected to succeed, error %x\n",(UINT)GetLastError());
 541
 542    ret = SetActivePwrScheme(current_scheme, &gpp, 0);
 543    ok(ret, "function was expected to succeed, error %x\n",(UINT)GetLastError());
 544
 545    ret = SetActivePwrScheme(current_scheme, 0, &pp);
 546    ok(ret, "function was expected to succeed, error %x\n",(UINT)GetLastError());
 547
 548    ret = SetActivePwrScheme(current_scheme, &gpp, &pp);
 549    ok(ret, "function was expected to succeed, error %x\n",(UINT)GetLastError());
 550
 551    ret = SetActivePwrScheme(g_ActivePwrScheme, 0, 0);
 552    ok(ret, "Warning: failed to restore old active power scheme %d\n", (UINT)g_ActivePwrScheme);
 553
 554 }
 555
 556 void test_GetPwrCapabilities(void)
 557 {
 558    SYSTEM_POWER_CAPABILITIES spc;
 559    BOOLEAN ret;
 560
 561    ret = GetPwrCapabilities(0);
 562    ok(!ret, "function was expected to fail\n");
 563    if (!ret)
 564    {
 565       ok(GetLastError() == ERROR_INVALID_PARAMETER,"function was expectet to return ERROR_INVALID_PARAMETER, but returns: %x\n",(UINT)GetLastError());
 566    }
 567    ret = GetPwrCapabilities(&spc);
 568    ok(ret, "function was expected to succeed, error %x\n",(UINT)GetLastError());
 569 }
 570
 571 void test_GetPwrDiskSpindownRange(void)
 572 {
 573    DWORD retval;
 574    UINT min = 0;
 575    UINT max = 0;
 576
 577    /*
 578     *  invalid parameter checks
 579     */
 580
 581    retval = GetPwrDiskSpindownRange(NULL, NULL);
 582    ok(!retval, "function was expected to fail\n");
 583    ok(GetLastError() == ERROR_INVALID_PARAMETER, "expected error ERROR_INVALID_PARAMETER but got %x\n", (UINT)GetLastError());
 584
 585    retval = GetPwrDiskSpindownRange(&max, NULL);
 586    ok(!retval, "function was expected to fail\n");
 587    ok(GetLastError() == ERROR_INVALID_PARAMETER, "expected error ERROR_INVALID_PARAMETER but got %x\n", (UINT)GetLastError());
 588
 589    retval = GetPwrDiskSpindownRange(NULL, &min);
 590    ok(!retval, "function was expected to fail\n");
 591    ok(GetLastError() == ERROR_INVALID_PARAMETER, "expected error ERROR_INVALID_PARAMETER but got %x\n", (UINT)GetLastError());
 592
 593    /*
 594     * read disk spindown range
 595     */
 596
 597    retval = GetPwrDiskSpindownRange(&max, &min);
 598    ok(retval, "function was expected to succeed error %x\n",(UINT)GetLastError());
 599    ok(min <= max, "range mismatch min %d max %d\n",min, max);
 600 }
 601
 602 void test_IsAdminOverrideActive(void)
 603 {
 604    ADMINISTRATOR_POWER_POLICY app;
 605    BOOLEAN ret;
 606
 607    ret = IsAdminOverrideActive(0);
 608    ok(!ret, "function was expected to fail, error %x\n",(UINT)GetLastError());
 609
 610    ret = IsAdminOverrideActive(&app);
 611    ok(!ret, "function was expected to fail, error %x\n",(UINT)GetLastError());
 612
 613    app.MinSleep = 0;
 614    app.MaxSleep = 0;
 615    app.MinVideoTimeout = 0;
 616    app.MaxVideoTimeout = 0;
 617    app.MinSpindownTimeout = 0;
 618    app.MaxSpindownTimeout = 0;
 619
 620    ret = IsAdminOverrideActive(&app);
 621    ok(!ret, "function was expected to fail, error %x\n",(UINT)GetLastError());
 622
 623    app.MinSleep = 1;
 624    app.MaxSleep = 2;
 625    app.MinVideoTimeout = 3;
 626    app.MaxVideoTimeout = 4;
 627    app.MinSpindownTimeout = 5;
 628    app.MaxSpindownTimeout = 6;
 629
 630    ret = IsAdminOverrideActive(&app);
 631    ok(!ret, "function was expected to fail, error %x\n",(UINT)GetLastError());
 632
 633 }
 634
 635 void test_IsPwrHibernateAllowed(void)
 636 {
 637 /*
 638         BOOLEAN ret;
 639
 640         ret = IsPwrHibernateAllowed();
 641         ok(!ret, "function was expected to fail, error %x\n",(UINT)GetLastError());
 642  */
 643 }
 644
 645 void test_IsPwrShutdownAllowed(void)
 646 {
 647 /*
 648         BOOLEAN ret;
 649
 650         ret = IsPwrShutdownAllowed();
 651         ok(ret, "function was expected to succeed, error %x\n",(UINT)GetLastError());
 652  */
 653 }
 654
 655 void test_IsPwrSuspendAllowed(void)
 656 {
 657 /*
 658         BOOLEAN ret;
 659
 660         ret = IsPwrSuspendAllowed();
 661         ok(ret, "function was expected to succed, error %x\n",(UINT)GetLastError());
 662  */
 663 }
 664
 665 void test_ReadGlobalPwrPolicy(void)
 666 {
 667    GLOBAL_POWER_POLICY gpp;
 668    BOOLEAN ret;
 669
 670    ret = ReadGlobalPwrPolicy(&gpp);
 671    ok(ret, "function was expected to succeed, error %x\n",(UINT)GetLastError());
 672    ok(gpp.mach.Revision  == 1,"Global Mach Revision was expected to be 1 got %i",(UINT)gpp.mach.Revision);
 673    ok(gpp.user.Revision  == 1,"Global User Revision was expected to be 1 got %i",(UINT)gpp.mach.Revision);
 674
 675
 676
 677 }
 678
 679 void test_ReadProcessorPwrScheme(void)
 680 {
 681    MACHINE_PROCESSOR_POWER_POLICY mppp;
 682    BOOLEAN ret;
 683    UINT i = 0;
 684    DWORD err;
 685
 686    do
 687    {
 688       RtlZeroMemory(&mppp, sizeof(MACHINE_PROCESSOR_POWER_POLICY));
 689       ret = ReadProcessorPwrScheme(i,&mppp);
 690       if (ret)
 691       {
 692          ok(mppp.Revision == 1,"Main Revision was expected to be 1 got %i",(UINT)mppp.Revision);
 693          ok(mppp.ProcessorPolicyAc.Revision == 1,"PowerAC Revision was expected to be 1 got %i",(UINT)mppp.ProcessorPolicyAc.Revision);
 694          ok(mppp.ProcessorPolicyDc.Revision == 1,"PowerDC Revision was expected to be 1 got %i",(UINT)mppp.ProcessorPolicyDc.Revision);
 695       }
 696       else
 697       {
 698          err = GetLastError();
 699          ok(err == 0,"Failed Error %x\n",(UINT)err);
 700          return;
 701       }
 702       i++;
 703       if (i == g_NumPwrSchemes)
 704          return;
 705    } while (TRUE);
 706
 707 }
 708
 709 void test_ReadPwrScheme(void)
 710 {
 711    DWORD retval;
 712
 713    /*
 714     * read power scheme with null pointer -> crashs on Windows XP SP2
 715     */
 716    //retval = ReadPwrScheme(0, NULL);
 717    //ok(!retval, "function was expected to fail\n");
 718    //ok(GetLastError() == STATUS_INVALID_PARAMETER, "expected error ... but got %x\n", GetLastError());
 719
 720    /*
 721     *  read a power scheme with an invalid index, leads to the creation of the key
 722     *  -> corrupts power scheme enumeration
 723     */
 724    //retval = ReadPwrScheme(0xFFFFFFFF, &powerPolicy);
 725    //ok(!retval, "function was expected to fail\n");
 726    //ok(GetLastError() == ERROR_ACCESS_DENIED, "expected error ERROR_ACCESS_DENIED but got %x\n", GetLastError());
 727
 728    /*
 729     * read current active power scheme
 730     */
 731
 732    retval = ReadPwrScheme(g_ActivePwrScheme, &g_PowerPolicy);
 733    ok(retval, "function was expected to succeed error %x\n",(UINT)GetLastError());
 734
 735 }
 736
 737 void test_SetSuspendState(void)
 738 {
 739 //      SetSuspendState(FALSE,FALSE,FALSE)
 740 }
 741
 742 void test_ValidatePowerPolicies(void)
 743 {
 744    GLOBAL_POWER_POLICY gpp;
 745    POWER_POLICY pp;
 746    BOOLEAN ret;
 747
 748    SetLastError(0);
 749    ret = ValidatePowerPolicies(0,0);
 750    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
 751
 752    ret = ValidatePowerPolicies(&gpp,0);
 753    ok(!ret, "function was expected to fail return %i\n",(UINT)ret);
 754    ok(GetLastError() == ERROR_REVISION_MISMATCH,"function was expected to fail with ERROR_REVISION_MISMATCH(%i,%i), but error :%i\n",(UINT)gpp.user.Revision,(UINT)gpp.mach.Revision,(UINT)GetLastError());
 755
 756    ret = ValidatePowerPolicies(0,&pp);
 757    ok(!ret, "function was expected to fail return %i\n",(UINT)ret);
 758    ok(GetLastError() == ERROR_REVISION_MISMATCH,"function was expected to fail with ERROR_REVISION_MISMATCH, but error :%i\n",(UINT)GetLastError());
 759
 760    ret = ValidatePowerPolicies(&gpp,&pp);
 761    ok(!ret, "function was expected to fail return %i\n",(UINT)ret);
 762    ok(GetLastError() == ERROR_REVISION_MISMATCH,"function was expected to fail with ERROR_REVISION_MISMATCH, but error :%i\n",(UINT)GetLastError());
 763
 764    gpp.user.Revision = 1;
 765    gpp.mach.Revision = 1;
 766
 767    ret = ValidatePowerPolicies(&gpp,0);
 768    ok(!ret, "function was expected to fail return %i\n",(UINT)ret);
 769    ok(GetLastError() == ERROR_INVALID_DATA,"function was expected to fail with ERROR_INVALID_DATA, but error :%i\n",(UINT)GetLastError());
 770
 771    gpp.mach.LidOpenWakeAc = PowerSystemWorking;
 772    gpp.mach.LidOpenWakeDc = PowerSystemWorking;
 773
 774    ret = ValidatePowerPolicies(&gpp,0);
 775    ok(!ret, "function was expected to fail return %i\n",(UINT)ret);
 776    ok(GetLastError() == ERROR_INVALID_DATA,"function was expected to fail with ERROR_INVALID_DATA, but error :%i\n",(UINT)GetLastError());
 777
 778    gpp.user.PowerButtonAc.Action = PowerActionNone;
 779    gpp.user.PowerButtonDc.Action = PowerActionNone;
 780    gpp.user.SleepButtonAc.Action = PowerActionNone;
 781    gpp.user.SleepButtonDc.Action = PowerActionNone;
 782    gpp.user.LidCloseAc.Action = PowerActionNone;
 783    gpp.user.LidCloseDc.Action = PowerActionNone;
 784
 785    gpp.user.DischargePolicy[0].Enable=FALSE;
 786    gpp.user.DischargePolicy[1].Enable=FALSE;
 787    gpp.user.DischargePolicy[2].Enable=FALSE;
 788    gpp.user.DischargePolicy[3].Enable=FALSE;
 789    gpp.user.DischargePolicy[4].Enable=FALSE;
 790    ret = ValidatePowerPolicies(&gpp,0);
 791    ok(ret, "function was expected to succeed return %i\n",(UINT)GetLastError());
 792    if (!ret)
 793    {
 794       ok(GetLastError() == ERROR_INVALID_DATA,"function was expected to fail with ERROR_INVALID_DATA, but error :%i\n",(UINT)GetLastError());
 795    }
 796
 797    pp.user.Revision = 1;
 798    pp.mach.Revision = 1;
 799
 800    ret = ValidatePowerPolicies(0,&pp);
 801    ok(!ret, "function was expected to fail return %i\n",(UINT)ret);
 802    ok(GetLastError() == ERROR_INVALID_DATA || GetLastError() == ERROR_GEN_FAILURE,"function was expected to fail with ERROR_GEN_FAILURE or ERROR_INVALID_DATA, but error :%i\n",(UINT)GetLastError());
 803
 804    pp.mach.MinSleepAc = PowerSystemWorking;
 805    pp.mach.MinSleepDc = PowerSystemWorking;
 806    pp.mach.ReducedLatencySleepAc = PowerSystemWorking;
 807    pp.mach.ReducedLatencySleepDc = PowerSystemWorking;
 808    pp.mach.OverThrottledAc.Action = PowerActionNone;
 809    pp.mach.OverThrottledDc.Action = PowerActionNone;
 810
 811    pp.user.IdleAc.Action = PowerActionWarmEject+1;
 812    pp.user.IdleDc.Action = PowerActionNone-1;
 813    pp.user.MaxSleepAc = PowerSystemMaximum+1;
 814    pp.user.MaxSleepDc = PowerSystemUnspecified;
 815
 816    ret = ValidatePowerPolicies(0,&pp);
 817    ok(!ret, "function was expected to fail return %i\n",(UINT)GetLastError());
 818    if (!ret)
 819    {
 820       ok(GetLastError() == ERROR_INVALID_DATA,"function was expected to fail with ERROR_INVALID_DATA, but error :%i\n",(UINT)GetLastError());
 821    }
 822
 823    pp.user.IdleAc.Action = PowerActionNone;
 824    pp.user.IdleDc.Action = PowerActionNone;
 825    pp.user.MaxSleepAc = PowerSystemWorking;
 826    pp.user.MaxSleepDc = PowerSystemWorking;
 827
 828    ret = ValidatePowerPolicies(0,&pp);
 829    ok(ret, "function was expected to succeed, error %i\n",(UINT)GetLastError());
 830    if (!ret)
 831    {
 832       ok(GetLastError() == ERROR_GEN_FAILURE,"function was expected to fail with ERROR_GEN_FAILURE, but error :%i\n",(UINT)GetLastError());
 833    }
 834
 835    ret = ValidatePowerPolicies(&gpp,&pp);
 836    ok(ret, "function was expected to succeed, error %i\n",(UINT)GetLastError());
 837    if (!ret)
 838    {
 839 //              ok(GetLastError() == ERROR_GEN_FAILURE,"function was expected to fail with ERROR_GEN_FAILURE, but error :%i\n",(UINT)GetLastError());
 840    }
 841
 842
 843    ret = GetCurrentPowerPolicies(&gpp,&pp);
 844    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
 845
 846    ret = ValidatePowerPolicies(&gpp,0);
 847    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
 848
 849    ret = ValidatePowerPolicies(0,&pp);
 850    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
 851
 852    ret = ValidatePowerPolicies(&gpp,&pp);
 853    ok(ret, "function was expected to succeed error %i\n",(UINT)GetLastError());
 854
 855 }
 856
 857 void test_WriteGlobalPwrPolicy(void)
 858 {
 859 //      WriteGlobalPwrPolicy(&gpp);
 860 }
 861
 862 void test_WriteProcessorPwrScheme(void)
 863 {
 864 //      WriteProcessorPwrScheme(0,&mppp);
 865 }
 866
 867 void test_WritePwrScheme(void)
 868 {
 869    DWORD retval;
 870    static const WCHAR szTestSchemeName[] = {'P','o','w','r','p','r','o','f',0};
 871    static const WCHAR szTestSchemeDesc[] = {'P','o','w','r','p','r','o','f',' ','S','c','h','e','m','e',0};
 872
 873    /*
 874     * create a temporarly profile, will be deleted in test_DeletePwrScheme
 875     */
 876
 877    retval = WritePwrScheme(&g_TempPwrScheme, (LPWSTR)szTestSchemeName, (LPWSTR)szTestSchemeDesc, &g_PowerPolicy);
 878    ok(retval, "Warning: function should have succeeded\n");
 879 }
 880
 881 void func_power(void)
 882 {
 883    test_CallNtPowerInformation();
 884    test_CanUserWritePwrScheme();
 885    test_EnumPwrSchemes();
 886    test_GetSetActivePwrScheme();
 887    test_ReadPwrScheme();
 888    test_WritePwrScheme();
 889    test_DeletePwrScheme();
 890    test_GetPwrDiskSpindownRange();
 891
 892    test_GetCurrentPowerPolicies();
 893
 894    test_GetPwrCapabilities();
 895    test_IsAdminOverrideActive();
 896    test_IsPwrHibernateAllowed();
 897    test_IsPwrShutdownAllowed();
 898    test_IsPwrSuspendAllowed();
 899    test_ReadGlobalPwrPolicy();
 900    test_ReadProcessorPwrScheme();
 901    test_SetSuspendState();
 902    test_ValidatePowerPolicies();
 903    test_WriteGlobalPwrPolicy();
 904    test_WriteProcessorPwrScheme();
 905
 906 }
 907
 908 void func_ros_init(void)
 909 {
 910    HKEY hUser, hKeyPowrCfg, hKeyGlobalPowrPol, hKeyPowerPolicies, hKeytmp;
 911    DWORD err;
 912    GLOBAL_USER_POWER_POLICY gupp;
 913    GLOBAL_MACHINE_POWER_POLICY gmpp;
 914    USER_POWER_POLICY upp;
 915    MACHINE_POWER_POLICY mpp;
 916    MACHINE_PROCESSOR_POWER_POLICY mppp;
 917    GLOBAL_POWER_POLICY gpp;
 918    POWER_POLICY pp;
 919
 920    int i;
 921
 922    static const WCHAR szUserPowrCfgKey[] = { 'C', 'o', 'n', 't', 'r', 'o', 'l', ' ',
 923                                              'P', 'a', 'n', 'e', 'l', '\\', 'P', 'o', 'w', 'e', 'r', 'C', 'f', 'g', 0};
 924
 925    static const WCHAR szCurrentPowerPolicy[] = {'C', 'u', 'r', 'r', 'e', 'n', 't', 'P',
 926                                                 'o', 'w', 'e', 'r', 'P', 'o', 'l', 'i', 'c', 'y', 0};
 927    static const WCHAR szcpp[] = {'3', 0 };
 928
 929    static const WCHAR szGlobalPowerPolicy[] = { 'G', 'l', 'o', 'b', 'a', 'l', 'P', 'o',
 930                                                 'w', 'e', 'r', 'P', 'o', 'l', 'i', 'c', 'y', 0};
 931    static const WCHAR szPolicies[] = {'P', 'o', 'l', 'i', 'c', 'i', 'e', 's', 0};
 932    static const WCHAR szPowerPolicies[] = { 'P', 'o', 'w', 'e', 'r', 'P', 'o', 'l', 'i',
 933                                             'c', 'i', 'e', 's', 0};
 934
 935    static const WCHAR szProcessorPolicies[] = { 'P', 'r', 'o', 'c', 'e', 's', 's', 'o', 'r',
 936                                                 'P', 'o', 'l', 'i', 'c', 'i', 'e', 's', 0};
 937
 938    static const WCHAR szcName[] = {'N', 'a', 'm', 'e', 0};
 939    static const WCHAR szcDescription[] = {'D', 'e', 's', 'c', 'r', 'i', 'p', 't', 'i', 'o', 'n', 0};
 940
 941    static WCHAR szName[] = {'N', 'a', 'm', 'e', '(', '0', ')', 0};
 942    static WCHAR szDescription[] = {'D', 'e', 's', 'c', 'r', 'i', 'p', 't', 'i', 'o', 'n', '(', '0', ')', 0};
 943
 944    static const WCHAR szMachPowrCfgKey[] = {'S', 'O', 'F', 'T', 'W', 'A', 'R', 'E', '\\', 'M', 'i',
 945                                             'c', 'r', 'o', 's', 'o', 'f', 't', '\\', 'W', 'i', 'n', 'd', 'o', 'w', 's', '\\', 'C', 'u',
 946                                             'r', 'r', 'e', 'n', 't', 'V', 'e', 'r', 's', 'i', 'o', 'n', '\\', 'C', 'o', 'n', 't', 'r',
 947                                             'o', 'l', 's', ' ', 'F', 'o', 'l', 'd', 'e', 'r', '\\', 'P', 'o', 'w', 'e', 'r', 'C', 'f', 'g', 0};
 948
 949    static const WCHAR szLastID[] = {'L', 'a', 's', 't', 'I', 'D', 0};
 950    static const WCHAR szDiskSpinDownMax[] = {'D', 'i', 's', 'k', 'S', 'p', 'i', 'n', 'D', 'o', 'w', 'n', 'M', 'a', 'x', 0};
 951    static const WCHAR szDiskSpinDownMin[] = {'D', 'i', 's', 'k', 'S', 'p', 'i', 'n', 'D', 'o', 'w', 'n', 'M', 'i', 'n', 0};
 952
 953    static const WCHAR szLastIDValue[] = {'5', 0};
 954    static const WCHAR szDiskSpinDownMaxValue[] = {'3', '6', '0', '0', 0};
 955    static const WCHAR szDiskSpinDownMinValue[] = {'3', 0};
 956
 957    WCHAR tmp[20];
 958    /*
 959     * Erstelle die Registry-struktur und Daten, welche dafür erforderlich ist damit diese Tests funktionieren
 960     */
 961
 962    /*
 963     * User
 964     */
 965    err = RegOpenCurrentUser(KEY_ALL_ACCESS,&hUser);
 966    ok(err == ERROR_SUCCESS,"Öffnen des Aktuellen Users Fehlgeschlagen\n");
 967    if (err == ERROR_SUCCESS)
 968    {
 969       err = RegCreateKey(hUser,szUserPowrCfgKey,&hKeyPowrCfg);
 970       ok(err == ERROR_SUCCESS,"Create Key UserPowrCfg failed with error %i\n",(UINT)err);
 971       ok(hKeyPowrCfg != NULL,"Erstellen des Eintrages Powercfg fehlgeschalgen\n");
 972       err = RegSetValueExW(hKeyPowrCfg,szCurrentPowerPolicy,(DWORD)NULL,REG_SZ,(CONST BYTE *)szcpp,strlenW(szcpp)*sizeof(WCHAR));
 973       ok(err == ERROR_SUCCESS,"Set Value CurrentPowerPolicy failed with error %i\n",(UINT)err);
 974       err = RegCreateKey(hKeyPowrCfg,szGlobalPowerPolicy,&hKeyGlobalPowrPol);
 975       ok(err == ERROR_SUCCESS,"Create Key GlobalPowerPolicy failed with error %i\n",(UINT)err);
 976       gupp.Revision = 1;
 977       gupp.PowerButtonAc.Action = PowerActionNone;
 978       gupp.PowerButtonDc.Action = PowerActionNone;
 979       gupp.SleepButtonAc.Action = PowerActionNone;
 980       gupp.SleepButtonDc.Action = PowerActionNone;
 981       gupp.LidCloseAc.Action = PowerActionNone;
 982       gupp.LidCloseDc.Action = PowerActionNone;
 983       for (i=0; i<NUM_DISCHARGE_POLICIES; i++)
 984       {
 985          gupp.DischargePolicy[0].Enable=FALSE;
 986       }
 987
 988       err = RegSetValueExW(hKeyGlobalPowrPol,szPolicies,(DWORD)NULL,REG_BINARY,(CONST BYTE *)&gupp,sizeof(GLOBAL_USER_POWER_POLICY));
 989       ok(err == ERROR_SUCCESS,"Set Value GlobalPowrPol failed with error %i\n",(UINT)err);
 990       err = RegCloseKey(hKeyGlobalPowrPol);
 991       ok(err == ERROR_SUCCESS,"Close Key GlobalPowrPol failed with error %i\n",(UINT)err);
 992       err = RegCreateKey(hKeyPowrCfg,szPowerPolicies,&hKeyPowerPolicies);
 993       ok(err == ERROR_SUCCESS,"Create Key PowerPolicies failed with error %i\n",(UINT)err);
 994
 995       upp.Revision = 1;
 996       upp.IdleAc.Action = PowerActionNone;
 997       upp.IdleDc.Action = PowerActionNone;
 998       upp.MaxSleepAc = PowerSystemWorking;
 999       upp.MaxSleepDc = PowerSystemWorking;
1000       upp.VideoTimeoutAc = 0;
1001       upp.VideoTimeoutDc = 0;
1002       upp.SpindownTimeoutAc = 0;
1003       upp.SpindownTimeoutDc = 0;
1004
1005       for (i = 0; i<6; i++)
1006       {
1007          _itow(i,tmp,10);
1008          err = RegCreateKey(hKeyPowerPolicies,tmp,&hKeytmp);
1009          ok(err == ERROR_SUCCESS,"Create Key PowerPolicies(%i) failed with error %i\n",i,(UINT)err);
1010          szName[5]++;
1011          szDescription[12]++;
1012          err = RegSetValueExW(hKeytmp,szcName,(DWORD)NULL,REG_SZ,(CONST BYTE *)szName,strlenW(szName)*sizeof(WCHAR));
1013          err = RegSetValueExW(hKeytmp,szcDescription,(DWORD)NULL,REG_SZ,(CONST BYTE *)szDescription,strlenW(szDescription)*sizeof(WCHAR));
1014          err = RegSetValueExW(hKeytmp,szPolicies,(DWORD)NULL,REG_BINARY,(CONST BYTE *)&upp,sizeof(USER_POWER_POLICY));
1015          err = RegCloseKey(hKeytmp);
1016       }
1017       err = RegCloseKey(hKeyPowerPolicies);
1018       err = RegCloseKey(hKeyPowrCfg);
1019       err = RegCloseKey(hUser);
1020    }
1021
1022    /*
1023     * Mach
1024     */
1025    err = RegCreateKey(HKEY_LOCAL_MACHINE,szMachPowrCfgKey,&hKeyPowrCfg);
1026    ok(err == ERROR_SUCCESS,"Create Key MachPowrCfgKey failed with error %i\n",(UINT)err);
1027    err = RegSetValueExW(hKeyPowrCfg,szLastID,(DWORD)NULL,REG_SZ,(CONST BYTE *)szLastIDValue,strlenW(szLastIDValue)*sizeof(WCHAR));
1028    err = RegSetValueExW(hKeyPowrCfg,szDiskSpinDownMax,(DWORD)NULL,REG_SZ,(CONST BYTE *)szDiskSpinDownMaxValue,strlenW(szDiskSpinDownMaxValue)*sizeof(WCHAR));
1029    err = RegSetValueExW(hKeyPowrCfg,szDiskSpinDownMin,(DWORD)NULL,REG_SZ,(CONST BYTE *)szDiskSpinDownMinValue,strlenW(szDiskSpinDownMinValue)*sizeof(WCHAR));
1030
1031    err = RegCreateKey(hKeyPowrCfg,szGlobalPowerPolicy,&hKeyGlobalPowrPol);
1032    ok(err == ERROR_SUCCESS,"Create Key Mach GlobalPowerPolicy failed with error %i\n",(UINT)err);
1033    gmpp.Revision = 1;
1034    gmpp.LidOpenWakeAc = PowerSystemWorking;
1035    gmpp.LidOpenWakeDc = PowerSystemWorking;
1036    gmpp.BroadcastCapacityResolution=0;
1037
1038    err = RegSetValueExW(hKeyGlobalPowrPol,szPolicies,(DWORD)NULL,REG_BINARY,(CONST BYTE *)&gmpp,sizeof(GLOBAL_MACHINE_POWER_POLICY));
1039
1040    err = RegCloseKey(hKeyGlobalPowrPol);
1041    err = RegCreateKey(hKeyPowrCfg,szPowerPolicies,&hKeyPowerPolicies);
1042    ok(err == ERROR_SUCCESS,"Create Key Mach PowerPolicies failed with error %i\n",(UINT)err);
1043
1044    mpp.Revision = 1;
1045    mpp.MinSleepAc = PowerSystemWorking;
1046    mpp.MinSleepDc = PowerSystemWorking;
1047    mpp.ReducedLatencySleepAc = PowerSystemWorking;
1048    mpp.ReducedLatencySleepDc = PowerSystemWorking;
1049    mpp.OverThrottledAc.Action = PowerActionNone;
1050    mpp.OverThrottledDc.Action = PowerActionNone;
1051    mpp.DozeS4TimeoutAc=0;
1052    mpp.DozeS4TimeoutDc=0;
1053
1054    for (i = 0; i<6; i++)
1055    {
1056       _itow(i,tmp,10);
1057       err = RegCreateKey(hKeyPowerPolicies,tmp,&hKeytmp);
1058       ok(err == ERROR_SUCCESS,"Create Key Mach PowerPolicies(%i) failed with error %i\n",(UINT)i,(UINT)err);
1059       err = RegSetValueExW(hKeytmp,szPolicies,(DWORD)NULL,REG_BINARY,(CONST BYTE *)&mpp,sizeof(MACHINE_POWER_POLICY));
1060       err = RegCloseKey(hKeytmp);
1061    }
1062    err = RegCloseKey(hKeyPowerPolicies);
1063
1064    err = RegCreateKey(hKeyPowrCfg,szProcessorPolicies,&hKeyPowerPolicies);
1065    ok(err == ERROR_SUCCESS,"Create Key Mach ProcessorPolicies failed with error %i\n",(UINT)err);
1066
1067    mppp.Revision = 1;
1068    mppp.ProcessorPolicyAc.Revision = 1;
1069    mppp.ProcessorPolicyDc.Revision = 1;
1070
1071    for (i = 0; i<6; i++)
1072    {
1073       _itow(i,tmp,10);
1074       err = RegCreateKey(hKeyPowerPolicies,tmp,&hKeytmp);
1075       ok(err == ERROR_SUCCESS,"Create Key Mach ProcessorPolicies(%i) failed with error %i\n",i,(UINT)err);
1076       err = RegSetValueExW(hKeytmp,szPolicies,(DWORD)NULL,REG_BINARY,(CONST BYTE *)&mppp,sizeof(MACHINE_PROCESSOR_POWER_POLICY));
1077       err = RegCloseKey(hKeytmp);
1078    }
1079    err = RegCloseKey(hKeyPowerPolicies);
1080
1081    err = RegCloseKey(hKeyPowrCfg);
1082
1083    err = GetCurrentPowerPolicies(&gpp,&pp);
1084    ok(err, "function was expected to succeed error %i\n",(UINT)GetLastError());
1085
1086    err = ValidatePowerPolicies(&gpp,&pp);
1087    ok(err, "function was expected to succeed error %i\n",(UINT)GetLastError());
1088
1089    /*
1090       [HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Controls Folder\PowerCfg\GlobalPowerPolicy]
1091       "CursorProperties"=...
1092
1093     */
1094
1095 }