<?php
/**
 * Copyright 2007 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
/**
 * Unit tests for the "memcached" PHP extension.
 *
 */

require_once 'google/appengine/api/memcache/memcache_service_pb.php';
require_once 'google/appengine/runtime/Memcached.php';
require_once 'google/appengine/testing/ApiProxyTestBase.php';

use google\appengine\MemcacheDeleteRequest;
use google\appengine\MemcacheDeleteResponse;
use google\appengine\MemcacheDeleteResponse\DeleteStatusCode;
use google\appengine\MemcacheFlushRequest;
use google\appengine\MemcacheFlushResponse;
use google\appengine\MemcacheGetRequest;
use google\appengine\MemcacheGetResponse;
use google\appengine\MemcacheIncrementRequest;
use google\appengine\MemcacheIncrementResponse;
use google\appengine\MemcacheSetRequest;
use google\appengine\MemcacheSetRequest\SetPolicy;
use google\appengine\MemcacheSetResponse;
use google\appengine\MemcacheSetResponse\SetStatusCode;
use google\appengine\testing\ApiProxyTestBase;

class MemcachedTest extends ApiProxyTestBase {

  public function setUp() {
    parent::setUp();
    $this->_SERVER = $_SERVER;
  }

  public function tearDown() {
    $_SERVER = $this->_SERVER;
    parent::tearDown();
  }

  public function testAddSuccess() {
    $memcached = new Memcached();

    $request = new MemcacheSetRequest();
    $item = $request->addItem();
    $item->setKey("float");
    $item->setValue("2");
    $item->setFlags(6);  // float
    $item->setSetPolicy(SetPolicy::ADD);
    $item->setExpirationTime(30);

    $response = new MemcacheSetResponse();
    $response->addSetStatus(SetStatusCode::STORED);

    $this->apiProxyMock->expectCall('memcache',
                                    'Set',
                                    $request,
                                    $response);
    $this->assertTrue($memcached->add("float", 2.0, 30));
    $this->apiProxyMock->verify();
  }

  public function testAddWithPrefixSuccess() {
    $memcached = new Memcached();
    $memcached->setOption(Memcached::OPT_PREFIX_KEY, "widgets_");

    $request = new MemcacheSetRequest();
    $item = $request->addItem();
    $item->setKey("widgets_float");
    $item->setValue("2");
    $item->setFlags(6);  // float
    $item->setSetPolicy(SetPolicy::ADD);
    $item->setExpirationTime(30);

    $response = new MemcacheSetResponse();
    $response->addSetStatus(SetStatusCode::STORED);

    $this->apiProxyMock->expectCall('memcache',
                                    'Set',
                                    $request,
                                    $response);
    $this->assertTrue($memcached->add("float", 2.0, 30));
    $this->assertEquals($memcached->getOption(Memcached::OPT_PREFIX_KEY),
                        "widgets_");
    $this->assertEquals($memcached->getResultCode(), Memcached::RES_SUCCESS);
    $this->assertEquals($memcached->getResultMessage(), "SUCCESS");
    $this->apiProxyMock->verify();
  }

  public function testAppend() {
    $request = new MemcacheGetRequest();
    $request->addKey("widgets_float");
    $request->setForCas(true);

    $response = new MemcacheGetResponse();
    $item = $response->addItem();
    $item->setKey("widgets_float");
    $item->setValue("bar");
    $item->setFlags(0);  // string.
    $item->setCasId(123456);

    $this->apiProxyMock->expectCall('memcache',
                                    'Get',
                                    $request,
                                    $response);

    $request = new MemcacheSetRequest();
    $item = $request->addItem();
    $item->setKey("widgets_float");
    $item->setValue("barfoo");
    $item->setFlags(0);  // string
    $item->setCasId(123456);
    $item->setSetPolicy(SetPolicy::CAS);
    $item->setExpirationTime(0);

    $response = new MemcacheSetResponse();
    $response->addSetStatus(SetStatusCode::STORED);

    $this->apiProxyMock->expectCall('memcache',
                                    'Set',
                                    $request,
                                    $response);
    $memcached = new Memcached();
    $memcached->setOption(Memcached::OPT_PREFIX_KEY, "widgets_");
    $this->assertTrue($memcached->append("float", "foo", 30));
    $this->assertEquals($memcached->getResultCode(), Memcached::RES_SUCCESS);
    $this->apiProxyMock->verify();
  }

