pwrprof.c

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

   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黵 erforderlich ist damit diese Tests funktionieren
    */

   /*
    * User
    */
   err = RegOpenCurrentUser(KEY_ALL_ACCESS,&hUser);
   ok(err == ERROR_SUCCESS,"謋fnen 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"=...

    */

}