From 1c9db6b84ead40b3ffc81f929de089ff1d515f39 Mon Sep 17 00:00:00 2001
From: Jacques Grove <aquarapid@gmail.com>
Date: Wed, 19 Aug 2020 18:20:22 -0700
Subject: [PATCH] Remove long-unused memcache and cacheservice

Signed-off-by: Jacques Grove <aquarapid@gmail.com>
---
 go/cacheservice/cacheservice.go | 112 -----------
 go/memcache/memcache.go         | 320 -------------------------------
 go/memcache/memcache_test.go    | 323 --------------------------------
 3 files changed, 755 deletions(-)
 delete mode 100644 go/cacheservice/cacheservice.go
 delete mode 100644 go/memcache/memcache.go
 delete mode 100644 go/memcache/memcache_test.go

diff --git a/go/cacheservice/cacheservice.go b/go/cacheservice/cacheservice.go
deleted file mode 100644
index 9a7dbcabaec..00000000000
--- a/go/cacheservice/cacheservice.go
+++ /dev/null
@@ -1,112 +0,0 @@
-/*
-Copyright 2019 The Vitess Authors.
-
-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.
-*/
-
-package cacheservice
-
-import (
-	"fmt"
-	"sync"
-	"time"
-)
-
-// NewConnFunc is a factory method that creates a CacheService instance
-// using given CacheServiceConfig.
-type NewConnFunc func(config Config) (CacheService, error)
-
-var (
-	// services stores all supported cache service.
-	services = make(map[string]NewConnFunc)
-
-	mu sync.Mutex
-
-	// DefaultCacheService decides the default cache service connection.
-	DefaultCacheService string
-)
-
-// Config carries config data for CacheService.
-type Config struct {
-	Address string
-	Timeout time.Duration
-}
-
-// Result gives the cached data.
-type Result struct {
-	Key   string
-	Value []byte
-	Flags uint16
-	Cas   uint64
-}
-
-// CacheService defines functions to use a cache service.
-type CacheService interface {
-	// Get returns cached data for given keys.
-	Get(keys ...string) (results []Result, err error)
-	// Gets returns cached data for given keys, it is an alternative Get api
-	// for using with CAS. Gets returns a CAS identifier with the item. If
-	// the item's CAS value has changed since you Gets'ed it, it will not be stored.
-	Gets(keys ...string) (results []Result, err error)
-	// Set sets the value with specified cache key.
-	Set(key string, flags uint16, timeout uint64, value []byte) (stored bool, err error)
-	// Add stores the value only if it does not already exist.
-	Add(key string, flags uint16, timeout uint64, value []byte) (stored bool, err error)
-	// Replace replaces the value, only if the value already exists,
-	// for the specified cache key.
-	Replace(key string, flags uint16, timeout uint64, value []byte) (stored bool, err error)
-	// Append appends the value after the last bytes in an existing item.
-	Append(key string, flags uint16, timeout uint64, value []byte) (stored bool, err error)
-	// Prepend prepends the value before existing value.
-	Prepend(key string, flags uint16, timeout uint64, value []byte) (stored bool, err error)
-	// Cas stores the value only if no one else has updated the data since you read it last.
-	Cas(key string, flags uint16, timeout uint64, value []byte, cas uint64) (stored bool, err error)
-	// Delete deletes the value for the specified cache key.
-	Delete(key string) (deleted bool, err error)
-	// FlushAll purges the entire cache.
-	FlushAll() (err error)
-	// Stats returns a list of basic stats.
-	Stats(argument string) (result []byte, err error)
-	// Close closes the CacheService
-	Close()
-}
-
-// Register a db connection.
-func Register(name string, fn NewConnFunc) {
-	mu.Lock()
-	defer mu.Unlock()
-	if _, ok := services[name]; ok {
-		panic(fmt.Sprintf("register a registered key: %s", name))
-	}
-	services[name] = fn
-}
-
-// Connect returns a CacheService using the given config.
-func Connect(config Config) (CacheService, error) {
-	mu.Lock()
-	defer mu.Unlock()
-	if DefaultCacheService == "" {
-		if len(services) == 1 {
-			for _, fn := range services {
-				return fn(config)
-			}
-		}
-		panic("there are more than one service connect func " +
-			"registered but no default cache service has been specified.")
-	}
-	fn, ok := services[DefaultCacheService]
-	if !ok {
-		panic(fmt.Sprintf("service connect function for given default cache service: %s is not found.", DefaultCacheService))
-	}
-	return fn(config)
-}
diff --git a/go/memcache/memcache.go b/go/memcache/memcache.go
deleted file mode 100644
index f645ac80d5f..00000000000
--- a/go/memcache/memcache.go
+++ /dev/null
@@ -1,320 +0,0 @@
-/*
-Copyright 2019 The Vitess Authors.
-
-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.
-*/
-
-// Package memcache is a client for memcached.
-package memcache
-
-import (
-	"bufio"
-	"fmt"
-	"io"
-	"net"
-	"strconv"
-	"strings"
-	"time"
-
-	"vitess.io/vitess/go/cacheservice"
-)
-
-// Connection is the connection to a memcache.
-type Connection struct {
-	conn     net.Conn
-	buffered bufio.ReadWriter
-	timeout  time.Duration
-}
-
-// Connect connects a memcache process.
-func Connect(address string, timeout time.Duration) (conn *Connection, err error) {
-	var network string
-	if strings.Contains(address, "/") {
-		network = "unix"
-	} else {
-		network = "tcp"
-	}
-	var nc net.Conn
-	nc, err = net.DialTimeout(network, address, timeout)
-	if err != nil {
-		return nil, err
-	}
-	return &Connection{
-		conn: nc,
-		buffered: bufio.ReadWriter{
-			Reader: bufio.NewReader(nc),
-			Writer: bufio.NewWriter(nc),
-		},
-		timeout: timeout,
-	}, nil
-}
-
-// Close closes the memcache connection.
-func (mc *Connection) Close() {
-	mc.conn.Close()
-}
-
-// Get returns cached data for given keys.
-func (mc *Connection) Get(keys ...string) (results []cacheservice.Result, err error) {
-	defer handleError(&err)
-	results = mc.get("get", keys)
-	return
-}
-
-// Gets returns cached data for given keys, it is an alternative Get api
-// for using with CAS. Gets returns a CAS identifier with the item. If
-// the item's CAS value has changed since you Gets'ed it, it will not be stored.
-func (mc *Connection) Gets(keys ...string) (results []cacheservice.Result, err error) {
-	defer handleError(&err)
-	results = mc.get("gets", keys)
-	return
-}
-
-// Set sets the value with specified cache key.
-func (mc *Connection) Set(key string, flags uint16, timeout uint64, value []byte) (stored bool, err error) {
-	defer handleError(&err)
-	return mc.store("set", key, flags, timeout, value, 0), nil
-}
-
-// Add stores the value only if it does not already exist.
-func (mc *Connection) Add(key string, flags uint16, timeout uint64, value []byte) (stored bool, err error) {
-	defer handleError(&err)
-	return mc.store("add", key, flags, timeout, value, 0), nil
-}
-
-// Replace replaces the value, only if the value already exists,
-// for the specified cache key.
-func (mc *Connection) Replace(key string, flags uint16, timeout uint64, value []byte) (stored bool, err error) {
-	defer handleError(&err)
-	return mc.store("replace", key, flags, timeout, value, 0), nil
-}
-
-// Append appends the value after the last bytes in an existing item.
-func (mc *Connection) Append(key string, flags uint16, timeout uint64, value []byte) (stored bool, err error) {
-	defer handleError(&err)
-	return mc.store("append", key, flags, timeout, value, 0), nil
-}
-
-// Prepend prepends the value before existing value.
-func (mc *Connection) Prepend(key string, flags uint16, timeout uint64, value []byte) (stored bool, err error) {
-	defer handleError(&err)
-	return mc.store("prepend", key, flags, timeout, value, 0), nil
-}
-
-// Cas stores the value only if no one else has updated the data since you read it last.
-func (mc *Connection) Cas(key string, flags uint16, timeout uint64, value []byte, cas uint64) (stored bool, err error) {
-	defer handleError(&err)
-	return mc.store("cas", key, flags, timeout, value, cas), nil
-}
-
-// Delete deletes the value for the specified cache key.
-func (mc *Connection) Delete(key string) (deleted bool, err error) {
-	defer handleError(&err)
-	mc.setDeadline()
-	// delete <key> [<time>] [noreply]\r\n
-	mc.writestrings("delete ", key, "\r\n")
-	reply := mc.readline()
-	if strings.Contains(reply, "ERROR") {
-		panic(NewError("Server error"))
-	}
-	return strings.HasPrefix(reply, "DELETED"), nil
-}
-
-// FlushAll purges the entire cache.
-func (mc *Connection) FlushAll() (err error) {
-	defer handleError(&err)
-	mc.setDeadline()
-	// flush_all [delay] [noreply]\r\n
-	mc.writestrings("flush_all\r\n")
-	response := mc.readline()
-	if !strings.Contains(response, "OK") {
-		panic(NewError(fmt.Sprintf("Error in FlushAll %v", response)))
-	}
-	return nil
-}
-
-// Stats returns a list of basic stats.
-func (mc *Connection) Stats(argument string) (result []byte, err error) {
-	defer handleError(&err)
-	mc.setDeadline()
-	if argument == "" {
-		mc.writestrings("stats\r\n")
-	} else {
-		mc.writestrings("stats ", argument, "\r\n")
-	}
-	mc.flush()
-	for {
-		l := mc.readline()
-		if strings.HasPrefix(l, "END") {
-			break
-		}
-		if strings.Contains(l, "ERROR") {
-			return nil, NewError(l)
-		}
-		result = append(result, l...)
-		result = append(result, '\n')
-	}
-	return result, err
-}
-
-func (mc *Connection) get(command string, keys []string) (results []cacheservice.Result) {
-	mc.setDeadline()
-	results = make([]cacheservice.Result, 0, len(keys))
-	if len(keys) == 0 {
-		return
-	}
-	// get(s) <key>*\r\n
-	mc.writestrings(command)
-	for _, key := range keys {
-		mc.writestrings(" ", key)
-	}
-	mc.writestrings("\r\n")
-	header := mc.readline()
-	var result cacheservice.Result
-	for strings.HasPrefix(header, "VALUE") {
-		// VALUE <key> <flags> <bytes> [<cas unique>]\r\n
-		chunks := strings.Split(header, " ")
-		if len(chunks) < 4 {
-			panic(NewError("Malformed response: %s", string(header)))
-		}
-		result.Key = chunks[1]
-		flags64, err := strconv.ParseUint(chunks[2], 10, 16)
-		if err != nil {
-			panic(NewError("%v", err))
-		}
-		result.Flags = uint16(flags64)
-		size, err := strconv.ParseUint(chunks[3], 10, 64)
-		if err != nil {
-			panic(NewError("%v", err))
-		}
-		if len(chunks) == 5 {
-			result.Cas, err = strconv.ParseUint(chunks[4], 10, 64)
-			if err != nil {
-				panic(NewError("%v", err))
-			}
-		}
-		// <data block>\r\n
-		result.Value = mc.read(int(size) + 2)[:size]
-		results = append(results, result)
-		header = mc.readline()
-	}
-	if !strings.HasPrefix(header, "END") {
-		panic(NewError("Malformed response: %s", string(header)))
-	}
-	return
-}
-
-func (mc *Connection) store(command, key string, flags uint16, timeout uint64, value []byte, cas uint64) (stored bool) {
-	if len(value) > 1000000 {
-		return false
-	}
-
-	mc.setDeadline()
-	// <command name> <key> <flags> <exptime> <bytes> [noreply]\r\n
-	mc.writestrings(command, " ", key, " ")
-	mc.write(strconv.AppendUint(nil, uint64(flags), 10))
-	mc.writestring(" ")
-	mc.write(strconv.AppendUint(nil, timeout, 10))
-	mc.writestring(" ")
-	mc.write(strconv.AppendInt(nil, int64(len(value)), 10))
-	if cas != 0 {
-		mc.writestring(" ")
-		mc.write(strconv.AppendUint(nil, cas, 10))
-	}
-	mc.writestring("\r\n")
-	// <data block>\r\n
-	mc.write(value)
-	mc.writestring("\r\n")
-	reply := mc.readline()
-	if strings.Contains(reply, "ERROR") {
-		panic(NewError("Server error"))
-	}
-	return strings.HasPrefix(reply, "STORED")
-}
-
-func (mc *Connection) writestrings(strs ...string) {
-	for _, s := range strs {
-		mc.writestring(s)
-	}
-}
-
-func (mc *Connection) writestring(s string) {
-	if _, err := mc.buffered.WriteString(s); err != nil {
-		panic(NewError("%s", err))
-	}
-}
-
-func (mc *Connection) write(b []byte) {
-	if _, err := mc.buffered.Write(b); err != nil {
-		panic(NewError("%s", err))
-	}
-}
-
-func (mc *Connection) flush() {
-	if err := mc.buffered.Flush(); err != nil {
-		panic(NewError("%s", err))
-	}
-}
-
-func (mc *Connection) readline() string {
-	mc.flush()
-	l, isPrefix, err := mc.buffered.ReadLine()
-	if isPrefix || err != nil {
-		panic(NewError("Prefix: %v, %s", isPrefix, err))
-	}
-	return string(l)
-}
-
-func (mc *Connection) read(count int) []byte {
-	mc.flush()
-	b := make([]byte, count)
-	if _, err := io.ReadFull(mc.buffered, b); err != nil {
-		panic(NewError("%s", err))
-	}
-	return b
-}
-
-func (mc *Connection) setDeadline() {
-	if err := mc.conn.SetDeadline(time.Now().Add(mc.timeout)); err != nil {
-		panic(NewError("%s", err))
-	}
-}
-
-// Error is the error from CacheService.
-type Error struct {
-	Message string
-}
-
-// NewError creates a new Error.
-func NewError(format string, args ...interface{}) Error {
-	return Error{fmt.Sprintf(format, args...)}
-}
-
-func (merr Error) Error() string {
-	return merr.Message
-}
-
-func handleError(err *error) {
-	if x := recover(); x != nil {
-		*err = x.(Error)
-	}
-}
-
-func init() {
-	cacheservice.Register(
-		"memcache",
-		func(config cacheservice.Config) (cacheservice.CacheService, error) {
-			return Connect(config.Address, config.Timeout)
-		},
-	)
-}
diff --git a/go/memcache/memcache_test.go b/go/memcache/memcache_test.go
deleted file mode 100644
index a6a50c5e334..00000000000
--- a/go/memcache/memcache_test.go
+++ /dev/null
@@ -1,323 +0,0 @@
-/*
-Copyright 2019 The Vitess Authors.
-
-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.
-*/
-
-package memcache
-
-import (
-	"os/exec"
-	"strings"
-	"testing"
-	"time"
-)
-
-func TestMemcache(t *testing.T) {
-	if testing.Short() {
-		t.Skip("skipping integration test in short mode.")
-	}
-
-	cmd := exec.Command("memcached", "-s", "/tmp/vt_memcache_test.sock")
-	if err := cmd.Start(); err != nil {
-		if strings.Contains(err.Error(), "executable file not found in $PATH") {
-			t.Skipf("skipping: %v", err)
-		}
-		t.Fatalf("Memcache start: %v", err)
-	}
-	defer cmd.Process.Kill()
-
-	var c *Connection
-	var err error
-	deadline := time.Now().Add(10 * time.Second)
-	for {
-		if c, err = Connect("/tmp/vt_memcache_test.sock", 30*time.Millisecond); err == nil {
-			break
-		} else {
-			if time.Now().After(deadline) {
-				t.Fatalf("Connect: %v", err)
-			}
-			time.Sleep(100 * time.Millisecond)
-		}
-	}
-
-	// Set
-	stored, err := c.Set("Hello", 0, 0, []byte("world"))
-	if err != nil {
-		t.Fatalf("Set: %v", err)
-	}
-	if !stored {
-		t.Errorf("want true, got %v", stored)
-	}
-	expect(t, c, "Hello", "world")
-
-	// Add
-	stored, err = c.Add("Hello", 0, 0, []byte("Jupiter"))
-	if err != nil {
-		t.Errorf("Add: %v", err)
-	}
-	if stored {
-		t.Errorf("want false, got %v", stored)
-	}
-	expect(t, c, "Hello", "world")
-
-	// Replace
-	stored, err = c.Replace("Hello", 0, 0, []byte("World"))
-	if err != nil {
-		t.Errorf("Replace: %v", err)
-	}
-	if !stored {
-		t.Errorf("want true, got %v", stored)
-	}
-	expect(t, c, "Hello", "World")
-
-	// Append
-	stored, err = c.Append("Hello", 0, 0, []byte("!"))
-	if err != nil {
-		t.Errorf("Append: %v", err)
-	}
-	if !stored {
-		t.Errorf("want true, got %v", stored)
-	}
-	expect(t, c, "Hello", "World!")
-
-	// Prepend
-	stored, err = c.Prepend("Hello", 0, 0, []byte("Hello, "))
-	if err != nil {
-		t.Errorf("Prepend: %v", err)
-	}
-	if !stored {
-		t.Errorf("want true, got %v", stored)
-	}
-	expect(t, c, "Hello", "Hello, World!")
-
-	// Delete
-	deleted, err := c.Delete("Hello")
-	if err != nil {
-		t.Errorf("Delete: %v", err)
-	}
-	if !deleted {
-		t.Errorf("want true, got %v", deleted)
-	}
-	expect(t, c, "Hello", "")
-
-	// Flags
-	stored, err = c.Set("Hello", 0xFFFF, 0, []byte("world"))
-	if err != nil {
-		t.Fatalf("Set: %v", err)
-	}
-	if !stored {
-		t.Errorf("want true, got %v", stored)
-	}
-	results, err := c.Get("Hello")
-	if err != nil {
-		t.Fatalf("Get: %v", err)
-	}
-	if results[0].Flags != 0xFFFF {
-		t.Errorf("want 0xFFFF, got %x", results[0].Flags)
-	}
-	if string(results[0].Value) != "world" {
-		t.Errorf("want world, got %s", results[0].Value)
-	}
-
-	// timeout
-	stored, err = c.Set("Lost", 0, 1, []byte("World"))
-	if err != nil {
-		t.Fatalf("Set: %v", err)
-	}
-	if !stored {
-		t.Errorf("want true, got %v", stored)
-	}
-	expect(t, c, "Lost", "World")
-	expectPoll(t, c, "Lost", "", 10*time.Second)
-
-	// cas
-	stored, err = c.Set("Data", 0, 0, []byte("Set"))
-	if err != nil {
-		t.Fatalf("Set: %v", err)
-	}
-	if !stored {
-		t.Errorf("want true, got %v", stored)
-	}
-	expect(t, c, "Data", "Set")
-	results, err = c.Gets("Data")
-	if err != nil {
-		t.Fatalf("Gets: %v", err)
-	}
-	cas := results[0].Cas
-	if cas == 0 {
-		t.Errorf("want non-zero for cas")
-	}
-	stored, err = c.Cas("Data", 0, 0, []byte("not set"), 12345)
-	if err != nil {
-		t.Fatalf("Set: %v", err)
-	}
-	if stored {
-		t.Errorf("want false, got %v", stored)
-	}
-	expect(t, c, "Data", "Set")
-	_, err = c.Cas("Data", 0, 0, []byte("Changed"), cas)
-	if err != nil {
-		t.Fatalf("Set: %v", err)
-	}
-	expect(t, c, "Data", "Changed")
-	stored, err = c.Set("Data", 0, 0, []byte("Overwritten"))
-	if err != nil {
-		t.Fatalf("Set: %v", err)
-	}
-	if !stored {
-		t.Errorf("want true, got %v", stored)
-	}
-	expect(t, c, "Data", "Overwritten")
-
-	// stats
-	var stats []byte
-	stats, err = c.Stats("")
-	if err != nil {
-		t.Fatalf("Stats: %v", err)
-	}
-	statsStr := string(stats)
-	if !strings.Contains(statsStr, "STAT version ") {
-		t.Fatalf("want containing \"version\", got %v", statsStr)
-	}
-	// for manual inspection of stats with -v
-	t.Logf("Main stats:\n" + statsStr)
-
-	stats, err = c.Stats("slabs")
-	if err != nil {
-		t.Fatalf("Stats: %v", err)
-	}
-	statsStr = string(stats)
-	if !strings.Contains(statsStr, "STAT 1:chunk_size ") {
-		t.Fatalf("want containing \"chunk_size\", got %v", statsStr)
-	}
-	// for manual inspection of stats with -v
-	t.Logf("Slabs stats:\n" + string(stats))
-
-	stats, err = c.Stats("items")
-	if err != nil {
-		t.Fatalf("Stats: %v", err)
-	}
-	statsStr = string(stats)
-	if !strings.Contains(statsStr, "STAT items:1:number ") {
-		t.Fatalf("want containing \"number\", got %v", statsStr)
-	}
-	// for manual inspection of stats with -v
-	t.Logf("Items stats:\n" + string(stats))
-
-	// FlushAll
-	// Set
-	_, err = c.Set("Flush", 0, 0, []byte("Test"))
-	if err != nil {
-		t.Errorf("Set: %v", err)
-	}
-	expect(t, c, "Flush", "Test")
-
-	err = c.FlushAll()
-	if err != nil {
-		t.Fatalf("FlushAll: err %v", err)
-	}
-
-	results, err = c.Get("Flush")
-	if err != nil {
-		t.Fatalf("Get: %v", err)
-	}
-	if len(results) != 0 {
-		t.Fatalf("FlushAll failed")
-	}
-
-	// Multi
-	_, _ = c.Set("key1", 0, 0, []byte("val1"))
-	_, _ = c.Set("key2", 0, 0, []byte("val2"))
-
-	results, _ = c.Get("key1", "key2")
-	if len(results) != 2 {
-		t.Fatalf("want 2, gto %d", len(results))
-	}
-	if results[0].Key != "key1" {
-		t.Errorf("want key1, got %s", results[0].Key)
-	}
-	if string(results[0].Value) != "val1" {
-		t.Errorf("want val1, got %s", string(results[0].Value))
-	}
-	if results[1].Key != "key2" {
-		t.Errorf("want key2, got %s", results[0].Key)
-	}
-	if string(results[1].Value) != "val2" {
-		t.Errorf("want val2, got %s", string(results[1].Value))
-	}
-
-	results, _ = c.Gets("key1", "key3", "key2")
-	if len(results) != 2 {
-		t.Fatalf("want 2, gto %d", len(results))
-	}
-	if results[0].Key != "key1" {
-		t.Errorf("want key1, got %s", results[0].Key)
-	}
-	if string(results[0].Value) != "val1" {
-		t.Errorf("want val1, got %s", string(results[0].Value))
-	}
-	if results[1].Key != "key2" {
-		t.Errorf("want key2, got %s", results[0].Key)
-	}
-	if string(results[1].Value) != "val2" {
-		t.Errorf("want val2, got %s", string(results[1].Value))
-	}
-
-	// timeout test
-	c.timeout = 1 * time.Nanosecond
-	_, err = c.Gets("key1", "key3", "key2")
-	want := "i/o timeout"
-	if err == nil || !strings.Contains(err.Error(), want) {
-		t.Errorf("\"%v\" does not contain \"%s\"", err, want)
-	}
-
-	// test double close
-	c.Close()
-	c.Close()
-}
-
-func expect(t *testing.T, c *Connection, key, value string) {
-	results, err := c.Get(key)
-	if err != nil {
-		t.Fatalf("Get: %v", err)
-	}
-	var got string
-	if len(results) != 0 {
-		got = string(results[0].Value)
-	}
-	if got != value {
-		t.Errorf("want %s, got %s", value, got)
-	}
-}
-
-func expectPoll(t *testing.T, c *Connection, key, value string, timeout time.Duration) {
-	deadline := time.Now().Add(timeout)
-	for {
-		results, err := c.Get(key)
-		if err != nil {
-			t.Fatalf("Get: %v", err)
-		}
-		var got string
-		if len(results) != 0 {
-			got = string(results[0].Value)
-		}
-		if got == value {
-			return
-		}
-		if time.Now().After(deadline) {
-			t.Errorf("want %s, got %s", value, got)
-		}
-		time.Sleep(100 * time.Millisecond)
-	}
-}