  public function testAppendCasRaceFailed() {
    $request = new MemcacheGetRequest();
    $request->addKey("widgets_float");
    $request->setForCas(true);

    $response = new MemcacheGetResponse();
    $item = $response->addItem();
    $item->setKey("widgets_float");
    $item->setValue("bar");
    $item->setFlags(0);  // string.
    $item->setCasId(123456);

    $this->apiProxyMock->expectCall('memcache',
                                    'Get',
                                    $request,
                                    $response);

    $request = new MemcacheSetRequest();
    $item = $request->addItem();
    $item->setKey("widgets_float");
    $item->setValue("barfoo");
    $item->setFlags(0);  // string
    $item->setCasId(123456);
    $item->setSetPolicy(SetPolicy::CAS);
    $item->setExpirationTime(0);

    $response = new MemcacheSetResponse();
    $response->addSetStatus(SetStatusCode::EXISTS);

    $this->apiProxyMock->expectCall('memcache',
                                    'Set',
                                    $request,
                                    $response);

    $request = new MemcacheGetRequest();
    $request->addKey("widgets_float");
    $request->setForCas(true);

    $response = new MemcacheGetResponse();
    $item = $response->addItem();
    $item->setKey("widgets_float");
    $item->setValue("baz");
    $item->setFlags(0);  // string.
    $item->setCasId(1234567);

    $this->apiProxyMock->expectCall('memcache',
                                    'Get',
                                    $request,
                                    $response);

    $request = new MemcacheSetRequest();
    $item = $request->addItem();
    $item->setKey("widgets_float");
    $item->setValue("bazfoo");
    $item->setFlags(0);  // string
    $item->setCasId(1234567);
    $item->setSetPolicy(SetPolicy::CAS);
    $item->setExpirationTime(0);

    $response = new MemcacheSetResponse();
    $response->addSetStatus(SetStatusCode::STORED);

    $this->apiProxyMock->expectCall('memcache',
                                    'Set',
                                    $request,
                                    $response);

    $memcached = new Memcached();
    $memcached->setOption(Memcached::OPT_PREFIX_KEY, "widgets_");
    $this->assertTrue($memcached->append("float", "foo", 30));
    $this->assertEquals($memcached->getResultCode(), Memcached::RES_SUCCESS);
    $this->apiProxyMock->verify();
  }

  public function testGetSuccess() {
    $request = new MemcacheGetRequest();
    $request->addKey("widgets_key");

    $response = new MemcacheGetResponse();
    $item = $response->addItem();
    $item->setKey("widgets_key");
    $item->setValue("INF");
    $item->setFlags(6);  // float

    $this->apiProxyMock->expectCall('memcache',
                                    'Get',
                                    $request,
                                    $response);
    $memcached = new Memcached();
    $memcached->setOption(Memcached::OPT_PREFIX_KEY, "widgets_");
    $this->assertEquals(INF, $memcached->get("key"));
    $this->assertEquals($memcached->getResultCode(), Memcached::RES_SUCCESS);
    $this->apiProxyMock->verify();
  }

