public void testSanitizeKey() throws Exception {
    memcachedClient.setSanitizeKeys(true);

    String key = "The string 眉@foo-bar";
    assertTrue(memcachedClient.add(key, 0, 0));
    assertEquals(0, memcachedClient.get(key));

    assertTrue(memcachedClient.replace(key, 0, 1));
    assertEquals(1, memcachedClient.get(key, 2000));

    assertTrue(memcachedClient.set(key, 0, 2));
    assertEquals((Integer) 2, memcachedClient.get(key, 2000, new IntegerTranscoder()));

    assertTrue(memcachedClient.set(key, 0, "xmemcached", new StringTranscoder()));
    assertTrue(memcachedClient.append(key, " great"));
    assertTrue(memcachedClient.prepend(key, "hello "));

    assertEquals("hello xmemcached great", memcachedClient.get(key));

    // test bulk get
    List<String> keys = new ArrayList<String>();
    for (int i = 0; i < 100; i++) {
      memcachedClient.add(key + i, 0, i);
      keys.add(key + i);
    }

    Map<String, Integer> result = memcachedClient.get(keys, 5000);
    for (int i = 0; i < 100; i++) {
      assertEquals((Integer) i, result.get(key + i));
    }

    for (int i = 0; i < 100; i++) {
      assertTrue(memcachedClient.delete(key + i));
      assertNull(memcachedClient.get(key + i));
    }

    // test cas
    memcachedClient.set(key, 0, 1);
    memcachedClient.cas(
        key,
        new CASOperation<Integer>() {

          public int getMaxTries() {
            return 1;
          }

          public Integer getNewValue(long currentCAS, Integer currentValue) {
            return currentValue + 1;
          }
        });
    assertEquals((Integer) 2, memcachedClient.get(key, 2000, new IntegerTranscoder()));
  }
  public void testAppendPrepend() throws Exception {
    // append,prepend
    assertTrue(memcachedClient.set("name", 0, "dennis", new StringTranscoder(), 1000));
    assertTrue(memcachedClient.prepend("name", "hello "));
    assertEquals("hello dennis", memcachedClient.get("name"));
    assertTrue(memcachedClient.append("name", " zhuang"));
    assertEquals("hello dennis zhuang", memcachedClient.get("name"));
    memcachedClient.delete("name");
    assertFalse(memcachedClient.prepend("name", "hello ", 2000));
    assertFalse(memcachedClient.append("name", " zhuang", 2000));
    // append test
    // blank key
    new BlankKeyChecker() {
      @Override
      public void call() throws Exception {
        memcachedClient.append("", 0, 1);
      }
    }.check();
    // null key
    new BlankKeyChecker() {
      @Override
      public void call() throws Exception {
        memcachedClient.append((String) null, 0, 1);
      }
    }.check();

    // invalid key
    new InValidKeyChecker() {
      @Override
      public void call() throws Exception {
        memcachedClient.append("test\r\n", 0, 1);
      }
    }.check();
    new InValidKeyChecker() {
      @Override
      public void call() throws Exception {
        memcachedClient.append("test test2", 0, 1);
      }
    }.check();

    // key is too long
    new TooLongKeyChecker(memcachedClient) {
      @Override
      public void call() throws Exception {
        int keyLength = memcachedClient.getProtocol() == Protocol.Text ? 256 : 65536;
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < keyLength; i++) {
          sb.append(i);
        }
        memcachedClient.append(sb.toString(), 0, 1);
      }
    }.check();

    // prepend test
    // blank key
    new BlankKeyChecker() {
      @Override
      public void call() throws Exception {
        memcachedClient.prepend("", 0, 1);
      }
    }.check();
    // null key
    new BlankKeyChecker() {
      @Override
      public void call() throws Exception {
        memcachedClient.prepend((String) null, 0, 1);
      }
    }.check();

    // invalid key
    new InValidKeyChecker() {
      @Override
      public void call() throws Exception {
        memcachedClient.prepend("test\r\n", 0, 1);
      }
    }.check();
    new InValidKeyChecker() {
      @Override
      public void call() throws Exception {
        memcachedClient.prepend("test test2", 0, 1);
      }
    }.check();

    // key is too long
    new TooLongKeyChecker(memcachedClient) {
      @Override
      public void call() throws Exception {
        int keyLength = memcachedClient.getProtocol() == Protocol.Text ? 256 : 65536;
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < keyLength; i++) {
          sb.append(i);
        }
        memcachedClient.prepend(sb.toString(), 0, 1);
      }
    }.check();
  }