/**
  * @params include:
  *   - objectCache : Name of an object cache registered in $wgObjectCaches.
  *                   This defaults to the one specified by $wgMainCacheType.
  *   - cacheTTL    : Seconds to cache the aggregate data before regenerating.
  * @param array $params
  */
 protected function __construct(array $params)
 {
     parent::__construct($params);
     $this->cache = isset($params['objectCache']) ? wfGetCache($params['objectCache']) : wfGetMainCache();
     $this->cacheTTL = isset($params['cacheTTL']) ? $params['cacheTTL'] : 180;
     // 3 min
 }

 /**
  * Prepares the environment before running a test.
  */
 protected function setUp()
 {
     global $wgMemc;
     parent::setUp();
     $this->user = User::newFromName("someReviewer");
     $wgMemc = wfGetCache(CACHE_DB);
 }

 /**
  * Get contents of a javascript file for inline use.
  *
  * Roughly based MediaWiki core methods:
  * - ResourceLoader::filter()
  * - ResourceLoaderFileModule::readScriptFiles()
  *
  * @param string $name Path to file relative to /modules/inline/
  * @return string Minified script
  * @throws Exception If file doesn't exist
  */
 protected static function getInlineScript($name)
 {
     // Get file
     $filePath = __DIR__ . '/../../modules/inline/' . $name;
     if (!file_exists($filePath)) {
         throw new Exception(__METHOD__ . ": file not found: \"{$filePath}\"");
     }
     $contents = file_get_contents($filePath);
     // Try minified from cache
     $key = wfMemcKey('centralauth', 'minify-js', md5($contents));
     $cache = wfGetCache(CACHE_ANYTHING);
     $cacheEntry = $cache->get($key);
     if (is_string($cacheEntry)) {
         return $cacheEntry;
     }
     // Compute new value
     $result = '';
     try {
         $result = JavaScriptMinifier::minify($contents) . "\n/* cache key: {$key} */";
         $cache->set($key, $result);
     } catch (Exception $e) {
         MWExceptionHandler::logException($e);
         wfDebugLog('CentralAuth', __METHOD__ . ": minification failed for {$name}: {$e}");
         $result = ResourceLoader::formatException($e) . "\n" . $contents;
     }
     return $result;
 }

 /**
  * @since 1.21
  * @deprecated 1.25 Construct a SiteStore instance directly instead.
  *
  * @param ORMTable|null $sitesTable
  * @param BagOStuff|null $cache
  *
  * @return SiteStore
  */
 public static function newInstance(ORMTable $sitesTable = null, BagOStuff $cache = null)
 {
     if ($cache === null) {
         $cache = wfGetCache(wfIsHHVM() ? CACHE_ACCEL : CACHE_ANYTHING);
     }
     $siteStore = new DBSiteStore();
     return new static($siteStore, $cache);
 }

 /**
  * Constructor.
  * @param string $title
  * @param integer $revision
  * @param ObjectCache $cache: (optional) cache client.
  * @param Http $http: (optional) HTTP client.
  */
 function __construct($title, $revision, $cache = NULL, $http = NULL)
 {
     global $wgEventLoggingDBname;
     $this->title = $title;
     $this->revision = $revision;
     $this->cache = $cache ?: wfGetCache(CACHE_ANYTHING);
     $this->http = $http ?: new Http();
     $this->key = "schema:{$wgEventLoggingDBname}:{$title}:{$revision}";
 }

 function __construct($memCached, $useDB, $expiry)
 {
     if (!$memCached) {
         $memCached = wfGetCache(CACHE_NONE);
     }
     $this->mMemc = $memCached;
     $this->mDisable = !$useDB;
     $this->mExpiry = $expiry;
 }

 protected function setUp()
 {
     parent::setUp();
     global $wgHooks;
     $this->setMwGlobals(array('wgHooks' => $wgHooks, 'wgTranslateTranslationServices' => array()));
     $wgHooks['TranslatePostInitGroups'] = array(array($this, 'getTestGroups'));
     $mg = MessageGroups::singleton();
     $mg->setCache(wfGetCache('hash'));
     $mg->recache();
 }

	function run() {
		global $wgUser;

		// Initialization
		$title = $this->title;
		// Other stuff
		$user    = $this->getUser();
		$summary = $this->getSummary();
		$base    = $this->getBase();

		PageTranslationHooks::$allowTargetEdit = true;
		$oldUser = $wgUser;
		$wgUser = $user;

		$error = '';
		$article = new Article( $title, 0 );
		$ok = $article->doDeleteArticle( $summary, false, 0, true, $error );
		if ( !$ok ) {
			$logger = new LogPage( 'pagetranslation' );
			$params = array(
				'user' => $this->getPerformer(),
				'target' => $base,
				'error' => base64_encode( serialize( $ok ) ), // This is getting ridiculous
			);
			$doer = User::newFromName( $this->getPerformer() );
			$msg = $this->getFull() ? 'deletefnok' : 'deletelnok';
			$logger->addEntry( $msg, $title, null, array( serialize( $params ) ), $doer );
		}

		PageTranslationHooks::$allowTargetEdit = false;

		$cache = wfGetCache( CACHE_DB );
		$pages = (array) $cache->get( wfMemcKey( 'pt-base', $base ) );
		$lastitem = array_pop( $pages );
		if ( $title->getPrefixedText() === $lastitem ) {
			$cache->delete( wfMemcKey( 'pt-base', $base ) );
			$logger = new LogPage( 'pagetranslation' );
			$params = array( 'user' => $this->getPerformer() );
			$doer = User::newFromName( $this->getPerformer() );
			$msg = $this->getFull() ? 'deletefok' : 'deletelok';
			$logger->addEntry( $msg, Title::newFromText( $base ), null, array( serialize( $params ) ), $doer );

			$tpage = TranslatablePage::newFromTitle( $title );
			$tpage->getTranslationPercentages( true );
			foreach ( $tpage->getTranslationPages() as $page ) {
				$page->invalidateCache();
			}
			$title->invalidateCache();
		}

		$wgUser = $oldUser;

		return true;
	}

 protected function setUp()
 {
     parent::setUp();
     global $wgHooks;
     $this->setMwGlobals(array('wgHooks' => $wgHooks, 'wgGroupPermissions' => array(), 'wgTranslateMessageNamespaces' => array(NS_MEDIAWIKI)));
     $wgHooks['TranslatePostInitGroups'] = array(array($this, 'getTestGroups'));
     $mg = MessageGroups::singleton();
     $mg->setCache(wfGetCache('hash'));
     $mg->recache();
     MessageIndex::setInstance(new HashMessageIndex());
     MessageIndex::singleton()->rebuild();
 }

 public function setUp()
 {
     parent::setUp();
     global $wgHooks;
     $this->setMwGlobals(array('wgHooks' => $wgHooks, 'wgTranslateTranslationServices' => array(), 'wgTranslateDelayedMessageIndexRebuild' => false));
     $wgHooks['TranslatePostInitGroups'] = array();
     $mg = MessageGroups::singleton();
     $mg->setCache(wfGetCache('hash'));
     $mg->recache();
     MessageIndex::setInstance(new HashMessageIndex());
     MessageIndex::singleton()->rebuild();
 }

 protected function setUp()
 {
     parent::setUp();
     global $wgHooks;
     $this->setMwGlobals(array('wgHooks' => $wgHooks, 'wgTranslateTranslationServices' => array(), 'wgTranslateCacheDirectory' => $this->getNewTempDirectory()));
     $wgHooks['TranslatePostInitGroups'] = array();
     $mg = MessageGroups::singleton();
     $mg->setCache(wfGetCache('hash'));
     $mg->recache();
     MessageIndex::setInstance(new HashMessageIndex());
     MessageIndex::singleton()->rebuild();
 }

 /**
  * Implement a rudimentary rate limiting system,
  * we can't use User::pingLImiter() because stewards
  * have the "noratelimit" userright
  *
  * Hardcoded to allow 1 merge per 60 seconds
  *
  * @return bool true if we should let the user proceed
  */
 private function checkRateLimit()
 {
     $cache = wfGetCache(CACHE_ANYTHING);
     $key = 'centralauth:usermerge:' . md5($this->getUser()->getName());
     $found = $cache->get($key);
     if ($found === false) {
         $cache->set($key, true, 60);
         return true;
     } else {
         return false;
     }
 }

 protected function setUp()
 {
     parent::setUp();
     $conf = array(__DIR__ . '/data/ParentGroups.yaml');
     global $wgHooks;
     $this->setMwGlobals(array('wgHooks' => $wgHooks, 'wgTranslateGroupFiles' => $conf, 'wgTranslateTranslationServices' => array()));
     $wgHooks['TranslatePostInitGroups'] = array('MessageGroups::getConfiguredGroups');
     $mg = MessageGroups::singleton();
     $mg->setCache(wfGetCache('hash'));
     $mg->recache();
     MessageIndex::setInstance(new HashMessageIndex());
     MessageIndex::singleton()->rebuild();
 }

 protected function setUp()
 {
     parent::setUp();
     global $wgHooks, $wgTranslateTranslationServices, $wgTranslateTestTTMServer;
     $this->setMwGlobals(array('wgHooks' => $wgHooks, 'wgTranslateTranslationServices' => array()));
     $wgTranslateTranslationServices['TTMServer'] = $wgTranslateTestTTMServer;
     $wgHooks['TranslatePostInitGroups'] = array(array($this, 'addGroups'));
     $mg = MessageGroups::singleton();
     $mg->setCache(wfGetCache('hash'));
     $mg->recache();
     MessageIndex::setInstance(new HashMessageIndex());
     MessageIndex::singleton()->rebuild();
 }

 function __construct()
 {
     $this->cache = wfGetCache(CACHE_ANYTHING);
     // if (HuijiPrefix::hasPrefix($prefix)){
     // 	$this->mPrefix = $prefix;
     // } else {
     // 	$this->mPrefix = '';
     // }
     // $this->cache = wfGetCache( CACHE_ANYTHING );
     // $this->loadFromRow();
     // $siteCache = self::getSiteCache();
     // $siteCache->set($this->mPrefix, $this);
 }

 protected function setUp()
 {
     parent::setUp();
     global $wgHooks;
     $this->setMwGlobals(array('wgHooks' => $wgHooks, 'wgEnablePageTranslation' => true, 'wgTranslateTranslationServices' => array()));
     TranslateHooks::setupTranslate();
     $wgHooks['TranslatePostInitGroups'] = array('MessageGroups::getTranslatablePages');
     $mg = MessageGroups::singleton();
     $mg->setCache(wfGetCache('hash'));
     $mg->recache();
     MessageIndex::setInstance(new HashMessageIndex());
     MessageIndex::singleton()->rebuild();
 }

 public static function updateCache()
 {
     global $wgFlaggedRevsStatsAge;
     $rNamespaces = FlaggedRevs::getReviewNamespaces();
     if (empty($rNamespaces)) {
         return;
         // no SQL errors please :)
     }
     // Set key to limit duplicate updates...
     $dbCache = wfGetCache(CACHE_DB);
     $keySQL = wfMemcKey('flaggedrevs', 'statsUpdating');
     $dbCache->set($keySQL, '1', $wgFlaggedRevsStatsAge);
     // Get total, reviewed, and synced page count for each namespace
     list($ns_total, $ns_reviewed, $ns_synced) = self::getPerNamespaceTotals();
     // Getting mean pending edit time
     // @TODO: percentiles?
     $avePET = self::getMeanPendingEditTime();
     # Get wait (till review) time samples for anon edits...
     $reviewData = self::getEditReviewTimes($dbCache, 'anons');
     $dbw = wfGetDB(DB_MASTER);
     // The timestamp to identify this whole batch of data
     $encDataTimestamp = $dbw->timestamp();
     $dataSet = array();
     $dataSet[] = array('frs_stat_key' => 'reviewLag-sampleStartTimestamp', 'frs_stat_val' => $reviewData['sampleStartTS'], 'frs_timestamp' => $encDataTimestamp);
     $dataSet[] = array('frs_stat_key' => 'reviewLag-sampleEndTimestamp', 'frs_stat_val' => $reviewData['sampleEndTS'], 'frs_timestamp' => $encDataTimestamp);
     // All-namespace percentiles...
     foreach ($reviewData['percTable'] as $percentile => $seconds) {
         $dataSet[] = array('frs_stat_key' => 'reviewLag-percentile:' . (int) $percentile, 'frs_stat_val' => $seconds, 'frs_timestamp' => $encDataTimestamp);
     }
     // Sample size...
     $dataSet[] = array('frs_stat_key' => 'reviewLag-sampleSize', 'frs_stat_val' => $reviewData['sampleSize'], 'frs_timestamp' => $encDataTimestamp);
     // All-namespace ave/med review lag & ave pending lag stats...
     $dataSet[] = array('frs_stat_key' => 'reviewLag-average', 'frs_stat_val' => $reviewData['average'], 'frs_timestamp' => $encDataTimestamp);
     $dataSet[] = array('frs_stat_key' => 'reviewLag-median', 'frs_stat_val' => $reviewData['median'], 'frs_timestamp' => $encDataTimestamp);
     $dataSet[] = array('frs_stat_key' => 'pendingLag-average', 'frs_stat_val' => $avePET, 'frs_timestamp' => $encDataTimestamp);
     // Per-namespace total/reviewed/synced stats...
     foreach ($rNamespaces as $namespace) {
         $dataSet[] = array('frs_stat_key' => 'totalPages-NS:' . (int) $namespace, 'frs_stat_val' => isset($ns_total[$namespace]) ? $ns_total[$namespace] : 0, 'frs_timestamp' => $encDataTimestamp);
         $dataSet[] = array('frs_stat_key' => 'reviewedPages-NS:' . (int) $namespace, 'frs_stat_val' => isset($ns_reviewed[$namespace]) ? $ns_reviewed[$namespace] : 0, 'frs_timestamp' => $encDataTimestamp);
         $dataSet[] = array('frs_stat_key' => 'syncedPages-NS:' . (int) $namespace, 'frs_stat_val' => isset($ns_synced[$namespace]) ? $ns_synced[$namespace] : 0, 'frs_timestamp' => $encDataTimestamp);
     }
     // Save the data...
     $dbw->begin();
     $dbw->insert('flaggedrevs_statistics', $dataSet, __FUNCTION__, array('IGNORE'));
     $dbw->commit();
     // Stats are now up to date!
     $key = wfMemcKey('flaggedrevs', 'statsUpdated');
     $dbCache->set($key, '1', $wgFlaggedRevsStatsAge);
     $dbCache->delete($keySQL);
 }

 /**
  * @param array $params
  * @throws MWException
  */
 protected function __construct(array $params)
 {
     $this->wiki = $params['wiki'];
     $this->type = $params['type'];
     $this->claimTTL = isset($params['claimTTL']) ? $params['claimTTL'] : 0;
     $this->maxTries = isset($params['maxTries']) ? $params['maxTries'] : 3;
     if (isset($params['order']) && $params['order'] !== 'any') {
         $this->order = $params['order'];
     } else {
         $this->order = $this->optimalOrder();
     }
     if (!in_array($this->order, $this->supportedOrders())) {
         throw new MWException(__CLASS__ . " does not support '{$this->order}' order.");
     }
     $this->dupCache = wfGetCache(CACHE_ANYTHING);
     $this->aggr = isset($params['aggregator']) ? $params['aggregator'] : new JobQueueAggregatorNull(array());
 }

 function run()
 {
     // Initialization
     $title = $this->title;
     // Other stuff
     $user = $this->getUser();
     $summary = $this->getSummary();
     $base = $this->getBase();
     $doer = User::newFromName($this->getPerformer());
     PageTranslationHooks::$allowTargetEdit = true;
     $error = '';
     $wikipage = new WikiPage($title);
     $ok = $wikipage->doDeleteArticle($summary, false, 0, true, $error, $user);
     if (!$ok) {
         $params = array('target' => $base, 'error' => $ok);
         $type = $this->getFull() ? 'deletefnok' : 'deletelnok';
         $entry = new ManualLogEntry('pagetranslation', $type);
         $entry->setPerformer($doer);
         $entry->setTarget($title);
         $entry->setParameters($params);
         $logid = $entry->insert();
         $entry->publish($logid);
     }
     PageTranslationHooks::$allowTargetEdit = false;
     $cache = wfGetCache(CACHE_DB);
     $pages = (array) $cache->get(wfMemcKey('pt-base', $base));
     $lastitem = array_pop($pages);
     if ($title->getPrefixedText() === $lastitem) {
         $cache->delete(wfMemcKey('pt-base', $base));
         $type = $this->getFull() ? 'deletefok' : 'deletelok';
         $entry = new ManualLogEntry('pagetranslation', $type);
         $entry->setPerformer($doer);
         $entry->setTarget(Title::newFromText($base));
         $logid = $entry->insert();
         $entry->publish($logid);
         $tpage = TranslatablePage::newFromTitle($title);
         $tpage->getTranslationPercentages(true);
         foreach ($tpage->getTranslationPages() as $page) {
             $page->invalidateCache();
         }
         $title->invalidateCache();
     }
     return true;
 }

	/**
	 * @param $params array
	 */
	protected function __construct( array $params ) {
		$this->wiki = $params['wiki'];
		$this->type = $params['type'];
		$this->claimTTL = isset( $params['claimTTL'] ) ? $params['claimTTL'] : 0;
		$this->maxTries = isset( $params['maxTries'] ) ? $params['maxTries'] : 3;
		if ( isset( $params['order'] ) && $params['order'] !== 'any' ) {
			$this->order = $params['order'];
		} else {
			$this->order = $this->optimalOrder();
		}
		if ( !in_array( $this->order, $this->supportedOrders() ) ) {
			throw new MWException( __CLASS__ . " does not support '{$this->order}' order." );
		}
		$this->checkDelay = !empty( $params['checkDelay'] );
		if ( $this->checkDelay && !$this->supportsDelayedJobs() ) {
			throw new MWException( __CLASS__ . " does not support delayed jobs." );
		}
		$this->dupCache = wfGetCache( CACHE_ANYTHING );
	}