  public function testGetMultiSuccess() {
    $request = new MemcacheGetRequest();
    $request->addKey("key");
    $request->addKey("key1");
    $request->setForCas(true);

    $response = new MemcacheGetResponse();
    $item = $response->addItem();
    $item->setKey("key");
    $item->setValue("value");
    $item->setFlags(0);  // string.
    $item->setCasId(123456);

    $this->apiProxyMock->expectCall('memcache',
                                    'Get',
                                    $request,
                                    $response);
    $memcached = new Memcached();
    $keys = ["key", "key1"];
    $result = $memcached->getMulti($keys,
                                   $cas_tokens,
                                   Memcached::GET_PRESERVE_ORDER);
    $this->assertEquals("value", $result["key"]);
    $this->assertEquals(123456, $cas_tokens["key"]);
    $this->assertTrue(array_key_exists("key1", $result));
    $this->assertNull($result["key1"]);
    $this->assertTrue(array_key_exists("key1", $cas_tokens));
    $this->assertNull($cas_tokens["key1"]);
    $this->assertEquals($memcached->getResultCode(), Memcached::RES_SUCCESS);
    $this->apiProxyMock->verify();
  }

  public function testGetMultiUnexpectedValue() {
    $request = new MemcacheGetRequest();
    $request->addKey("key");
    $request->addKey("key1");
    $request->setForCas(true);

    $response = new MemcacheGetResponse();
    $item = $response->addItem();
    $item->setKey("key");
    $item->setValue("value");
    $item->setFlags(2);  // Python's picked type.
    $item->setCasId(123456);
    $item = $response->addItem();
    $item->setKey("key1");
    $item->setValue("value1");
    $item->setFlags(0);  // String.
    $item->setCasId(789);

    $this->apiProxyMock->expectCall('memcache',
                                    'Get',
                                    $request,
                                    $response);
    $memcached = new Memcached();
    $keys = ["key", "key1"];
    $result = $memcached->getMulti($keys,
                                   $cas_tokens,
                                   Memcached::GET_PRESERVE_ORDER);
    $this->assertTrue(array_key_exists("key", $result));
    $this->assertNull($result["key"]);
    $this->assertTrue(array_key_exists("key", $cas_tokens));
    $this->assertNull($cas_tokens["key"]);
    $this->assertEquals("value1", $result["key1"]);
    $this->assertEquals(789, $cas_tokens["key1"]);
    $this->assertEquals($memcached->getResultCode(), Memcached::RES_SUCCESS);
    $this->apiProxyMock->verify();
  }

  public function testGetCasSuccess() {
    $request = new MemcacheGetRequest();
    $request->addKey("widgets_key");
    $request->setForCas(true);

    $response = new MemcacheGetResponse();
    $item = $response->addItem();
    $item->setKey("widgets_key");
    $item->setValue("value");
    $item->setFlags(0);  // string.
    $item->setCasId(123456);

    $this->apiProxyMock->expectCall('memcache',
                                    'Get',
                                    $request,
                                    $response);
    $memcached = new Memcached();
    $memcached->setOption(Memcached::OPT_PREFIX_KEY, "widgets_");
    $this->assertEquals("value", $memcached->get("key", null, $cas_id));
    $this->assertEquals($memcached->getResultCode(), Memcached::RES_SUCCESS);
    $this->assertEquals($cas_id, 123456);
    $this->apiProxyMock->verify();
  }

  public function testGetCasReadCacheSuccess() {
    $request = new MemcacheGetRequest();
    $request->addKey("widgets_key");
    $request->setForCas(true);

    $response = new MemcacheGetResponse();

    $this->apiProxyMock->expectCall('memcache',
                                    'Get',
                                    $request,
                                    $response);

    $request = new MemcacheSetRequest();
    $item = $request->addItem();
    $item->setKey("widgets_key");
    $item->setValue("cache_cb_value");
    $item->setFlags(0);  // string
    $item->setSetPolicy(SetPolicy::SET);
    $item->setExpirationTime(0);

    $response = new MemcacheSetResponse();
    $response->addSetStatus(SetStatusCode::STORED);
    $this->apiProxyMock->expectCall('memcache',
                                    'Set',
                                    $request,
                                    $response);

    $cache_cb = function($memcache, $key, &$value) {
      $value = 'cache_cb_value';
      return true;
    };

    $memcached = new Memcached();
    $memcached->setOption(Memcached::OPT_PREFIX_KEY, "widgets_");
    $cas_id = null;
    $this->assertEquals("cache_cb_value",
                        $memcached->get("key", $cache_cb, $cas_id));
    $this->assertEquals($memcached->getResultCode(), Memcached::RES_SUCCESS);
    $this->apiProxyMock->verify();
  }

