public static function setUpBeforeClass()
 {
     $configuration = new Configuration();
     self::$selenium_test_page_path = $configuration->getSeleniumTestPagePath();
     self::$selenium_execution_context = new SeleniumExecutionContext("firefox", "file://" . self::$selenium_test_page_path, "jQuery");
     self::$selenium_driven_user = new SeleniumDrivenUser(self::$selenium_execution_context);
 }

 /**
  * Constructor
  * 
  * Inits the appropriate endpoint and httpconnector objects 
  * Sets all of the Profiles class properties
  * 
  * @param \Beanstream\Configuration $config
  */
 function __construct(Configuration $config)
 {
     //init endpoint
     $this->_endpoint = new Endpoints($config->getPlatform(), $config->getApiVersion());
     //init http connector
     $this->_connector = new HttpConnector(base64_encode($config->getMerchantId() . ':' . $config->getApiKey()));
 }

 public function run()
 {
     $config = new Configuration();
     $config->name = 'beer_of_the_day_modification_date';
     $config->value = Carbon::now()->format('Y-m-d');
     $config->save();
 }

 protected function assertConfiguration(Configuration $config, $srcDir, array $cloverXml, $jsonPath, $excludeNoStatements = false)
 {
     $this->assertEquals($srcDir, $config->getSrcDir());
     $this->assertEquals($cloverXml, $config->getCloverXmlPaths());
     $this->assertEquals($jsonPath, $config->getJsonPath());
     $this->assertEquals($excludeNoStatements, $config->isExcludeNoStatements());
 }

 public static function reminderInvoker(Folder $folder)
 {
     $configuration = new Configuration();
     //parameter to know the max gap between last parsing done on the folder.
     $invokeMinutes = $configuration->getConfiguration(ConfigurationKeys::$reminderInvokeMinutes);
     //parameter to know the max gap between notifications
     $intervalMinutes = $configuration->getConfiguration(ConfigurationKeys::$reminderIntervalMinutes);
     $invokeMinutes = intval($invokeMinutes);
     $intervalMinutes = intval($intervalMinutes);
     $parsedSinceMinutes = self::getDatesDifferenceInMinutes($folder->getLastParsedOn(), date("Y-m-d H:i:s"));
     if ($parsedSinceMinutes > 0) {
         //OK we have some minutes passed with no parsing undertook
         if ($parsedSinceMinutes > $invokeMinutes) {
             //if reminder already sent, check interval and send again
             if ($folder->getLastRemindedOn() != null) {
                 $lastRemindedSince = self::getDatesDifferenceInMinutes($folder->getLastRemindedOn(), date("Y-m-d H:i:s"));
                 if ($lastRemindedSince > $intervalMinutes) {
                     self::sendNotification($folder);
                     FolderDataStore::getInstance()->updateLastReminderDate($folder->getSeq());
                 }
             } else {
                 self::sendNotification($folder);
                 FolderDataStore::getInstance()->updateLastReminderDate($folder->getSeq());
             }
         } else {
             //time still there to remind
         }
     }
 }

 public function __construct()
 {
     parent::__construct();
     $this->opo_app_config = Configuration::load();
     $vs_external_app_config_path = $this->opo_app_config->get('external_applications');
     $this->opo_external_app_config = Configuration::load($vs_external_app_config_path);
 }

 public function testSetOptionsWithValidOptions()
 {
     $key = 'steam-api-key';
     $options = array(Configuration::STEAM_KEY => $key);
     $this->configuration->setOptions($options);
     $this->assertEquals($key, $this->configuration->getSteamKey());
 }

 public function testGetInstanceWithWrongConfiguredParameterThrowsException()
 {
     $this->setExpectedException('rg\\injektor\\InjectionException', 'Invalid argument without class typehint class: [rg\\injektor\\DICTestClassNoTypeHint] method: [__construct] argument: [two]');
     $config = new Configuration(null, '');
     $config->setClassConfig('rg\\injektor\\DICTestClassNoTypeHint', array('params' => array('one' => array('value' => 'foo'))));
     $dic = $this->getContainer($config);
     $dic->getInstanceOfClass('rg\\injektor\\DICTestClassNoTypeHint');
 }

 public function __construct(Configuration $configuration, DatabaseVersion $dbVersion, DeltaDirectory $deltaDirectory)
 {
     $this->dbName = $configuration->dbName();
     $this->dbUsername = $configuration->dbUsername();
     $this->dbPassword = $configuration->dbPassword();
     $this->dbVersion = $dbVersion;
     $this->deltaDirectory = $deltaDirectory;
 }

 public function build(Configuration $config)
 {
     $serviceConfig = $config->get(Configuration::SERVICE);
     $serviceClass = $this->getServiceClass($serviceConfig);
     $serverUrl = $this->extractParameter(AbstractServiceManager::SERVER_URL, $serviceConfig);
     $watchedServices = $this->getWatchedServices($serviceConfig);
     return new $serviceClass($serverUrl, $config->getConfigDir(), $watchedServices);
 }

 /**
  * @covers Airbrake\Configuration::verify
  */
 public function testVerify()
 {
     $this->object->set('apiKey', null);
     try {
         $this->object->verify();
     } catch (\Exception $e) {
         $this->assertInstanceOf('Airbrake\\Exception', $e);
     }
 }

 public function add($key, $value, $ns = 'conf')
 {
     $config = new Configuration();
     $config->setKey($ns . ':' . $key);
     $config->setValue($value);
     $config->save();
     $this->confTab[$ns][$key] = $value;
     unset($_SESSION['configuration']);
 }

 public function testNonDefaultValuesDefine()
 {
     $name = uniqid('name');
     $realValue = uniqid('realValue');
     $default = uniqid('value');
     $config = new Configuration([$name => $realValue]);
     $config->define($name, $default);
     $expected = $realValue;
     $this->assertEquals(constant($name), $expected, 'The parameter is not defined properly with real value');
 }

 /**
  * Test get pass phrase with use PasswordGetter system
  */
 public function testGetPassPhraseWithUsePasswordGetter()
 {
     $configuration = new Configuration('name', 'localhost', 80);
     $configuration->setUser('user');
     $passwordGetter = $this->getMockForAbstractClass('Deployer\\Server\\Password\\PasswordGetterInterface');
     $passwordGetter->expects($this->once())->method('getPassword')->with('localhost', 'user')->will($this->returnValue('some-pass-phrase'));
     $configuration->setPassPhrase($passwordGetter);
     $passPhrase = $configuration->getPassPhrase();
     $this->assertEquals('some-pass-phrase', $passPhrase, 'Pass phrases mismatch');
 }

 /**
  * Returns a writable directory for temporary files
  *
  * @return String
  * @see Configuration::setTempDirectory()
  * @throws NoTempDirectoryException
  */
 public function getTempDirectory()
 {
     if (!is_null($this->configuration->getTempDirectory())) {
         return $this->configuration->getTempDirectory();
     }
     if (is_null($this->cachedTempDirectory)) {
         $this->cachedTempDirectory = $this->findTempDirectory();
     }
     return $this->cachedTempDirectory;
 }

 public function testGlobbingSupport()
 {
     $basePath = getcwd() . DS;
     $configuration = new Configuration($this->fixture('phpunit-globbing.xml'));
     /** @var SuitePath[][] $suites */
     $suites = $configuration->getSuites();
     $this->assertEquals($basePath . 'test' . DS . 'fixtures' . DS . 'globbing-support-tests' . DS . 'some-dir', $suites["ParaTest Fixtures"][0]->getPath());
     $this->assertEquals($basePath . 'test' . DS . 'fixtures' . DS . 'globbing-support-tests' . DS . 'some-dir2', $suites["ParaTest Fixtures"][1]->getPath());
     return $suites;
 }

 /**
  * @static
  * @param $name
  * @param $value
  * @return void
  */
 public static function set($name, $value = null)
 {
     $configuration = ConfigurationPeer::retrieveByName($name);
     if (!$configuration) {
         $configuration = new Configuration();
         $configuration->setName($name);
     }
     $configuration->setValue($value);
     $configuration->save();
 }

 function getConnectionSettings()
 {
     require_once $_SERVER['DOCUMENT_ROOT'] . '/inc/conf/configuration.class.php';
     $configuration = new Configuration();
     extract($configuration->getDatabaseConnectionSettings());
     $this->host = $host;
     $this->database = $database;
     $this->username = $username;
     $this->password = $password;
 }

 /**
  * DataManager constructor.
  * @param Configuration $conf
  */
 function __construct(Configuration $conf)
 {
     $this->message = "";
     try {
         $data = new \PDO('mysql:host=' . $conf->getDbHost() . ';dbname=' . $conf->getDbName() . '', $conf->getDbUser(), $conf->getDbPass());
         $this->data_manager = new \FluentPDO($data);
         $this->data_manager->debug = false;
     } catch (\Exception $ex) {
         $this->message = "Database connection failed : " . $ex->getMessage();
     }
 }

 protected function localRelease()
 {
     $configuration = new Configuration('wakka.config.php');
     $configuration->load();
     $release = Release::UNKNOW_RELEASE;
     if (isset($configuration['yeswiki_release'])) {
         $release = $configuration['yeswiki_release'];
     }
     $release = new Release($release);
     return $release;
 }