15 Jun
2006
15 Jun
'06
2:50 p.m.
Author: janderwald
Date: Thu Jun 15 18:50:42 2006
New Revision: 22369
URL: http://svn.reactos.ru/svn/reactos?rev=22369&view=rev
Log:
* add powrprof regression tests
* developed by Alex Wurzinger, Johannes Anderwald & Martin Rottensteiner
Added:
trunk/reactos/regtests/winetests/powrprof/
trunk/reactos/regtests/winetests/powrprof/powrprof.rbuild (with props)
trunk/reactos/regtests/winetests/powrprof/pwrprof.c (with props)
trunk/reactos/regtests/winetests/powrprof/testlist.c (with props)
Modified:
trunk/reactos/regtests/winetests/directory.rbuild
Modified: trunk/reactos/regtests/winetests/directory.rbuild
URL:
http://svn.reactos.ru/svn/reactos/trunk/reactos/regtests/winetests/director…
==============================================================================
--- trunk/reactos/regtests/winetests/directory.rbuild (original)
+++ trunk/reactos/regtests/winetests/directory.rbuild Thu Jun 15 18:50:42 2006
@@ -26,6 +26,9 @@
<directory name="psapi">
<xi:include href="psapi/psapi.rbuild" />
</directory>
+<directory name="powrprof">
+ <xi:include href="powrprof/powrprof.rbuild" />
+</directory>
<directory name="setupapi">
<xi:include href="setupapi/setupapi.rbuild" />
</directory>
Added: trunk/reactos/regtests/winetests/powrprof/powrprof.rbuild
URL:
http://svn.reactos.ru/svn/reactos/trunk/reactos/regtests/winetests/powrprof…
==============================================================================
--- trunk/reactos/regtests/winetests/powrprof/powrprof.rbuild (added)
+++ trunk/reactos/regtests/winetests/powrprof/powrprof.rbuild Thu Jun 15 18:50:42 2006
@@ -1,0 +1,10 @@
+<module name="powrprof_winetest" type="win32cui"
installbase="bin" installname="powrprof_winetest.exe"
allowwarnings="true">
+ <include base="setupapi_winetest">.</include>
+ <define name="__USE_W32API" />
+ <define name="UNICODE" />
+ <define name="_UNICODE" />
+ <library>ntdll</library>
+ <library>powrprof</library>
+ <file>testlist.c</file>
+ <file>pwrprof.c</file>
+</module>
Propchange: trunk/reactos/regtests/winetests/powrprof/powrprof.rbuild
------------------------------------------------------------------------------
svn:eol-style = native
Added: trunk/reactos/regtests/winetests/powrprof/pwrprof.c
URL:
http://svn.reactos.ru/svn/reactos/trunk/reactos/regtests/winetests/powrprof…
==============================================================================
--- trunk/reactos/regtests/winetests/powrprof/pwrprof.c (added)
+++ trunk/reactos/regtests/winetests/powrprof/pwrprof.c Thu Jun 15 18:50:42 2006
@@ -1,0 +1,1093 @@
+#include<stdarg.h>
+#include "ntstatus.h"
+#define WIN32_NO_STATUS
+#define STANDALONE
+#include "wine/test.h"
+#include "winternl.h"
+#include "windef.h"
+#include "winbase.h"
+#include "powrprof.h"
+#include "assert.h"
+
+#include "wine/unicode.h"
+/*
+ LONG WINAPI RegOpenCurrentUser(REGSAM a,PHKEY b)
+ {
+ *b = HKEY_CURRENT_USER;
+ return ERROR_SUCCESS;
+ }
+ */
+unsigned int g_NumPwrSchemes = 0;
+unsigned int g_NumPwrSchemesEnumerated = 0;
+unsigned int g_ActivePwrScheme = 3;
+unsigned int g_TempPwrScheme = 99;
+
+typedef struct _PROCESSOR_POWER_INFORMATION {
+ ULONG Number;
+ ULONG MaxMhz;
+ ULONG CurrentMhz;
+ ULONG MhzLimit;
+ ULONG MaxIdleState;
+ ULONG CurrentIdleState;
+} PROCESSOR_POWER_INFORMATION,
+*PPROCESSOR_POWER_INFORMATION;
+
+POWER_POLICY g_PowerPolicy;
+
+static const WCHAR szMachPowerPoliciesSubKey[] = { 'S', 'O', 'F',
'T', 'W', 'A', 'R',
+ 'E', '\\',
'M', 'i', 'c', 'r', 'o', 's', 'o',
'f', 't', '\\', 'W', 'i', 'n',
'd',
+ 'o', 'w', 's',
'\\', 'C', 'u', 'r', 'r', 'e',
'n', 't', 'V', 'e', 'r', 's',
'i',
+ 'o', 'n',
'\\', 'C', 'o', 'n', 't', 'r',
'o', 'l', 's', ' ', 'F', 'o', 'l',
'd',
+ 'e', 'r',
'\\', 'P', 'o', 'w', 'e', 'r',
'C', 'f', 'g', '\\', 'P', 'o',
'w', 'e',
+ 'r', 'P', 'o',
'l', 'i', 'c', 'i', 'e', 's', 0};
+
+static const WCHAR szTempPwrScheme[] = { '9', '9', 0 };
+
+ULONG DbgPrint(PCH X,...)
+{
+ return (ULONG)NULL;
+}
+
+void test_CallNtPowerInformation(void)
+{
+ DWORD retval;
+ ADMINISTRATOR_POWER_POLICY apolicy;
+ ULONGLONG atime, ctime;
+ PROCESSOR_POWER_INFORMATION ppi, *pppi;
+ PROCESSOR_POWER_POLICY ppp;
+ SYSTEM_BATTERY_STATE sbs;
+ SYSTEM_POWER_CAPABILITIES spc;
+ SYSTEM_POWER_INFORMATION spi;
+ SYSTEM_POWER_POLICY spp;
+ HANDLE x=NULL;
+
+ /* AdministratorPowerPolicy tests */
+ retval = CallNtPowerInformation(AdministratorPowerPolicy, 0, 0, 0, 0);
+ ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but
got %d\n", (UINT)retval);
+ retval = CallNtPowerInformation(AdministratorPowerPolicy, 0, 0, &apolicy,
sizeof(ADMINISTRATOR_POWER_POLICY));
+ ok(retval == STATUS_SUCCESS, "function expected STATUS_SUCCESS but got
%d\n", (UINT)retval);
+ retval = CallNtPowerInformation(AdministratorPowerPolicy, &apolicy,
sizeof(ADMINISTRATOR_POWER_POLICY), 0, 0);
+ ok(retval != STATUS_PRIVILEGE_NOT_HELD, "Privileg not held!!!! more errors to
expect");
+ ok(retval == STATUS_SUCCESS, "function expected STATUS_SUCCESS but got
%d\n", (UINT)retval);
+
+ /* LastSleepTime tests */
+ retval = CallNtPowerInformation(LastSleepTime, 0, 0, 0, 0);
+ ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but
got %d\n", (UINT)retval);
+ retval = CallNtPowerInformation(LastSleepTime, &atime, sizeof(sizeof(ULONGLONG)),
0, 0);
+ ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected
STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
+ retval = CallNtPowerInformation(LastSleepTime, &atime, sizeof(ULONGLONG),
&ctime, sizeof(ULONGLONG));
+ ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected
STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
+ retval = CallNtPowerInformation(LastSleepTime, 0, 0, &atime, sizeof(ULONGLONG));
+ ok(retval == STATUS_SUCCESS, "function expected STATUS_SUCCESS but got
%d\n",(UINT)retval);
+
+ /* LastWakeTime tests */
+ retval = CallNtPowerInformation(LastWakeTime, 0, 0, 0, 0);
+ ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but
got %d\n", (UINT)retval);
+ retval = CallNtPowerInformation(LastWakeTime, &atime, sizeof(sizeof(ULONGLONG)),
0, 0);
+ ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected
STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
+ retval = CallNtPowerInformation(LastWakeTime, &atime, sizeof(ULONGLONG),
&ctime, sizeof(ULONGLONG));
+ ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected
STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
+ retval = CallNtPowerInformation(LastWakeTime, 0, 0, &atime, sizeof(ULONGLONG));
+ ok(retval == STATUS_SUCCESS, "function expected STATUS_SUCCESS but got
%d\n",(UINT)retval);
+
+ /* ProcessorInformation tests */
+ retval = CallNtPowerInformation(ProcessorInformation, 0, 0, 0, 0);
+ ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but
got %d\n", (UINT)retval);
+ retval = CallNtPowerInformation(ProcessorInformation, 0, 0, &ppi,
sizeof(PROCESSOR_POWER_INFORMATION));
+ ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but
got %d\n", (UINT)retval);
+ retval = CallNtPowerInformation(ProcessorInformation, &ppi,
sizeof(PROCESSOR_POWER_INFORMATION), 0, 0);
+ ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but
got %d\n", (UINT)retval);
+ retval = CallNtPowerInformation(ProcessorInformation, &ppi,
sizeof(PROCESSOR_POWER_INFORMATION), &ppi, sizeof(PROCESSOR_POWER_INFORMATION));
+
+ ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but
got %d\n", (UINT)retval);
+ retval = CallNtPowerInformation(ProcessorInformation, 0, 0, &pppi,
sizeof(PPROCESSOR_POWER_INFORMATION));
+ ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but
got %d\n", (UINT)retval);
+ retval = CallNtPowerInformation(ProcessorInformation, &pppi,
sizeof(PPROCESSOR_POWER_INFORMATION), 0, 0);
+ ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but
got %d\n", (UINT)retval);
+ retval = CallNtPowerInformation(ProcessorInformation, &pppi,
sizeof(PPROCESSOR_POWER_INFORMATION), &pppi, sizeof(PPROCESSOR_POWER_INFORMATION));
+ ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but
got %d\n", (UINT)retval);
+
+ /* ProcessorPowerPolicyAc tests */
+ retval = CallNtPowerInformation(ProcessorPowerPolicyAc, 0, 0, 0, 0);
+ ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but
got %d\n", (UINT)retval);
+ retval = CallNtPowerInformation(ProcessorPowerPolicyAc, 0, 0, &ppp,
sizeof(PROCESSOR_POWER_POLICY));
+ ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but
got %d\n", (UINT)retval);
+ retval = CallNtPowerInformation(ProcessorPowerPolicyAc, &ppp,
sizeof(PROCESSOR_POWER_POLICY), 0, 0);
+ ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but
got %d\n", (UINT)retval);
+ retval = CallNtPowerInformation(ProcessorPowerPolicyAc, &ppp,
sizeof(PROCESSOR_POWER_POLICY), &ppp, sizeof(PROCESSOR_POWER_POLICY));
+ ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but
got %d\n", (UINT)retval);
+
+ /* ProcessorPowerPolicyCurrent tests */
+ retval = CallNtPowerInformation(ProcessorPowerPolicyCurrent, 0, 0, 0, 0);
+ ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but
got %d\n", (UINT)retval);
+ retval = CallNtPowerInformation(ProcessorPowerPolicyCurrent, 0, 0, &ppp,
sizeof(PROCESSOR_POWER_POLICY));
+ ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but
got %d\n", (UINT)retval);
+ retval = CallNtPowerInformation(ProcessorPowerPolicyCurrent, &ppp,
sizeof(PROCESSOR_POWER_POLICY), 0, 0);
+ ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected
STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
+ retval = CallNtPowerInformation(ProcessorPowerPolicyCurrent, &ppp,
sizeof(PROCESSOR_POWER_POLICY), &ppp, sizeof(PROCESSOR_POWER_POLICY));
+ ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected
STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
+
+ /* ProcessorPowerPolicyDc tests */
+ retval = CallNtPowerInformation(ProcessorPowerPolicyDc, 0, 0, 0, 0);
+ ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but
got %d\n", (UINT)retval);
+ retval = CallNtPowerInformation(ProcessorPowerPolicyDc, 0, 0, &ppp,
sizeof(PROCESSOR_POWER_POLICY));
+ ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but
got %d\n", (UINT)retval);
+ retval = CallNtPowerInformation(ProcessorPowerPolicyDc, &ppp,
sizeof(PROCESSOR_POWER_POLICY), 0, 0);
+ ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but
got %d\n", (UINT)retval);
+ retval = CallNtPowerInformation(ProcessorPowerPolicyDc, &ppp,
sizeof(PROCESSOR_POWER_POLICY), &ppp, sizeof(PROCESSOR_POWER_POLICY));
+ ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but
got %d\n", (UINT)retval);
+
+ /* SystemBatteryState tests */
+ retval = CallNtPowerInformation(SystemBatteryState, 0, 0, 0, 0);
+ ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but
got %d\n", (UINT)retval);
+ retval = CallNtPowerInformation(SystemBatteryState, 0, 0, &sbs,
sizeof(SYSTEM_BATTERY_STATE));
+ ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but
got %d\n", (UINT)retval);
+ retval = CallNtPowerInformation(SystemBatteryState, &sbs,
sizeof(SYSTEM_BATTERY_STATE), 0, 0);
+ ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but
got %d\n", (UINT)retval);
+ retval = CallNtPowerInformation(SystemBatteryState, &sbs,
sizeof(SYSTEM_BATTERY_STATE), &sbs, sizeof(SYSTEM_BATTERY_STATE));
+ ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but
got %d\n", (UINT)retval);
+
+ /* SystemExecutionState tests */
+ retval = CallNtPowerInformation(SystemExecutionState, 0, 0, 0, 0);
+ ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but
got %d\n", (UINT)retval);
+
+ /* SystemPowerCapabilities tests */
+ retval = CallNtPowerInformation(SystemPowerCapabilities, 0, 0, 0, 0);
+ ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but
got %d\n", (UINT)retval);
+ retval = CallNtPowerInformation(SystemPowerCapabilities, 0, 0, &spc,
sizeof(SYSTEM_POWER_CAPABILITIES));
+ ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but
got %d\n", (UINT)retval);
+ retval = CallNtPowerInformation(SystemPowerCapabilities, &spc,
sizeof(SYSTEM_POWER_CAPABILITIES), 0, 0);
+ ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected
STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
+ retval = CallNtPowerInformation(SystemPowerCapabilities, &spc,
sizeof(SYSTEM_POWER_CAPABILITIES), &spc, sizeof(SYSTEM_POWER_CAPABILITIES));
+ ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected
STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
+
+ /* SystemPowerInformation tests */
+ retval = CallNtPowerInformation(SystemPowerInformation, 0, 0, 0, 0);
+ ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but
got %d\n", (UINT)retval);
+ retval = CallNtPowerInformation(SystemPowerInformation, 0, 0, &spi,
sizeof(SYSTEM_POWER_INFORMATION));
+ ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but
got %d\n", (UINT)retval);
+ retval = CallNtPowerInformation(SystemPowerInformation, &spi,
sizeof(SYSTEM_POWER_INFORMATION), 0, 0);
+ ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but
got %d\n", (UINT)retval);
+ retval = CallNtPowerInformation(SystemPowerInformation, &spi,
sizeof(SYSTEM_POWER_INFORMATION), &spi, sizeof(SYSTEM_POWER_INFORMATION));
+ ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but
got %d\n", (UINT)retval);
+ retval = CallNtPowerInformation(SystemPowerInformation, &spp,
sizeof(SYSTEM_POWER_POLICY), 0, 0);
+ ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but
got %d\n", (UINT)retval);
+ retval = CallNtPowerInformation(SystemPowerInformation, &spp,
sizeof(SYSTEM_POWER_POLICY), &spi, sizeof(SYSTEM_POWER_INFORMATION));
+ ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but
got %d\n", (UINT)retval);
+
+ /* SystemPowerPolicyAc tests */
+ retval = CallNtPowerInformation(SystemPowerPolicyAc, 0, 0, 0, 0);
+ ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but
got %d\n", (UINT)retval);
+ retval = CallNtPowerInformation(SystemPowerPolicyAc, 0, 0, &spp,
sizeof(SYSTEM_POWER_POLICY));
+ ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but
got %d\n", (UINT)retval);
+ retval = CallNtPowerInformation(SystemPowerPolicyAc, &spp,
sizeof(SYSTEM_POWER_POLICY), 0, 0);
+ ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but
got %d\n", (UINT)retval);
+ retval = CallNtPowerInformation(SystemPowerPolicyAc, &spp,
sizeof(SYSTEM_POWER_POLICY), &spp, sizeof(SYSTEM_POWER_POLICY));
+ ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but
got %d\n", (UINT)retval);
+
+ /* SystemPowerPolicyCurrent tests */
+ retval = CallNtPowerInformation(SystemPowerPolicyCurrent, 0, 0, 0, 0);
+ ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but
got %d\n", (UINT)retval);
+ retval = CallNtPowerInformation(SystemPowerPolicyCurrent, 0, 0, &spp,
sizeof(SYSTEM_POWER_POLICY));
+ ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but
got %d\n", (UINT)retval);
+ retval = CallNtPowerInformation(SystemPowerPolicyCurrent, &spp,
sizeof(SYSTEM_POWER_POLICY), 0, 0);
+ ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected
STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
+ retval = CallNtPowerInformation(SystemPowerPolicyCurrent, &spp,
sizeof(SYSTEM_POWER_POLICY), &spp, sizeof(SYSTEM_POWER_POLICY));
+ ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected
STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
+
+ /* SystemPowerPolicyDc tests */
+ retval = CallNtPowerInformation(SystemPowerPolicyDc, 0, 0, 0, 0);
+ ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but
got %d\n", (UINT)retval);
+ retval = CallNtPowerInformation(SystemPowerPolicyDc, 0, 0, &spp,
sizeof(SYSTEM_POWER_POLICY));
+ ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but
got %d\n", (UINT)retval);
+ retval = CallNtPowerInformation(SystemPowerPolicyDc, &spp,
sizeof(SYSTEM_POWER_POLICY), 0, 0);
+ ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but
got %d\n", (UINT)retval);
+ retval = CallNtPowerInformation(SystemPowerPolicyDc, &spp,
sizeof(SYSTEM_POWER_POLICY), &spp, sizeof(SYSTEM_POWER_POLICY));
+ ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but
got %d\n", (UINT)retval);
+
+ /* SystemReserveHiberFile tests */
+/*
+ retval = CallNtPowerInformation(SystemReserveHiberFile, 0, 0, 0, 0);
+ ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected
STATUS_INVALID_PARAMETER but got %ld\n", retval);
+ bln=TRUE;
+ retval = CallNtPowerInformation(SystemReserveHiberFile, &bln, sizeof(bln), 0, 0);
+ ok(retval == STATUS_DISK_FULL, "function result wrong expected STATUS_DISK_FULL
but got %ld\n", nret);
+ bln=FALSE;
+ retval = CallNtPowerInformation(SystemReserveHiberFile, &bln, sizeof(bln), 0, 0);
+ ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but
got %ld\n", nret);
+
+ bln2=TRUE;
+ nret = CallNtPowerInformation(SystemReserveHiberFile, 0, 0, &bln2, sizeof(bln2));
+ ok(nret == STATUS_DATATYPE_MISALIGNMENT, "function result wrong expected
STATUS_DATATYPE_MISALIGNMENT but got %ld\n", nret);
+ bln2=FALSE;
+ nret = CallNtPowerInformation(SystemReserveHiberFile, 0, 0, &bln2, sizeof(bln2));
+ ok(nret == STATUS_DATATYPE_MISALIGNMENT, "function result wrong expected
STATUS_DATATYPE_MISALIGNMENT but got %ld\n", nret);
+
+ bln=TRUE;
+ bln2=TRUE;
+ nret = CallNtPowerInformation(SystemReserveHiberFile, &bln, sizeof(bln),
&bln2, sizeof(bln2));
+ ok(nret == STATUS_DATATYPE_MISALIGNMENT, "function result wrong expected
STATUS_DATATYPE_MISALIGNMENT but got %ld\n", nret);
+ bln2=FALSE;
+ nret = CallNtPowerInformation(SystemReserveHiberFile, &bln, sizeof(bln),
&bln2, sizeof(bln2));
+ ok(nret == STATUS_DATATYPE_MISALIGNMENT, "function result wrong expected
STATUS_DATATYPE_MISALIGNMENT but got %ld\n", nret);
+ bln=FALSE;
+ bln2=TRUE;
+ nret = CallNtPowerInformation(SystemReserveHiberFile, &bln, sizeof(bln),
&bln2, sizeof(bln2));
+ ok(nret == STATUS_DATATYPE_MISALIGNMENT, "function result wrong expected
STATUS_DATATYPE_MISALIGNMENT but got %ld\n", nret);
+ bln2=FALSE;
+ nret = CallNtPowerInformation(SystemReserveHiberFile, &bln, sizeof(bln),
&bln2, sizeof(bln2));
+ ok(nret == STATUS_DATATYPE_MISALIGNMENT, "function result wrong expected
STATUS_DATATYPE_MISALIGNMENT but got %ld\n", nret);
+ */
+
+ /* VerifyProcessorPowerPolicyAc tests */
+ retval = CallNtPowerInformation(VerifyProcessorPowerPolicyAc, 0, 0, 0, 0);
+ ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected
STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
+ retval = CallNtPowerInformation(VerifyProcessorPowerPolicyAc, 0, 0, &ppp,
sizeof(PROCESSOR_POWER_POLICY));
+ ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected
STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
+ retval = CallNtPowerInformation(VerifyProcessorPowerPolicyAc, &ppp,
sizeof(PROCESSOR_POWER_POLICY), 0, 0);
+ ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected
STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
+ retval = CallNtPowerInformation(VerifyProcessorPowerPolicyAc, &ppp,
sizeof(PROCESSOR_POWER_POLICY), &ppp, sizeof(PROCESSOR_POWER_POLICY));
+ ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but
got %d\n", (UINT)retval);
+
+ /* VerifyProcessorPowerPolicyDc tests */
+ retval = CallNtPowerInformation(VerifyProcessorPowerPolicyDc, 0, 0, 0, 0);
+ ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected
STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
+ retval = CallNtPowerInformation(VerifyProcessorPowerPolicyDc, 0, 0, &ppp,
sizeof(PROCESSOR_POWER_POLICY));
+ ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected
STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
+ retval = CallNtPowerInformation(VerifyProcessorPowerPolicyDc, &ppp,
sizeof(PROCESSOR_POWER_POLICY), 0, 0);
+ ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected
STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
+ retval = CallNtPowerInformation(VerifyProcessorPowerPolicyDc, &ppp,
sizeof(PROCESSOR_POWER_POLICY), &ppp, sizeof(PROCESSOR_POWER_POLICY));
+ ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but
got %d\n", (UINT)retval);
+
+ /* VerifySystemPolicyAc tests */
+ retval = CallNtPowerInformation(VerifySystemPolicyAc, 0, 0, 0, 0);
+ ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected
STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
+ retval = CallNtPowerInformation(VerifySystemPolicyAc, 0, 0, &spp,
sizeof(SYSTEM_POWER_POLICY));
+ ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected
STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
+ retval = CallNtPowerInformation(VerifySystemPolicyAc, &spp,
sizeof(SYSTEM_POWER_POLICY), 0, 0);
+ ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected
STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
+ retval = CallNtPowerInformation(VerifySystemPolicyAc, &spp,
sizeof(SYSTEM_POWER_POLICY), &spp, sizeof(SYSTEM_POWER_POLICY));
+ ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but
got %d\n", (UINT)retval);
+
+ /* VerifySystemPolicyDc tests */
+ retval = CallNtPowerInformation(VerifySystemPolicyDc, 0, 0, 0, 0);
+ ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected
STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
+ retval = CallNtPowerInformation(VerifySystemPolicyDc, 0, 0, &spp,
sizeof(SYSTEM_POWER_POLICY));
+ ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected
STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
+ retval = CallNtPowerInformation(VerifySystemPolicyDc, &spp,
sizeof(SYSTEM_POWER_POLICY), 0, 0);
+ ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected
STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
+ retval = CallNtPowerInformation(VerifySystemPolicyDc, &spp,
sizeof(SYSTEM_POWER_POLICY), &spp, sizeof(SYSTEM_POWER_POLICY));
+ ok(retval == STATUS_SUCCESS, "function result wrong expected STATUS_SUCCESS but
got %d\n", (UINT)retval);
+
+ /* SystemPowerStateHandler tests */
+ retval = CallNtPowerInformation(SystemPowerStateHandler, 0, 0, 0, 0);
+ ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected
STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
+ retval = CallNtPowerInformation(SystemPowerStateHandler, 0, 0, x, sizeof(HANDLE));
+ ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected
STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
+
+ /* ProcessorStateHandler tests */
+ retval = CallNtPowerInformation(ProcessorStateHandler, 0, 0, 0, 0);
+ ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected
STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
+ retval = CallNtPowerInformation(ProcessorStateHandler, 0, 0, x, sizeof(HANDLE));
+ ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected
STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
+
+ /* ProcessorStateHandler2 tests */
+ retval = CallNtPowerInformation(ProcessorStateHandler2, 0, 0, 0, 0);
+ ok(retval == STATUS_ACCESS_DENIED, "function result wrong expected
STATUS_ACCESS_DENIED but got %d\n", (UINT)retval);
+ retval = CallNtPowerInformation(ProcessorStateHandler2, 0, 0, x, sizeof(HANDLE));
+ ok(retval == STATUS_ACCESS_DENIED, "function result wrong expected
STATUS_ACCESS_DENIED but got %d\n", (UINT)retval);
+
+ /* SystemPowerStateNotifyHandler tests */
+ retval = CallNtPowerInformation(SystemPowerStateNotifyHandler, 0, 0, 0, 0);
+ ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected
STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
+ retval = CallNtPowerInformation(SystemPowerStateNotifyHandler, 0, 0, x,
sizeof(HANDLE));
+ ok(retval == STATUS_INVALID_PARAMETER, "function result wrong expected
STATUS_INVALID_PARAMETER but got %d\n", (UINT)retval);
+
+}
+
+/*
+ @implemented
+ */
+void test_CanUserWritePwrScheme(void)
+{
+ DWORD error, retval;
+
+ retval = CanUserWritePwrScheme();
+
+ error = GetLastError();
+
+ if (retval)
+ ok(retval, "function failed?");
+ else
+ ok(error == ERROR_ACCESS_DENIED, "function last error wrong expected
ERROR_ACCESS_DENIED but got %d\n", (UINT)error);
+
+}
+BOOLEAN CALLBACK test_callback_EnumPwrScheme(UINT uiIndex, DWORD dwName, LPWSTR sName,
DWORD dwDesc,
+ LPWSTR sDesc, PPOWER_POLICY pp,LPARAM lParam
)
+{
+ ok(uiIndex == g_NumPwrSchemes, "expected power scheme index of %d but got
%d\n", g_NumPwrSchemes, uiIndex);
+ g_NumPwrSchemes++;
+
+ ok(lParam == 0xDEADBEEF, "expected function lParam to be 0xDEADBEEF but got
%d\n", (UINT)lParam);
+
+ return TRUE;
+}
+
+BOOLEAN CALLBACK test_callback_stop_EnumPwrScheme(UINT uiIndex, DWORD dwName, LPWSTR
sName, DWORD dwDesc,
+ LPWSTR sDesc, PPOWER_POLICY pp,LPARAM
lParam )
+{
+ ok((!uiIndex || g_NumPwrSchemesEnumerated + 1 == uiIndex), "expected power scheme
%d but got %d\n",g_NumPwrSchemesEnumerated+1, uiIndex);
+ g_NumPwrSchemesEnumerated = uiIndex;
+
+ ok(uiIndex <= (UINT)lParam, "enumeration should have already been stopped at
index %d current index %d\n", (UINT)lParam, uiIndex);
+ if (uiIndex == (UINT)lParam)
+ return FALSE;
+ else
+ return TRUE;
+}
+
+void test_DeletePwrScheme(void)
+{
+ DWORD retval;
+ HKEY hSubKey = NULL;
+
+
+ /*
+ * try inexistant profile number, should fail
+ */
+
+ retval = DeletePwrScheme(0xFFFFFFFF);
+ ok(!retval, "function should have failed error %x\n",(UINT)GetLastError());
+
+ /*
+ * delete active power scheme, should fail
+ */
+
+ retval = GetActivePwrScheme(&g_ActivePwrScheme);
+ ok(retval, "function was expected to succeed, error
%x\n",(UINT)GetLastError());
+
+ retval = DeletePwrScheme(g_ActivePwrScheme);
+ ok(!retval, "function should have failed\n");
+ ok(GetLastError() == ERROR_ACCESS_DENIED, "function should have failed with
ERROR_ACCESS_DENIED but got %x\n", (UINT)GetLastError());
+
+ /*
+ * delete a temporarly created power scheme
+ */
+ retval = DeletePwrScheme(g_TempPwrScheme);
+ ok(retval, "function should have succeeded\n");
+
+/*
+ * clean up, delete illegal entry, witch was created for this test
+ */
+
+ if (RegOpenKeyW(HKEY_LOCAL_MACHINE, szMachPowerPoliciesSubKey, &hSubKey) ==
ERROR_SUCCESS)
+ {
+ if (RegDeleteKeyW(hSubKey, szTempPwrScheme) != STATUS_SUCCESS)
+ printf("failed to delete subkey %i (testentry)\n", g_TempPwrScheme);
+ RegCloseKey(hSubKey);
+ }
+
+}
+
+void test_EnumPwrSchemes(void)
+{
+ BOOLEAN retval;
+
+ /*
+ * test EnumPwrScheme with null pointer callback
+ */
+
+ retval = EnumPwrSchemes(0, 0);
+ ok(!retval, "function was expected to fail\n");
+ ok(GetLastError() == ERROR_INVALID_PARAMETER, "expected ERROR_INVALID_PARAMETER
but got %x\n",(UINT)GetLastError());
+
+ /*
+ * enumerate power schemes, should succeed
+ */
+
+ retval = EnumPwrSchemes(test_callback_EnumPwrScheme, 0xDEADBEEF);
+ ok(retval, "function was expected to succeed %d\n",retval);
+ ok(g_NumPwrSchemes, "Warning: no power schemes available\n");
+
+ /*
+ * stop enumeration after first power scheme
+ */
+
+ retval = EnumPwrSchemes(test_callback_stop_EnumPwrScheme, (LPARAM)0);
+ ok(!retval, "function was expected to false\n");
+
+ /*
+ * enumerate half of all avalailble profiles
+ */
+
+ g_NumPwrSchemesEnumerated = 0;
+ retval = EnumPwrSchemes(test_callback_stop_EnumPwrScheme, (LPARAM)g_NumPwrSchemes /
2);
+ ok(retval, "function was expected to succeed but got %i\n", (UINT)retval);
+ ok(g_NumPwrSchemesEnumerated == g_NumPwrSchemes / 2, "function did not enumerate
requested num of profiles %d enumerated %d\n", g_NumPwrSchemes / 2,
g_NumPwrSchemesEnumerated);
+
+
+}
+
+void test_GetSetActivePwrScheme(void)
+{
+ DWORD retval;
+ UINT current_scheme = 2;
+ UINT temp_scheme = 0;
+
+ /*
+ * read active power scheme
+ */
+
+ retval = GetActivePwrScheme(&g_ActivePwrScheme);
+
+ ok(retval, "function was expected to succeed, error
%x\n",(UINT)GetLastError());
+ ok(retval <= g_NumPwrSchemes, "expected index lower as power scheme count %d
but got %d\n", g_NumPwrSchemes, g_ActivePwrScheme);
+
+ /*
+ * sets active power scheme to inexistant profile
+ * -> corrupts power scheme enumeration on Windows XP SP2
+ */
+ //corrupts registry
+ //retval = SetActivePwrScheme(0xFFFFFFFF, 0, 0);
+ //ok(!retval, "function was expected to fail");
+ //current_scheme = min(active_scheme+1, g_NumPwrSchemes-1);
+
+ /*
+ * sets the active power scheme to profile with index 0
+ */
+
+ retval = SetActivePwrScheme(current_scheme, 0, 0);
+ ok(retval, "function was expected to succeed, error
%x\n",(UINT)GetLastError());
+
+ /*
+ * read back the active power scheme
+ */
+
+ retval = GetActivePwrScheme(&temp_scheme);
+ ok(retval, "function was expected to succeed, error
%x\n",(UINT)GetLastError());
+ ok(temp_scheme == current_scheme, "expected %d but got %d\n",
(UINT)current_scheme, (UINT)temp_scheme);
+
+ /*
+ * restore previous active power scheme
+ */
+
+ retval = SetActivePwrScheme(g_ActivePwrScheme, 0, 0);
+ ok(retval, "Warning: failed to restore old active power scheme %d\n",
(UINT)g_ActivePwrScheme);
+}
+
+void test_GetCurrentPowerPolicies(void)
+{
+ GLOBAL_POWER_POLICY gpp;
+ POWER_POLICY pp;
+ BOOLEAN ret;
+ UINT current_scheme = 2;
+
+ g_ActivePwrScheme=3;
+ ret = GetActivePwrScheme(&g_ActivePwrScheme);
+
+ ok(ret, "function was expected to succeed, error
%x\n",(UINT)GetLastError());
+ ret = SetActivePwrScheme(0, &gpp, 0);
+
+ ok(!ret, "function was expected to fail, error %x\n",(UINT)GetLastError());
+
+ ret = SetActivePwrScheme(0, 0, &pp);
+ ok(!ret, "function was expected to fail, error %x\n",(UINT)GetLastError());
+
+ ret = SetActivePwrScheme(0, &gpp, &pp);
+ ok(!ret, "function was expected to fail, error %x\n",(UINT)GetLastError());
+
+ ret = SetActivePwrScheme(current_scheme, &gpp, 0);
+ ok(!ret, "function was expected to fail, error %x\n",(UINT)GetLastError());
+
+ ret = SetActivePwrScheme(current_scheme, 0, &pp);
+ ok(!ret, "function was expected to fail, error %x\n",(UINT)GetLastError());
+
+ ret = SetActivePwrScheme(current_scheme, &gpp, &pp);
+ ok(!ret, "function was expected to fail, error %x\n",(UINT)GetLastError());
+
+ ret = SetActivePwrScheme(g_ActivePwrScheme, 0, 0);
+ ok(ret, "Warning: failed to restore old active power scheme %d\n",
(UINT)g_ActivePwrScheme);
+
+ ret = GetCurrentPowerPolicies(0,0);
+ ok(ret, "function was expected to succeed, error
%x\n",(UINT)GetLastError());
+
+ ret = GetCurrentPowerPolicies(&gpp,0);
+ ok(ret, "function was expected to succeed, error
%x\n",(UINT)GetLastError());
+
+ ret = GetCurrentPowerPolicies(0,&pp);
+ ok(ret, "function was expected to succeed, error
%x\n",(UINT)GetLastError());
+
+ ret = GetCurrentPowerPolicies(&gpp,&pp);
+ ok(ret, "function was expected to succeed, error
%x\n",(UINT)GetLastError());
+ ok(gpp.mach.Revision == 1,"Global Mach Revision was expected to be 1 got
%i",(UINT)gpp.mach.Revision);
+ ok(gpp.user.Revision == 1,"Global User Revision was expected to be 1 got
%i",(UINT)gpp.mach.Revision);
+ ok(pp.mach.Revision == 1,"Mach Revision was expected to be 1 got
%i",(UINT)gpp.mach.Revision);
+ ok(pp.user.Revision == 1,"User Revision was expected to be 1 got
%i",(UINT)gpp.mach.Revision);
+
+
+ ret = GetActivePwrScheme(&g_ActivePwrScheme);
+ ok(ret, "function was expected to succeed, error
%x\n",(UINT)GetLastError());
+
+ ret = SetActivePwrScheme(0, &gpp, 0);
+ ok(ret, "function was expected to succeed, error
%x\n",(UINT)GetLastError());
+
+ ret = SetActivePwrScheme(0, 0, &pp);
+ ok(ret, "function was expected to succeed, error
%x\n",(UINT)GetLastError());
+
+ ret = SetActivePwrScheme(0, &gpp, &pp);
+ ok(ret, "function was expected to succeed, error
%x\n",(UINT)GetLastError());
+
+ ret = SetActivePwrScheme(current_scheme, &gpp, 0);
+ ok(ret, "function was expected to succeed, error
%x\n",(UINT)GetLastError());
+
+ ret = SetActivePwrScheme(current_scheme, 0, &pp);
+ ok(ret, "function was expected to succeed, error
%x\n",(UINT)GetLastError());
+
+ ret = SetActivePwrScheme(current_scheme, &gpp, &pp);
+ ok(ret, "function was expected to succeed, error
%x\n",(UINT)GetLastError());
+
+ ret = SetActivePwrScheme(g_ActivePwrScheme, 0, 0);
+ ok(ret, "Warning: failed to restore old active power scheme %d\n",
(UINT)g_ActivePwrScheme);
+
+}
+
+void test_GetPwrCapabilities(void)
+{
+ SYSTEM_POWER_CAPABILITIES spc;
+ BOOLEAN ret;
+
+ ret = GetPwrCapabilities(0);
+ ok(!ret, "function was expected to fail\n");
+ if (!ret)
+ {
+ ok(GetLastError() == ERROR_INVALID_PARAMETER,"function was expectet to return
ERROR_INVALID_PARAMETER, but returns: %x\n",(UINT)GetLastError());
+ }
+ ret = GetPwrCapabilities(&spc);
+ ok(ret, "function was expected to succeed, error
%x\n",(UINT)GetLastError());
+}
+
+void test_GetPwrDiskSpindownRange(void)
+{
+ DWORD retval;
+ UINT min = 0;
+ UINT max = 0;
+
+ /*
+ * invalid parameter checks
+ */
+
+ retval = GetPwrDiskSpindownRange(NULL, NULL);
+ ok(!retval, "function was expected to fail\n");
+ ok(GetLastError() == ERROR_INVALID_PARAMETER, "expected error
ERROR_INVALID_PARAMETER but got %x\n", (UINT)GetLastError());
+
+ retval = GetPwrDiskSpindownRange(&max, NULL);
+ ok(!retval, "function was expected to fail\n");
+ ok(GetLastError() == ERROR_INVALID_PARAMETER, "expected error
ERROR_INVALID_PARAMETER but got %x\n", (UINT)GetLastError());
+
+ retval = GetPwrDiskSpindownRange(NULL, &min);
+ ok(!retval, "function was expected to fail\n");
+ ok(GetLastError() == ERROR_INVALID_PARAMETER, "expected error
ERROR_INVALID_PARAMETER but got %x\n", (UINT)GetLastError());
+
+ /*
+ * read disk spindown range
+ */
+
+ retval = GetPwrDiskSpindownRange(&max, &min);
+ ok(retval, "function was expected to succeed error
%x\n",(UINT)GetLastError());
+ ok(min <= max, "range mismatch min %d max %d\n",min, max);
+}
+
+void test_IsAdminOverrideActive(void)
+{
+ ADMINISTRATOR_POWER_POLICY app;
+ BOOLEAN ret;
+
+ ret = IsAdminOverrideActive(0);
+ ok(!ret, "function was expected to fail, error %x\n",(UINT)GetLastError());
+
+ ret = IsAdminOverrideActive(&app);
+ ok(!ret, "function was expected to fail, error %x\n",(UINT)GetLastError());
+
+ app.MinSleep = 0;
+ app.MaxSleep = 0;
+ app.MinVideoTimeout = 0;
+ app.MaxVideoTimeout = 0;
+ app.MinSpindownTimeout = 0;
+ app.MaxSpindownTimeout = 0;
+
+ ret = IsAdminOverrideActive(&app);
+ ok(!ret, "function was expected to fail, error %x\n",(UINT)GetLastError());
+
+ app.MinSleep = 1;
+ app.MaxSleep = 2;
+ app.MinVideoTimeout = 3;
+ app.MaxVideoTimeout = 4;
+ app.MinSpindownTimeout = 5;
+ app.MaxSpindownTimeout = 6;
+
+ ret = IsAdminOverrideActive(&app);
+ ok(!ret, "function was expected to fail, error %x\n",(UINT)GetLastError());
+
+}
+
+void test_IsPwrHibernateAllowed(void)
+{
+/*
+ BOOLEAN ret;
+
+ ret = IsPwrHibernateAllowed();
+ ok(!ret, "function was expected to fail, error
%x\n",(UINT)GetLastError());
+ */
+}
+
+void test_IsPwrShutdownAllowed(void)
+{
+/*
+ BOOLEAN ret;
+
+ ret = IsPwrShutdownAllowed();
+ ok(ret, "function was expected to succeed, error
%x\n",(UINT)GetLastError());
+ */
+}
+
+void test_IsPwrSuspendAllowed(void)
+{
+/*
+ BOOLEAN ret;
+
+ ret = IsPwrSuspendAllowed();
+ ok(ret, "function was expected to succed, error
%x\n",(UINT)GetLastError());
+ */
+}
+
+void test_ReadGlobalPwrPolicy(void)
+{
+ GLOBAL_POWER_POLICY gpp;
+ BOOLEAN ret;
+
+ ret = ReadGlobalPwrPolicy(&gpp);
+ ok(ret, "function was expected to succeed, error
%x\n",(UINT)GetLastError());
+ ok(gpp.mach.Revision == 1,"Global Mach Revision was expected to be 1 got
%i",(UINT)gpp.mach.Revision);
+ ok(gpp.user.Revision == 1,"Global User Revision was expected to be 1 got
%i",(UINT)gpp.mach.Revision);
+
+
+
+}
+
+void test_ReadProcessorPwrScheme(void)
+{
+ MACHINE_PROCESSOR_POWER_POLICY mppp;
+ BOOLEAN ret;
+ UINT i = 0;
+ DWORD err;
+
+ do
+ {
+ RtlZeroMemory(&mppp, sizeof(MACHINE_PROCESSOR_POWER_POLICY));
+ ret = ReadProcessorPwrScheme(i,&mppp);
+ if (ret)
+ {
+ ok(mppp.Revision == 1,"Main Revision was expected to be 1 got
%i",(UINT)mppp.Revision);
+ ok(mppp.ProcessorPolicyAc.Revision == 1,"PowerAC Revision was expected to
be 1 got %i",(UINT)mppp.ProcessorPolicyAc.Revision);
+ ok(mppp.ProcessorPolicyDc.Revision == 1,"PowerDC Revision was expected to
be 1 got %i",(UINT)mppp.ProcessorPolicyDc.Revision);
+ }
+ else
+ {
+ err = GetLastError();
+ ok(err == 0,"Failed Error %x\n",(UINT)err);
+ return;
+ }
+ i++;
+ if (i == g_NumPwrSchemes)
+ return;
+ } while (TRUE);
+
+}
+
+void test_ReadPwrScheme(void)
+{
+ DWORD retval;
+
+ /*
+ * read power scheme with null pointer -> crashs on Windows XP SP2
+ */
+ //retval = ReadPwrScheme(0, NULL);
+ //ok(!retval, "function was expected to fail\n");
+ //ok(GetLastError() == STATUS_INVALID_PARAMETER, "expected error ... but got
%x\n", GetLastError());
+
+ /*
+ * read a power scheme with an invalid index, leads to the creation of the key
+ * -> corrupts power scheme enumeration
+ */
+ //retval = ReadPwrScheme(0xFFFFFFFF, &powerPolicy);
+ //ok(!retval, "function was expected to fail\n");
+ //ok(GetLastError() == ERROR_ACCESS_DENIED, "expected error ERROR_ACCESS_DENIED
but got %x\n", GetLastError());
+
+ /*
+ * read current active power scheme
+ */
+
+ retval = ReadPwrScheme(g_ActivePwrScheme, &g_PowerPolicy);
+ ok(retval, "function was expected to succeed error
%x\n",(UINT)GetLastError());
+
+}
+
+void test_SetSuspendState(void)
+{
+// SetSuspendState(FALSE,FALSE,FALSE)
+}
+
+void test_ValidatePowerPolicies(void)
+{
+ GLOBAL_POWER_POLICY gpp;
+ POWER_POLICY pp;
+ BOOLEAN ret;
+
+ SetLastError(0);
+ ret = ValidatePowerPolicies(0,0);
+ ok(ret, "function was expected to succeed error
%i\n",(UINT)GetLastError());
+
+ ret = ValidatePowerPolicies(&gpp,0);
+ ok(!ret, "function was expected to fail return %i\n",(UINT)ret);
+ 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());
+
+ ret = ValidatePowerPolicies(0,&pp);
+ ok(!ret, "function was expected to fail return %i\n",(UINT)ret);
+ ok(GetLastError() == ERROR_REVISION_MISMATCH,"function was expected to fail with
ERROR_REVISION_MISMATCH, but error :%i\n",(UINT)GetLastError());
+
+ ret = ValidatePowerPolicies(&gpp,&pp);
+ ok(!ret, "function was expected to fail return %i\n",(UINT)ret);
+ ok(GetLastError() == ERROR_REVISION_MISMATCH,"function was expected to fail with
ERROR_REVISION_MISMATCH, but error :%i\n",(UINT)GetLastError());
+
+ gpp.user.Revision = 1;
+ gpp.mach.Revision = 1;
+
+ ret = ValidatePowerPolicies(&gpp,0);
+ ok(!ret, "function was expected to fail return %i\n",(UINT)ret);
+ ok(GetLastError() == ERROR_INVALID_DATA,"function was expected to fail with
ERROR_INVALID_DATA, but error :%i\n",(UINT)GetLastError());
+
+ gpp.mach.LidOpenWakeAc = PowerSystemWorking;
+ gpp.mach.LidOpenWakeDc = PowerSystemWorking;
+
+ ret = ValidatePowerPolicies(&gpp,0);
+ ok(!ret, "function was expected to fail return %i\n",(UINT)ret);
+ ok(GetLastError() == ERROR_INVALID_DATA,"function was expected to fail with
ERROR_INVALID_DATA, but error :%i\n",(UINT)GetLastError());
+
+ gpp.user.PowerButtonAc.Action = PowerActionNone;
+ gpp.user.PowerButtonDc.Action = PowerActionNone;
+ gpp.user.SleepButtonAc.Action = PowerActionNone;
+ gpp.user.SleepButtonDc.Action = PowerActionNone;
+ gpp.user.LidCloseAc.Action = PowerActionNone;
+ gpp.user.LidCloseDc.Action = PowerActionNone;
+
+ gpp.user.DischargePolicy[0].Enable=FALSE;
+ gpp.user.DischargePolicy[1].Enable=FALSE;
+ gpp.user.DischargePolicy[2].Enable=FALSE;
+ gpp.user.DischargePolicy[3].Enable=FALSE;
+ gpp.user.DischargePolicy[4].Enable=FALSE;
+ ret = ValidatePowerPolicies(&gpp,0);
+ ok(ret, "function was expected to succeed return
%i\n",(UINT)GetLastError());
+ if (!ret)
+ {
+ ok(GetLastError() == ERROR_INVALID_DATA,"function was expected to fail with
ERROR_INVALID_DATA, but error :%i\n",(UINT)GetLastError());
+ }
+
+ pp.user.Revision = 1;
+ pp.mach.Revision = 1;
+
+ ret = ValidatePowerPolicies(0,&pp);
+ ok(!ret, "function was expected to fail return %i\n",(UINT)ret);
+ 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());
+
+ pp.mach.MinSleepAc = PowerSystemWorking;
+ pp.mach.MinSleepDc = PowerSystemWorking;
+ pp.mach.ReducedLatencySleepAc = PowerSystemWorking;
+ pp.mach.ReducedLatencySleepDc = PowerSystemWorking;
+ pp.mach.OverThrottledAc.Action = PowerActionNone;
+ pp.mach.OverThrottledDc.Action = PowerActionNone;
+
+ pp.user.IdleAc.Action = PowerActionWarmEject+1;
+ pp.user.IdleDc.Action = PowerActionNone-1;
+ pp.user.MaxSleepAc = PowerSystemMaximum+1;
+ pp.user.MaxSleepDc = PowerSystemUnspecified;
+
+ ret = ValidatePowerPolicies(0,&pp);
+ ok(!ret, "function was expected to fail return %i\n",(UINT)GetLastError());
+ if (!ret)
+ {
+ ok(GetLastError() == ERROR_INVALID_DATA,"function was expected to fail with
ERROR_INVALID_DATA, but error :%i\n",(UINT)GetLastError());
+ }
+
+ pp.user.IdleAc.Action = PowerActionNone;
+ pp.user.IdleDc.Action = PowerActionNone;
+ pp.user.MaxSleepAc = PowerSystemWorking;
+ pp.user.MaxSleepDc = PowerSystemWorking;
+
+ ret = ValidatePowerPolicies(0,&pp);
+ ok(ret, "function was expected to succeed, error
%i\n",(UINT)GetLastError());
+ if (!ret)
+ {
+ ok(GetLastError() == ERROR_GEN_FAILURE,"function was expected to fail with
ERROR_GEN_FAILURE, but error :%i\n",(UINT)GetLastError());
+ }
+
+ ret = ValidatePowerPolicies(&gpp,&pp);
+ ok(ret, "function was expected to succeed, error
%i\n",(UINT)GetLastError());
+ if (!ret)
+ {
+// ok(GetLastError() == ERROR_GEN_FAILURE,"function was expected to fail with
ERROR_GEN_FAILURE, but error :%i\n",(UINT)GetLastError());
+ }
+
+
+ ret = GetCurrentPowerPolicies(&gpp,&pp);
+ ok(ret, "function was expected to succeed error
%i\n",(UINT)GetLastError());
+
+ ret = ValidatePowerPolicies(&gpp,0);
+ ok(ret, "function was expected to succeed error
%i\n",(UINT)GetLastError());
+
+ ret = ValidatePowerPolicies(0,&pp);
+ ok(ret, "function was expected to succeed error
%i\n",(UINT)GetLastError());
+
+ ret = ValidatePowerPolicies(&gpp,&pp);
+ ok(ret, "function was expected to succeed error
%i\n",(UINT)GetLastError());
+
+}
+
+void test_WriteGlobalPwrPolicy(void)
+{
+// WriteGlobalPwrPolicy(&gpp);
+}
+
+void test_WriteProcessorPwrScheme(void)
+{
+// WriteProcessorPwrScheme(0,&mppp);
+}
+
+void test_WritePwrScheme(void)
+{
+ DWORD retval;
+ 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");
+}
+
+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();
+ test_WriteGlobalPwrPolicy();
+ test_WriteProcessorPwrScheme();
+
+}
+
+void func_ros_init(void)
+{
+ HKEY hUser, hKeyPowrCfg, hKeyGlobalPowrPol, hKeyPowerPolicies, hKeytmp;
+ DWORD err;
+ GLOBAL_USER_POWER_POLICY gupp;
+ GLOBAL_MACHINE_POWER_POLICY gmpp;
+ USER_POWER_POLICY upp;
+ MACHINE_POWER_POLICY mpp;
+ MACHINE_PROCESSOR_POWER_POLICY mppp;
+ GLOBAL_POWER_POLICY gpp;
+ POWER_POLICY pp;
+
+ int i;
+
+ static const WCHAR szUserPowrCfgKey[] = { 'C', 'o', 'n',
't', 'r', 'o', 'l', ' ',
+ 'P', 'a', 'n',
'e', 'l', '\\', 'P', 'o', 'w',
'e', 'r', 'C', 'f', 'g', 0};
+
+ static const WCHAR szCurrentPowerPolicy[] = {'C', 'u', 'r',
'r', 'e', 'n', 't', 'P',
+ 'o', 'w', 'e',
'r', 'P', 'o', 'l', 'i', 'c', 'y',
0};
+ static const WCHAR szcpp[] = {'3', 0 };
+
+ static const WCHAR szGlobalPowerPolicy[] = { 'G', 'l', 'o',
'b', 'a', 'l', 'P', 'o',
+ 'w', 'e', 'r',
'P', 'o', 'l', 'i', 'c', 'y', 0};
+ static const WCHAR szPolicies[] = {'P', 'o', 'l', 'i',
'c', 'i', 'e', 's', 0};
+ static const WCHAR szPowerPolicies[] = { 'P', 'o', 'w',
'e', 'r', 'P', 'o', 'l', 'i',
+ 'c', 'i', 'e',
's', 0};
+
+ static const WCHAR szProcessorPolicies[] = { 'P', 'r', 'o',
'c', 'e', 's', 's', 'o', 'r',
+ 'P', 'o', 'l',
'i', 'c', 'i', 'e', 's', 0};
+
+ static const WCHAR szcName[] = {'N', 'a', 'm', 'e',
0};
+ static const WCHAR szcDescription[] = {'D', 'e', 's',
'c', 'r', 'i', 'p', 't', 'i', 'o',
'n', 0};
+
+ static WCHAR szName[] = {'N', 'a', 'm', 'e',
'(', '0', ')', 0};
+ static WCHAR szDescription[] = {'D', 'e', 's', 'c',
'r', 'i', 'p', 't', 'i', 'o', 'n',
'(', '0', ')', 0};
+
+ static const WCHAR szMachPowrCfgKey[] = {'S', 'O', 'F',
'T', 'W', 'A', 'R', 'E', '\\',
'M', 'i',
+ 'c', 'r', 'o',
's', 'o', 'f', 't', '\\', 'W',
'i', 'n', 'd', 'o', 'w', 's',
'\\', 'C', 'u',
+ 'r', 'r', 'e',
'n', 't', 'V', 'e', 'r', 's', 'i',
'o', 'n', '\\', 'C', 'o', 'n',
't', 'r',
+ 'o', 'l', 's', '
', 'F', 'o', 'l', 'd', 'e', 'r',
'\\', 'P', 'o', 'w', 'e', 'r',
'C', 'f', 'g', 0};
+
+ static const WCHAR szLastID[] = {'L', 'a', 's', 't',
'I', 'D', 0};
+ static const WCHAR szDiskSpinDownMax[] = {'D', 'i', 's',
'k', 'S', 'p', 'i', 'n', 'D', 'o',
'w', 'n', 'M', 'a', 'x', 0};
+ static const WCHAR szDiskSpinDownMin[] = {'D', 'i', 's',
'k', 'S', 'p', 'i', 'n', 'D', 'o',
'w', 'n', 'M', 'i', 'n', 0};
+
+ static const WCHAR szLastIDValue[] = {'5', 0};
+ static const WCHAR szDiskSpinDownMaxValue[] = {'3', '6', '0',
'0', 0};
+ static const WCHAR szDiskSpinDownMinValue[] = {'3', 0};
+
+ WCHAR tmp[20];
+ /*
+ * Erstelle die Registry-struktur und Daten, welche dafür erforderlich ist damit diese
Tests funktionieren
+ */
+
+ /*
+ * User
+ */
+ err = RegOpenCurrentUser(KEY_ALL_ACCESS,&hUser);
+ ok(err == ERROR_SUCCESS,"Öffnen des Aktuellen Users Fehlgeschlagen\n");
+ if (err == ERROR_SUCCESS)
+ {
+ err = RegCreateKey(hUser,szUserPowrCfgKey,&hKeyPowrCfg);
+ ok(err == ERROR_SUCCESS,"Create Key UserPowrCfg failed with error
%i\n",(UINT)err);
+ ok(hKeyPowrCfg != NULL,"Erstellen des Eintrages Powercfg
fehlgeschalgen\n");
+ err = RegSetValueExW(hKeyPowrCfg,szCurrentPowerPolicy,(DWORD)NULL,REG_SZ,(CONST
BYTE *)szcpp,strlenW(szcpp)*sizeof(WCHAR));
+ ok(err == ERROR_SUCCESS,"Set Value CurrentPowerPolicy failed with error
%i\n",(UINT)err);
+ err = RegCreateKey(hKeyPowrCfg,szGlobalPowerPolicy,&hKeyGlobalPowrPol);
+ ok(err == ERROR_SUCCESS,"Create Key GlobalPowerPolicy failed with error
%i\n",(UINT)err);
+ gupp.Revision = 1;
+ gupp.PowerButtonAc.Action = PowerActionNone;
+ gupp.PowerButtonDc.Action = PowerActionNone;
+ gupp.SleepButtonAc.Action = PowerActionNone;
+ gupp.SleepButtonDc.Action = PowerActionNone;
+ gupp.LidCloseAc.Action = PowerActionNone;
+ gupp.LidCloseDc.Action = PowerActionNone;
+ for (i=0; i<NUM_DISCHARGE_POLICIES; i++)
+ {
+ gupp.DischargePolicy[0].Enable=FALSE;
+ }
+
+ err = RegSetValueExW(hKeyGlobalPowrPol,szPolicies,(DWORD)NULL,REG_BINARY,(CONST
BYTE *)&gupp,sizeof(GLOBAL_USER_POWER_POLICY));
+ ok(err == ERROR_SUCCESS,"Set Value GlobalPowrPol failed with error
%i\n",(UINT)err);
+ err = RegCloseKey(hKeyGlobalPowrPol);
+ ok(err == ERROR_SUCCESS,"Close Key GlobalPowrPol failed with error
%i\n",(UINT)err);
+ err = RegCreateKey(hKeyPowrCfg,szPowerPolicies,&hKeyPowerPolicies);
+ ok(err == ERROR_SUCCESS,"Create Key PowerPolicies failed with error
%i\n",(UINT)err);
+
+ upp.Revision = 1;
+ upp.IdleAc.Action = PowerActionNone;
+ upp.IdleDc.Action = PowerActionNone;
+ upp.MaxSleepAc = PowerSystemWorking;
+ upp.MaxSleepDc = PowerSystemWorking;
+ upp.VideoTimeoutAc = 0;
+ upp.VideoTimeoutDc = 0;
+ upp.SpindownTimeoutAc = 0;
+ upp.SpindownTimeoutDc = 0;
+
+ for (i = 0; i<6; i++)
+ {
+ _itow(i,tmp,10);
+ err = RegCreateKey(hKeyPowerPolicies,tmp,&hKeytmp);
+ ok(err == ERROR_SUCCESS,"Create Key PowerPolicies(%i) failed with error
%i\n",i,(UINT)err);
+ szName[5]++;
+ szDescription[12]++;
+ err = RegSetValueExW(hKeytmp,szcName,(DWORD)NULL,REG_SZ,(CONST BYTE
*)szName,strlenW(szName)*sizeof(WCHAR));
+ err = RegSetValueExW(hKeytmp,szcDescription,(DWORD)NULL,REG_SZ,(CONST BYTE
*)szDescription,strlenW(szDescription)*sizeof(WCHAR));
+ err = RegSetValueExW(hKeytmp,szPolicies,(DWORD)NULL,REG_BINARY,(CONST BYTE
*)&upp,sizeof(USER_POWER_POLICY));
+ err = RegCloseKey(hKeytmp);
+ }
+ err = RegCloseKey(hKeyPowerPolicies);
+ err = RegCloseKey(hKeyPowrCfg);
+ err = RegCloseKey(hUser);
+ }
+
+ /*
+ * Mach
+ */
+ err = RegCreateKey(HKEY_LOCAL_MACHINE,szMachPowrCfgKey,&hKeyPowrCfg);
+ ok(err == ERROR_SUCCESS,"Create Key MachPowrCfgKey failed with error
%i\n",(UINT)err);
+ err = RegSetValueExW(hKeyPowrCfg,szLastID,(DWORD)NULL,REG_SZ,(CONST BYTE
*)szLastIDValue,strlenW(szLastIDValue)*sizeof(WCHAR));
+ err = RegSetValueExW(hKeyPowrCfg,szDiskSpinDownMax,(DWORD)NULL,REG_SZ,(CONST BYTE
*)szDiskSpinDownMaxValue,strlenW(szDiskSpinDownMaxValue)*sizeof(WCHAR));
+ err = RegSetValueExW(hKeyPowrCfg,szDiskSpinDownMin,(DWORD)NULL,REG_SZ,(CONST BYTE
*)szDiskSpinDownMinValue,strlenW(szDiskSpinDownMinValue)*sizeof(WCHAR));
+
+ err = RegCreateKey(hKeyPowrCfg,szGlobalPowerPolicy,&hKeyGlobalPowrPol);
+ ok(err == ERROR_SUCCESS,"Create Key Mach GlobalPowerPolicy failed with error
%i\n",(UINT)err);
+ gmpp.Revision = 1;
+ gmpp.LidOpenWakeAc = PowerSystemWorking;
+ gmpp.LidOpenWakeDc = PowerSystemWorking;
+ gmpp.BroadcastCapacityResolution=0;
+
+ err = RegSetValueExW(hKeyGlobalPowrPol,szPolicies,(DWORD)NULL,REG_BINARY,(CONST BYTE
*)&gmpp,sizeof(GLOBAL_MACHINE_POWER_POLICY));
+
+ err = RegCloseKey(hKeyGlobalPowrPol);
+ err = RegCreateKey(hKeyPowrCfg,szPowerPolicies,&hKeyPowerPolicies);
+ ok(err == ERROR_SUCCESS,"Create Key Mach PowerPolicies failed with error
%i\n",(UINT)err);
+
+ mpp.Revision = 1;
+ mpp.MinSleepAc = PowerSystemWorking;
+ mpp.MinSleepDc = PowerSystemWorking;
+ mpp.ReducedLatencySleepAc = PowerSystemWorking;
+ mpp.ReducedLatencySleepDc = PowerSystemWorking;
+ mpp.OverThrottledAc.Action = PowerActionNone;
+ mpp.OverThrottledDc.Action = PowerActionNone;
+ mpp.DozeS4TimeoutAc=0;
+ mpp.DozeS4TimeoutDc=0;
+
+ for (i = 0; i<6; i++)
+ {
+ _itow(i,tmp,10);
+ err = RegCreateKey(hKeyPowerPolicies,tmp,&hKeytmp);
+ ok(err == ERROR_SUCCESS,"Create Key Mach PowerPolicies(%i) failed with error
%i\n",(UINT)i,(UINT)err);
+ err = RegSetValueExW(hKeytmp,szPolicies,(DWORD)NULL,REG_BINARY,(CONST BYTE
*)&mpp,sizeof(MACHINE_POWER_POLICY));
+ err = RegCloseKey(hKeytmp);
+ }
+ err = RegCloseKey(hKeyPowerPolicies);
+
+ err = RegCreateKey(hKeyPowrCfg,szProcessorPolicies,&hKeyPowerPolicies);
+ ok(err == ERROR_SUCCESS,"Create Key Mach ProcessorPolicies failed with error
%i\n",(UINT)err);
+
+ mppp.Revision = 1;
+ mppp.ProcessorPolicyAc.Revision = 1;
+ mppp.ProcessorPolicyDc.Revision = 1;
+
+ for (i = 0; i<6; i++)
+ {
+ _itow(i,tmp,10);
+ err = RegCreateKey(hKeyPowerPolicies,tmp,&hKeytmp);
+ ok(err == ERROR_SUCCESS,"Create Key Mach ProcessorPolicies(%i) failed with
error %i\n",i,(UINT)err);
+ err = RegSetValueExW(hKeytmp,szPolicies,(DWORD)NULL,REG_BINARY,(CONST BYTE
*)&mppp,sizeof(MACHINE_PROCESSOR_POWER_POLICY));
+ err = RegCloseKey(hKeytmp);
+ }
+ err = RegCloseKey(hKeyPowerPolicies);
+
+ err = RegCloseKey(hKeyPowrCfg);
+
+ err = GetCurrentPowerPolicies(&gpp,&pp);
+ ok(err, "function was expected to succeed error
%i\n",(UINT)GetLastError());
+
+ err = ValidatePowerPolicies(&gpp,&pp);
+ ok(err, "function was expected to succeed error
%i\n",(UINT)GetLastError());
+
+ /*
+ [HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Controls
Folder\PowerCfg\GlobalPowerPolicy]
+ "CursorProperties"=...
+
+ */
+
+}
Propchange: trunk/reactos/regtests/winetests/powrprof/pwrprof.c
------------------------------------------------------------------------------
svn:eol-style = native
Added: trunk/reactos/regtests/winetests/powrprof/testlist.c
URL:
http://svn.reactos.ru/svn/reactos/trunk/reactos/regtests/winetests/powrprof…
==============================================================================
--- trunk/reactos/regtests/winetests/powrprof/testlist.c (added)
+++ trunk/reactos/regtests/winetests/powrprof/testlist.c Thu Jun 15 18:50:42 2006
@@ -1,0 +1,27 @@
+/* Automatically generated file; DO NOT EDIT!! */
+
+/* stdarg.h is needed for Winelib */
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include "windef.h"
+#include "winbase.h"
+
+struct test
+{
+ const char *name;
+ void (*func)(void);
+};
+
+extern void func_power(void);
+extern void func_ros_init(void);
+
+const struct test winetest_testlist[] =
+{
+ { "power", func_power },
+ { "ros_init", func_ros_init },
+ { 0, 0 }
+};
+
+#define WINETEST_WANT_MAIN
+#include "wine/test.h"
Propchange: trunk/reactos/regtests/winetests/powrprof/testlist.c
------------------------------------------------------------------------------
svn:eol-style = native