  public function testGetMissing() {
    $request = new MemcacheGetRequest();
    $request->addKey("key");

    $response = new MemcacheGetResponse();

    $this->apiProxyMock->expectCall('memcache',
                                    'Get',
                                    $request,
                                    $response);
    $memcached = new Memcached();
    $this->assertFalse($memcached->get("key"));
    $this->assertEquals($memcached->getResultCode(), Memcached::RES_NOTFOUND);
    $this->assertEquals($memcached->getResultMessage(), 'NOT FOUND');
    $this->apiProxyMock->verify();
  }

  public function testGetUnexpectedValue() {
    $request = new MemcacheGetRequest();
    $request->addKey("key");

    $response = new MemcacheGetResponse();
    $item = $response->addItem();
    $item->setKey("key");
    $item->setValue("value");
    $item->setFlags(2);  // Python's picked type.

    $this->apiProxyMock->expectCall('memcache',
                                    'Get',
                                    $request,
                                    $response);
    $memcached = new Memcached();
    $this->assertFalse($memcached->get("key"));
    $this->assertEquals($memcached->getResultCode(), Memcached::RES_NOTFOUND);
    $this->apiProxyMock->verify();
  }

  public function testSetSuccess() {
    $request = new MemcacheSetRequest();
    $item = $request->addItem();
    $item->setKey("widgets_float");
    $item->setValue("2");
    $item->setFlags(6);  // float
    $item->setSetPolicy(SetPolicy::SET);
    $item->setExpirationTime(30);

    $response = new MemcacheSetResponse();
    $response->addSetStatus(SetStatusCode::STORED);

    $this->apiProxyMock->expectCall('memcache',
                                    'Set',
                                    $request,
                                    $response);
    $memcached = new Memcached();
    $memcached->setOption(Memcached::OPT_PREFIX_KEY, "widgets_");
    $this->assertTrue($memcached->set("float", 2.0, 30));
    $this->assertEquals($memcached->getResultCode(), Memcached::RES_SUCCESS);
    $this->apiProxyMock->verify();
  }

  public function testSetMultiSuccess() {
    $request = new MemcacheSetRequest();
    $item = $request->addItem();
    $item->setKey("widgets_float");
    $item->setValue("2");
    $item->setFlags(6);  // float
    $item->setSetPolicy(SetPolicy::SET);
    $item->setExpirationTime(30);

    $item = $request->addItem();
    $item->setKey("widgets_str");
    $item->setValue("str_value");
    $item->setFlags(0);  // string
    $item->setSetPolicy(SetPolicy::SET);
    $item->setExpirationTime(30);

    $response = new MemcacheSetResponse();
    $response->addSetStatus(SetStatusCode::STORED);
    $response->addSetStatus(SetStatusCode::STORED);

    $this->apiProxyMock->expectCall('memcache',
                                    'Set',
                                    $request,
                                    $response);
    $memcached = new Memcached();
    $memcached->setOption(Memcached::OPT_PREFIX_KEY, "widgets_");
    $items = [ "float" => 2.0, "str" => "str_value" ];
    $this->assertTrue($memcached->setMulti($items, 30));
    $this->assertEquals($memcached->getResultCode(), Memcached::RES_SUCCESS);
    $this->apiProxyMock->verify();
  }

