pwrprof.c

winNT技术操作系统,国外开放的原代码和LIUX一样

   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());