function remove($key)
 {
     if (!ini_get('xcache.var_size')) {
         return;
     }
     return @xcache_unset($key);
 }

 public function delete($id, $tag = FALSE)
 {
     if ($tag !== FALSE) {
         Kohana::log('error', 'Cache: tags are unsupported by the Xcache driver');
         return TRUE;
     } elseif ($id !== TRUE) {
         if (xcache_isset($id)) {
             return xcache_unset($id);
         }
         return FALSE;
     } else {
         // Do the login
         $this->auth();
         $result = TRUE;
         for ($i = 0, $max = xcache_count(XC_TYPE_VAR); $i < $max; $i++) {
             if (xcache_clear_cache(XC_TYPE_VAR, $i) !== NULL) {
                 $result = FALSE;
                 break;
             }
         }
         // Undo the login
         $this->auth(TRUE);
         return $result;
     }
     return TRUE;
 }

function xp_unset($var)
{
    if (XCACHE_ENABLED) {
        xcache_unset(XCACHE_PREFIX . $var);
    }
    unlink("./cache/" . XCACHE_PREFIX . $var);
}

 function clean($basedir, $initdir = false, $filename = false)
 {
     if (strlen($filename)) {
         $basedir_version = xcache_get($this->sid . $basedir);
         if ($basedir_version === null) {
             return true;
         }
         if ($initdir !== false) {
             $initdir_version = xcache_get($basedir_version . "|" . $initdir);
             if ($initdir_version === null) {
                 return true;
             }
         } else {
             $initdir_version = "";
         }
         xcache_unset($basedir_version . "|" . $initdir_version . "|" . $filename);
     } else {
         if (strlen($initdir)) {
             $basedir_version = xcache_get($this->sid . $basedir);
             if ($basedir_version === null) {
                 return true;
             }
             xcache_unset($basedir_version . "|" . $initdir);
         } else {
             xcache_unset($this->sid . $basedir);
         }
     }
     return true;
 }

 /**
  * @param string $key
  * @return boolean
  */
 public function delete($key)
 {
     if (!xcache_isset($key)) {
         return TRUE;
     }
     return xcache_unset($key);
 }

 /**
  * Check for extension availability and perform cleanup.
  */
 protected function setUp()
 {
     if (!extension_loaded('xcache')) {
         $this->markTestSkipped('XCache extension not available.');
     }
     xcache_unset('test');
 }

 /**
  * Delete cache from shared memory
  *
  * @param  string $sKey - file name
  * @return result of the operation
  */
 function delData($sKey)
 {
     if (!xcache_isset($sKey)) {
         return true;
     }
     return xcache_unset($sKey);
 }

 /**
  */
 function del($name)
 {
     if (!$this->is_ready()) {
         return null;
     }
     return xcache_unset($name);
 }

 /**
  * Destroy a session
  *
  * @param   integer  $session_id  The session ID being destroyed
  *
  * @return  boolean  True on success, false otherwise
  *
  * @since   __DEPLOY_VERSION__
  */
 public function destroy($session_id)
 {
     if (!xcache_isset($this->prefix . $session_id)) {
         return true;
     }
     return xcache_unset($this->prefix . $session_id);
 }

 public function delete($key)
 {
     if (!$key) {
         return false;
     }
     return xcache_unset($key);
 }

function cs_cache_delete($name, $ttl = 0)
{
    $token = empty($ttl) ? $name : 'ttl_' . $name;
    if (xcache_isset($token)) {
        xcache_unset($token);
    }
}

 /**
  * Remove a cached data entry by id and group
  *
  * @access	public
  * @param	string	$id		The cache data id
  * @param	string	$group	The cache data group
  * @return	boolean	True on success, false otherwise
  * @since	1.5
  */
 function remove($id, $group)
 {
     $cache_id = $this->_getCacheId($id, $group);
     if (!xcache_isset($cache_id)) {
         return true;
     }
     return xcache_unset($cache_id);
 }

 /**
  * (Plug-in replacement for memcache API) Delete data from the persistant cache.
  *
  * @param  mixed			Key name
  */
 function delete($key)
 {
     // Update list of e-objects
     global $ECACHE_OBJECTS;
     unset($ECACHE_OBJECTS[$key]);
     xcache_set(get_file_base() . 'ECACHE_OBJECTS', $ECACHE_OBJECTS, 0);
     xcache_unset($key);
 }

 /**
  * Destroy the data for a particular session identifier in the SessionHandler backend.
  *
  * @param   string  $id  The session identifier.
  *
  * @return  boolean  True on success, false otherwise.
  *
  * @since   11.1
  */
 public function destroy($id)
 {
     $sess_id = 'sess_' . $id;
     if (!xcache_isset($sess_id)) {
         return true;
     }
     return xcache_unset($sess_id);
 }

 public function clear($tags)
 {
     $tags = (array) $this->_mapTags($tags);
     foreach ($tags as $tag) {
         xcache_unset($tag);
     }
     return true;
 }

 /**
  * Sets a value to the variable store
  * @param string $key The key of the variable
  * @param mixed $value The value of the variable
  * @param integer $timeToLive Set to a number of seconds to make the variable expire in that amount of time
  * @return null
  */
 public function set($key, $value = null, $timeToLive = null)
 {
     if ($value === null) {
         xcache_unset($key);
     } else {
         xcache_set($key, $value, $timeToLive);
     }
 }

 /**
  * Delete cache item by key
  */
 public function delete($keys)
 {
     foreach ($keys as $key) {
         if (!xcache_unset($key)) {
             return NO;
         }
     }
     return YES;
 }

 /**
  * Delete cache item by key
  */
 public function delete($keys)
 {
     foreach ($keys as $key) {
         if (!xcache_unset($key)) {
             return FALSE;
         }
     }
     return TRUE;
 }

 function delete($key)
 {
     $key = $this->key($key);
     if (function_exists('apc_delete')) {
         return apc_delete($key);
     }
     if (function_exists('xcache_unset')) {
         return xcache_unset($key);
     }
 }

 public function _before(UnitTester $I)
 {
     if (!function_exists('xcache_emulation') && !function_exists('xcache_get')) {
         throw new \PHPUnit_Framework_SkippedTestError('Warning: xcache extension is not loaded');
     }
     $I->haveServiceInDi('modelsMetadata', function () {
         return new Xcache(['prefix' => 'app\\', 'lifetime' => 60]);
     }, true);
     $this->data = (require PATH_FIXTURES . 'metadata/robots.php');
     xcache_unset('$PMM$app\\');
 }