  public function testSetMultiFails() {
    $request = new MemcacheSetRequest();
    $item = $request->addItem();
    $item->setKey("widgets_float");
    $item->setValue("2");
    $item->setFlags(6);  // float
    $item->setSetPolicy(SetPolicy::SET);
    $item->setExpirationTime(30);

    $item = $request->addItem();
    $item->setKey("widgets_str");
    $item->setValue("str_value");
    $item->setFlags(0);  // string
    $item->setSetPolicy(SetPolicy::SET);
    $item->setExpirationTime(30);

    $response = new MemcacheSetResponse();
    $response->addSetStatus(SetStatusCode::STORED);
    $response->addSetStatus(SetStatusCode::NOT_STORED);

    $this->apiProxyMock->expectCall('memcache',
                                    'Set',
                                    $request,
                                    $response);
    $memcached = new Memcached();
    $memcached->setOption(Memcached::OPT_PREFIX_KEY, "widgets_");
    $items = [ "float" => 2.0, "str" => "str_value" ];
    $this->assertFalse($memcached->setMulti($items, 30));
    $this->assertEquals($memcached->getResultCode(), Memcached::RES_NOTSTORED);
    $this->apiProxyMock->verify();
  }

  public function testReplaceSuccess() {
    $request = new MemcacheSetRequest();
    $item = $request->addItem();
    $item->setKey("widgets_float");
    $item->setValue("2");
    $item->setFlags(6);  // float
    $item->setSetPolicy(SetPolicy::REPLACE);
    $item->setExpirationTime(30);

    $response = new MemcacheSetResponse();
    $response->addSetStatus(SetStatusCode::STORED);

    $this->apiProxyMock->expectCall('memcache',
                                    'Set',
                                    $request,
                                    $response);
    $memcached = new Memcached();
    $memcached->setOption(Memcached::OPT_PREFIX_KEY, "widgets_");
    $this->assertTrue($memcached->replace("float", 2.0, 30));
    $this->assertEquals($memcached->getResultCode(), Memcached::RES_SUCCESS);
    $this->apiProxyMock->verify();
  }

  public function testIncrementSuccess() {
    $request = new MemcacheIncrementRequest();
    $request->setKey("key");
    $request->setDelta(5);
    $request->setInitialValue(500);

    $response = new MemcacheIncrementResponse();
    $response->setNewValue(7);

    $this->apiProxyMock->expectCall('memcache',
                                    'Increment',
                                    $request,
                                    $response);
    $memcached = new Memcached();
    $this->assertEquals(7, $memcached->increment("key", 5, 500, 30));
    $this->apiProxyMock->verify();
  }

  public function testDecrementSuccess() {
    $request = new MemcacheIncrementRequest();
    $request->setKey("widgets_key");
    $request->setDelta(5);
    $request->setDirection(MemcacheIncrementRequest\Direction::DECREMENT);
    $request->setInitialValue(500);

    $response = new MemcacheIncrementResponse();
    $response->setNewValue(7);

    $this->apiProxyMock->expectCall('memcache',
                                    'Increment',
                                    $request,
                                    $response);
    $memcached = new Memcached();
    $memcached->setOption(Memcached::OPT_PREFIX_KEY, "widgets_");
    $this->assertEquals(7, $memcached->decrement("key", 5, 500, 30));
    $this->assertEquals($memcached->getResultCode(), Memcached::RES_SUCCESS);
    $this->apiProxyMock->verify();
  }

