/**
  * Checks for allowed characters
  * @see Zend\Validator\Barcode.AbstractAdapter::checkChars()
  */
 public function hasValidCharacters($value)
 {
     if (strpbrk($value, 'ABCD')) {
         $first = $value[0];
         if (!strpbrk($first, 'ABCD')) {
             // Missing start char
             return false;
         }
         $last = substr($value, -1, 1);
         if (!strpbrk($last, 'ABCD')) {
             // Missing stop char
             return false;
         }
         $value = substr($value, 1, -1);
     } elseif (strpbrk($value, 'TN*E')) {
         $first = $value[0];
         if (!strpbrk($first, 'TN*E')) {
             // Missing start char
             return false;
         }
         $last = substr($value, -1, 1);
         if (!strpbrk($last, 'TN*E')) {
             // Missing stop char
             return false;
         }
         $value = substr($value, 1, -1);
     }
     $chars = $this->getCharacters();
     $this->setCharacters('0123456789-$:/.+');
     $result = parent::hasValidCharacters($value);
     $this->setCharacters($chars);
     return $result;
 }

    /**
     * Checks for allowed characters
     * @see Zend\Validator\Barcode.AbstractAdapter::checkChars()
     */
    public function checkChars($value)
    {
        $first = $value[0];
        if (strpbrk($value, 'ABCD') !== false) {
            $first = $value[0];
            if (strpbrk($first, 'ABCD') === false) {
                // Missing start char
                return false;
            }

            $last = substr($value, -1, 1);
            if (strpbrk($last, 'ABCD') === false) {
                // Missing stop char
                return false;
            }

            $value = substr($value, 1, -1);
        }

        $chars             = $this->_characters;
        $this->_characters = '0123456789-$:/.+';
        $result            = parent::checkChars($value);
        $this->_characters = $chars;
        return $result;
    }

 /**
  * @param $element
  *
  * @return Page
  */
 public function select($element)
 {
     $pageClass = $this->getPageClass($element);
     $element = $this->item($element);
     $this->debug("Clicking element {$element} (" . $element->getId() . ")\n");
     $element->click();
     return $this->driver->pageFactoryCreate($pageClass);
 }

 public function testAuthenticationFails()
 {
     $email = '[email protected]';
     $password = 12345678;
     $this->auth->expects($this->once())->method('getAdapter')->will($this->returnValue($this->adapter));
     $this->auth->expects($this->once())->method('authenticate')->will($this->returnValue($this->getFailureResult()));
     $result = $this->authenticator->authenticate($email, $password);
     // Ensures identity and credential were actually set on the mock adapter
     $this->assertEquals($email, $this->adapter->getIdentity());
     $this->assertEquals($password, $this->adapter->getCredential());
     $this->assertFalse($result->isValid());
 }

 /**
  * {@inheritdoc}
  */
 protected function doFetch(array $ids)
 {
     $values = array();
     $now = time();
     foreach ($ids as $id) {
         $file = $this->getFile($id);
         if (!file_exists($file) || !($h = @fopen($file, 'rb'))) {
             continue;
         }
         if ($now >= (int) ($expiresAt = fgets($h))) {
             fclose($h);
             if (isset($expiresAt[0])) {
                 @unlink($file);
             }
         } else {
             $i = rawurldecode(rtrim(fgets($h)));
             $value = stream_get_contents($h);
             fclose($h);
             if ($i === $id) {
                 $values[$id] = parent::unserialize($value);
             }
         }
     }
     return $values;
 }

 /**
  * Set dimensions
  *
  * @param  array  $dimensions
  * @param  string $unit
  *
  * @return void
  */
 public function setDimensions(array $dimensions, $unit = null)
 {
     parent::setDimensions($dimensions, $unit);
     if (null !== $unit && ($unit == 'IN' || $unit == 'CM')) {
         $this->dimensions['UnitOfMeasurement'] = $unit;
     }
 }

 /**
  * Constructor
  *
  * Instantiate the cache db object
  *
  * @param  string  $db
  * @param  int     $lifetime
  * @param  string  $table
  * @param  boolean $pdo
  * @throws Exception
  * @return Sqlite
  */
 public function __construct($db, $lifetime = 0, $table = 'pop_cache', $pdo = false)
 {
     parent::__construct($lifetime);
     $this->setDb($db);
     $pdoDrivers = class_exists('Pdo', false) ? \PDO::getAvailableDrivers() : [];
     if (!class_exists('Sqlite3', false) && !in_array('sqlite', $pdoDrivers)) {
         throw new Exception('Error: SQLite is not available.');
     } else {
         if ($pdo && !in_array('sqlite', $pdoDrivers)) {
             $pdo = false;
         } else {
             if (!$pdo && !class_exists('Sqlite3', false)) {
                 $pdo = true;
             }
         }
     }
     if ($pdo) {
         $this->sqlite = new \PDO('sqlite:' . $this->db);
         $this->isPdo = true;
     } else {
         $this->sqlite = new \SQLite3($this->db);
     }
     if (null !== $table) {
         $this->setTable($table);
     }
 }

 /**
  * Constructor
  *
  * Instantiate the APC cache object
  *
  * @param  int $lifetime
  * @throws Exception
  * @return Apc
  */
 public function __construct($lifetime = 0)
 {
     parent::__construct($lifetime);
     if (!function_exists('apc_cache_info')) {
         throw new Exception('Error: APC is not available.');
     }
     $this->info = apc_cache_info();
 }

 /**
  * Overrides parent checkLength
  *
  * @param string $value Value
  * @return boolean
  */
 public function checkLength($value)
 {
     if (strlen($value) != 8) {
         $this->setCheck(false);
     } else {
         $this->setCheck(true);
     }
     return parent::checkLength($value);
 }

 /**
  * Overrides parent checkLength
  *
  * @param string $value Value
  * @return bool
  */
 public function hasValidLength($value)
 {
     if (strlen($value) == 7) {
         $this->useChecksum(false);
     } else {
         $this->useChecksum(true);
     }
     return parent::hasValidLength($value);
 }

 /**
  * Validates the checksum
  *
  * @param  string $value The barcode to check the checksum for
  * @return bool
  */
 public function hasValidChecksum($value)
 {
     if (strlen($value) == 8) {
         $this->setChecksum('issn');
     } else {
         $this->setChecksum('gtin');
     }
     return parent::hasValidChecksum($value);
 }

 /**
  * Validates the checksum
  *
  * @param  string $value The barcode to check the checksum for
  * @return boolean
  */
 public function checksum($value)
 {
     if (strlen($value) == 8) {
         $this->_checksum = '_issn';
     } else {
         $this->_checksum = '_gtin';
     }
     return parent::checksum($value);
 }

 /**
  * {@inheritdoc}
  */
 public function setOption($key, $value)
 {
     switch ($key) {
         case 'limit':
             $value = (int) $value;
             $this->limit = $value;
             return true;
     }
     return parent::setOption($key, $value);
 }

 /**
  * Constructor
  *
  * Instantiate the cache session object
  *
  * @param  int $lifetime
  * @return Session
  */
 public function __construct($lifetime = 0)
 {
     parent::__construct($lifetime);
     if (session_id() == '') {
         session_start();
     }
     if (!isset($_SESSION['_POP_CACHE'])) {
         $_SESSION['_POP_CACHE'] = [];
     }
 }

 public static function init(array $params)
 {
     parent::init($params);
     $redis = new \Redis();
     if (array_key_exists('socket', $params)) {
         $redis->connect($params['socket']);
     } else {
         $redis->connect($params['host'], $params['port']);
     }
     $redis->select($params['index']);
     self::$redis = $redis;
 }

 /**
  * Constructor
  *
  * Instantiate the memcache cache object
  *
  * @param  int    $lifetime
  * @param  string $host
  * @param  int    $port
  * @throws Exception
  * @return Redis
  */
 public function __construct($lifetime = 0, $host = 'localhost', $port = 6379)
 {
     parent::__construct($lifetime);
     if (!class_exists('Redis', false)) {
         throw new Exception('Error: Redis is not available.');
     }
     $this->redis = new \Redis();
     if (!$this->redis->connect($host, (int) $port)) {
         throw new Exception('Error: Unable to connect to the memcached server.');
     }
     $this->version = $this->redis->info()['redis_version'];
 }

 /**
  * Allows start and stop tag within checked chars
  *
  * @param  string $value The barcode to check for allowed characters
  * @return boolean
  */
 public function hasValidCharacters($value)
 {
     if ($value[0] == '(') {
         $value = substr($value, 1);
         if ($value[strlen($value) - 1] == ')') {
             $value = substr($value, 0, -1);
         } else {
             return false;
         }
     }
     return parent::hasValidCharacters($value);
 }

 /**
  * Constructor
  *
  * Instantiate the memcache cache object
  *
  * @param  int    $lifetime
  * @param  string $host
  * @param  int    $port
  * @throws Exception
  * @return Memcache
  */
 public function __construct($lifetime = 0, $host = 'localhost', $port = 11211)
 {
     parent::__construct($lifetime);
     if (!class_exists('Memcache', false)) {
         throw new Exception('Error: Memcache is not available.');
     }
     $this->memcache = new \Memcache();
     if (!$this->memcache->connect($host, (int) $port)) {
         throw new Exception('Error: Unable to connect to the memcache server.');
     }
     $this->version = $this->memcache->getVersion();
 }

 /**
  * Constructor
  *
  * Instantiate the memcached cache object
  *
  * @param  int    $lifetime
  * @param  string $host
  * @param  int    $port
  * @param  int    $weight
  * @throws Exception
  * @return Memcached
  */
 public function __construct($lifetime = 0, $host = 'localhost', $port = 11211, $weight = 1)
 {
     parent::__construct($lifetime);
     if (!class_exists('Memcached', false)) {
         throw new Exception('Error: Memcached is not available.');
     }
     $this->memcached = new \Memcached();
     $this->addServer($host, $port, $weight);
     $version = $this->memcached->getVersion();
     if (isset($version[$host . ':' . $port])) {
         $this->version = $version[$host . ':' . $port];
     }
 }

 public function getItem($key, &$success = null, $queue = true)
 {
     //check to see if it's already been cached in the class
     $value = parent::getItem($key, $success, $queue);
     if ($success === true) {
         return $value;
     } else {
         $fileName = $this->getFileName($key);
         if ($queue === true && !file_exists($fileName)) {
             if ($this->isQueueInProgress($fileName) === true) {
                 //anonymous function to test if we should continue to wait
                 $condition = function () use($fileName) {
                     return !file_exists($fileName);
                 };
                 $wait = $this->wait($condition);
                 if ($wait === false) {
                     $this->clearQueue($key);
                     $success = false;
                     return null;
                 } else {
                     $success = true;
                     return $this->readFromFile($fileName);
                 }
             } else {
                 $this->queue($fileName);
                 $success = false;
                 return null;
             }
         } else {
             $ttl = $this->getTtl($key);
             if ($ttl < time() && $this->isReCacheInProgress($fileName) === false) {
                 //set the queue
                 $this->reCache($fileName);
                 $success = false;
                 return null;
             } else {
                 $success = true;
                 $value = $this->readFromFile($fileName);
                 return $value;
             }
         }
     }
 }