  public function testPrependSuccess() {
    $request = new MemcacheGetRequest();
    $request->addKey("widgets_float");
    $request->setForCas(true);

    $response = new MemcacheGetResponse();
    $item = $response->addItem();
    $item->setKey("widgets_float");
    $item->setValue("bar");
    $item->setFlags(0);  // string.
    $item->setCasId(123456);

    $this->apiProxyMock->expectCall('memcache',
                                    'Get',
                                    $request,
                                    $response);

    $request = new MemcacheSetRequest();
    $item = $request->addItem();
    $item->setKey("widgets_float");
    $item->setValue("foobar");
    $item->setFlags(0);  // string
    $item->setCasId(123456);
    $item->setSetPolicy(SetPolicy::CAS);
    $item->setExpirationTime(0);

    $response = new MemcacheSetResponse();
    $response->addSetStatus(SetStatusCode::STORED);

    $this->apiProxyMock->expectCall('memcache',
                                    'Set',
                                    $request,
                                    $response);
    $memcached = new Memcached();
    $memcached->setOption(Memcached::OPT_PREFIX_KEY, "widgets_");
    $this->assertTrue($memcached->prepend("float", "foo", 30));
    $this->assertEquals($memcached->getResultCode(), Memcached::RES_SUCCESS);
    $this->apiProxyMock->verify();
  }

  public function testPrependCasRace() {
    $request = new MemcacheGetRequest();
    $request->addKey("widgets_float");
    $request->setForCas(true);

    $response = new MemcacheGetResponse();
    $item = $response->addItem();
    $item->setKey("widgets_float");
    $item->setValue("bar");
    $item->setFlags(0);  // string.
    $item->setCasId(123456);

    $this->apiProxyMock->expectCall('memcache',
                                    'Get',
                                    $request,
                                    $response);

    $request = new MemcacheSetRequest();
    $item = $request->addItem();
    $item->setKey("widgets_float");
    $item->setValue("foobar");
    $item->setFlags(0);  // string
    $item->setCasId(123456);
    $item->setSetPolicy(SetPolicy::CAS);
    $item->setExpirationTime(0);

    $response = new MemcacheSetResponse();
    $response->addSetStatus(SetStatusCode::EXISTS);

    $this->apiProxyMock->expectCall('memcache',
                                    'Set',
                                    $request,
                                    $response);

    $request = new MemcacheGetRequest();
    $request->addKey("widgets_float");
    $request->setForCas(true);

    $response = new MemcacheGetResponse();
    $item = $response->addItem();
    $item->setKey("widgets_float");
    $item->setValue("baz");
    $item->setFlags(0);  // string.
    $item->setCasId(1234567);

    $this->apiProxyMock->expectCall('memcache',
                                    'Get',
                                    $request,
                                    $response);

    $request = new MemcacheSetRequest();
    $item = $request->addItem();
    $item->setKey("widgets_float");
    $item->setValue("foobaz");
    $item->setFlags(0);  // string
    $item->setCasId(1234567);
    $item->setSetPolicy(SetPolicy::CAS);
    $item->setExpirationTime(0);

    $response = new MemcacheSetResponse();
    $response->addSetStatus(SetStatusCode::STORED);

    $this->apiProxyMock->expectCall('memcache',
                                    'Set',
                                    $request,
                                    $response);
    $memcached = new Memcached();
    $memcached->setOption(Memcached::OPT_PREFIX_KEY, "widgets_");
    $this->assertTrue($memcached->prepend("float", "foo", 30));
    $this->assertEquals($memcached->getResultCode(), Memcached::RES_SUCCESS);
    $this->apiProxyMock->verify();
  }

  public function testPrependGetFailed() {
    $request = new MemcacheGetRequest();
    $request->addKey("widgets_float");
    $request->setForCas(true);

    $response = new MemcacheGetResponse();

    $this->apiProxyMock->expectCall('memcache',
                                    'Get',
                                    $request,
                                    $response);

    $memcached = new Memcached();
    $memcached->setOption(Memcached::OPT_PREFIX_KEY, "widgets_");
    $this->assertFalse($memcached->prepend("float", "foo", 30));
    $this->assertEquals($memcached->getResultCode(), Memcached::RES_NOTSTORED);
    $this->apiProxyMock->verify();
  }

  public function testPrependReplaceFailed() {
    $request = new MemcacheGetRequest();
    $request->addKey("widgets_float");
    $request->setForCas(true);

    $response = new MemcacheGetResponse();
    $item = $response->addItem();
    $item->setKey("widgets_float");
    $item->setValue("bar");
    $item->setFlags(0);  // string.
    $item->setCasId(123456);

    $this->apiProxyMock->expectCall('memcache',
                                    'Get',
                                    $request,
                                    $response);

    $request = new MemcacheSetRequest();
    $item = $request->addItem();
    $item->setKey("widgets_float");
    $item->setValue("foobar");
    $item->setFlags(0);  // string
    $item->setCasId(123456);
    $item->setSetPolicy(SetPolicy::CAS);
    $item->setExpirationTime(0);

    $response = new MemcacheSetResponse();
    $response->addSetStatus(SetStatusCode::NOT_STORED);

    $this->apiProxyMock->expectCall('memcache',
                                    'Set',
                                    $request,
                                    $response);
    $memcached = new Memcached();
    $memcached->setOption(Memcached::OPT_PREFIX_KEY, "widgets_");
    $this->assertFalse($memcached->prepend("float", "foo", 30));
    $this->assertEquals($memcached->getResultCode(), Memcached::RES_NOTSTORED);
    $this->apiProxyMock->verify();
  }

  public function testCasSuccess() {
    $request = new MemcacheSetRequest();
    $item = $request->addItem();
    $item->setKey("widgets_float");
    $item->setValue("2");
    $item->setFlags(6);  // float
    $item->setCasId(12345);
    $item->setSetPolicy(SetPolicy::CAS);
    $item->setExpirationTime(30);

    $response = new MemcacheSetResponse();
    $response->addSetStatus(SetStatusCode::STORED);

    $this->apiProxyMock->expectCall('memcache',
                                    'Set',
                                    $request,
                                    $response);
    $memcached = new Memcached();
    $memcached->setOption(Memcached::OPT_PREFIX_KEY, "widgets_");
    $this->assertTrue($memcached->cas(12345, "float", 2.0, 30));
    $this->assertEquals($memcached->getResultCode(), Memcached::RES_SUCCESS);
    $this->apiProxyMock->verify();
  }

  public function testCasFailure() {
    $request = new MemcacheSetRequest();
    $item = $request->addItem();
    $item->setKey("widgets_float");
    $item->setValue("2");
    $item->setFlags(6);  // float
    $item->setCasId(12345);
    $item->setSetPolicy(SetPolicy::CAS);
    $item->setExpirationTime(30);

    $response = new MemcacheSetResponse();
    $response->addSetStatus(SetStatusCode::EXISTS);

    $this->apiProxyMock->expectCall('memcache',
                                    'Set',
                                    $request,
                                    $response);
    $memcached = new Memcached();
    $memcached->setOption(Memcached::OPT_PREFIX_KEY, "widgets_");
    $this->assertFalse($memcached->cas(12345, "float", 2.0, 30));
    $this->assertEquals($memcached->getResultCode(),
                        Memcached::RES_DATA_EXISTS);
    $this->apiProxyMock->verify();
  }

  public function testDeleteSuccess() {
    $request = new MemcacheDeleteRequest();
    $item = $request->addItem();
    $item->setKey("widgets_delete_key");
    $item->setDeleteTime(10);

    $response = new MemcacheDeleteResponse();
    $response->addDeleteStatus(DeleteStatusCode::DELETED);

    $this->apiProxyMock->expectCall('memcache',
                                    'Delete',
                                    $request,
                                    $response);
    $memcached = new Memcached();
    $memcached->setOption(Memcached::OPT_PREFIX_KEY, "widgets_");
    $this->assertTrue($memcached->delete("delete_key", 10));
    $this->assertEquals($memcached->getResultCode(), Memcached::RES_SUCCESS);
    $this->apiProxyMock->verify();
  }

  public function testDeleteNotThere() {
    $request = new MemcacheDeleteRequest();
    $item = $request->addItem();
    $item->setKey("widgets_delete_key");
    $item->setDeleteTime(10);

    $response = new MemcacheDeleteResponse();
    $response->addDeleteStatus(DeleteStatusCode::NOT_FOUND);

    $this->apiProxyMock->expectCall('memcache',
                                    'Delete',
                                    $request,
                                    $response);
    $memcached = new Memcached();
    $memcached->setOption(Memcached::OPT_PREFIX_KEY, "widgets_");
    $this->assertFalse($memcached->delete("delete_key", 10));
    $this->assertEquals($memcached->getResultCode(), Memcached::RES_NOTFOUND);
    $this->apiProxyMock->verify();
  }

  public function testFetchEmptyResults() {
    $memcached = new Memcached();
    $this->assertFalse($memcached->fetch());
  }

  public function testFetchAllEmptyResults() {
    $memcached = new Memcached();
    $this->assertFalse($memcached->fetchAll());
  }

  public function testGetDelayedSuccess() {
    $request = new MemcacheGetRequest();
    $request->addKey("key");
    $request->addKey("bar");
    $request->setForCas(true);

    $response = new MemcacheGetResponse();
    $item = $response->addItem();
    $item->setKey("key");
    $item->setValue("value");
    $item->setFlags(0);  // string.
    $item->setCasId(123456);

    $item = $response->addItem();
    $item->setKey("bar");
    $item->setValue("bar_value");
    $item->setFlags(0);  // string.
    $item->setCasId(2);

    $cb_count = 0;
    $cb = function($val) use (&$cb_count) {
      $cb_count++;
    };

    $this->apiProxyMock->expectCall('memcache',
                                    'Get',
                                    $request,
                                    $response);

    $memcached = new Memcached();
    $this->assertTrue($memcached->getDelayed(["key", "bar"], true, $cb));
    $this->assertEquals($memcached->getResultCode(), Memcached::RES_SUCCESS);
    $result = $memcached->fetch();
    $this->assertEquals($result["key"], "key");
    $this->assertEquals($result["value"], "value");
    $this->assertEquals($result["cas"], 123456);
    $result = $memcached->fetch();
    $this->assertEquals($result["key"], "bar");
    $this->assertEquals($result["value"], "bar_value");
    $this->assertEquals($result["cas"], 2);
    $this->assertFalse($memcached->fetch());
    $this->assertEquals($cb_count, 2);
    $this->apiProxyMock->verify();
  }

  public function testTouchSuccess() {
    $request = new MemcacheGetRequest();
    $request->addKey("key");
    $request->setForCas(true);

    $response = new MemcacheGetResponse();
    $item = $response->addItem();
    $item->setKey("key");
    $item->setValue("value");
    $item->setFlags(0);  // string.
    $item->setCasId(123456);

    $this->apiProxyMock->expectCall('memcache',
                                    'Get',
                                    $request,
                                    $response);

    $request = new MemcacheSetRequest();
    $item = $request->addItem();
    $item->setKey("key");
    $item->setValue("value");
    $item->setFlags(0);  // string
    $item->setCasId(123456);
    $item->setSetPolicy(SetPolicy::CAS);
    $item->setExpirationTime(999);

    $response = new MemcacheSetResponse();
    $response->addSetStatus(SetStatusCode::STORED);

    $this->apiProxyMock->expectCall('memcache',
                                    'Set',
                                    $request,
                                    $response);

    $memcached = new Memcached();
    $this->assertTrue($memcached->touch("key", 999));
    $this->apiProxyMock->verify();
  }

  public function testPassingNullKey() {
    $memcached = new Memcached();
    $this->assertFalse($memcached->add(null, 1));
    $this->assertFalse($memcached->replace(null, 1));
    $this->assertFalse($memcached->set(null, 1));
    $this->assertFalse($memcached->increment(null));
    $this->assertFalse($memcached->decrement(null));
  }
}