Golang cache.New函数代码示例

func TestConnectionsItems(t *testing.T) {
	stats := New(42, "9999", "8888", 1024, 2, true, true)
	storage := cache.New(42)
	if len(stats.Items(storage)) != 6 {
		t.Fatalf("Unexpected length of returned value; expected 6.")
	}
}

func TestSerializationCase1(t *testing.T) {
	stats := New(42, "9999", "8888", 1024, 2, true, true)
	storage := cache.New(42)
	if len(stats.Serialize(storage)) != 19 {
		t.Fatalf("Unexpected number of fields of returned value: ", stats)
	}
}

func TestSettingsSerialization(t *testing.T) {
	stats := New(42, "9999", "8888", 1024, 2, true, true)
	storage := cache.New(42)
	res := stats.Settings(storage)
	if len(res) != 12 {
		t.Fatalf("Unexpected length of Settings serialization: %d, expected 12;", len(res), res)
	}
}

func TestHandlingSuiteSet2(t *testing.T) {
	var storage = cache.New(4)
	var testEnum = Ascii_protocol_enum{"set", []string{"key"}, 1, 0, 42, 0, false, make([]byte, 42), ""}
	res, err := testEnum.HandleRequest(storage, nil)
	if err == nil || string(res) != strings.Replace(SERVER_ERROR_TEMP, "%s", "Not enough memory", 1) {
		t.Fatalf("Unexpected returned values of handling: ", err, res)
	}
}

func TestHandlingSuiteFlushAll(t *testing.T) {
	var storage = cache.New(42)
	var testEnum = Ascii_protocol_enum{"flush_all", nil, 0, 0, 0, 0, false, nil, ""}
	res, err := testEnum.HandleRequest(storage, nil)
	if err != nil || string(res) != "OK\r\n" {
		t.Fatalf("Unexpected returned values of handling: ", err, res)
	}
}

func TestHandlingSuiteSet1(t *testing.T) {
	var storage = cache.New(42)
	var testEnum = Ascii_protocol_enum{"set", []string{"key"}, 1, 0, 4, 0, false, []byte("TEST"), ""}
	res, err := testEnum.HandleRequest(storage, nil)
	if err != nil || string(res) != "STORED\r\n" {
		t.Fatalf("Unexpected returned values of handling: ", err, res)
	}
}

func TestHandlingStatistic(t *testing.T) {
	var testEnum = Ascii_protocol_enum{"stats", nil, 0, 0, 0, 0, false, nil, ""}
	var stats = stat.New(42, "9999", "8888", 1024, 2, true, true)
	var storage = cache.New(42)

	res, err := testEnum.HandleRequest(storage, stats)
	if err != nil || res == nil {
		t.Fatalf("Unexpected returned values of handling: ", err, res)
	}
}

func TestHandlingSuiteDelete2(t *testing.T) {
	var storage = cache.New(42)
	var testEnum = Ascii_protocol_enum{"set", []string{"key"}, 1, 0, 4, 0, false, []byte("TEST"), ""}
	testEnum.HandleRequest(storage, nil)
	testEnum = Ascii_protocol_enum{"delete", []string{"not_key"}, 0, 0, 0, 0, false, nil, ""}
	res, err := testEnum.HandleRequest(storage, nil)
	if err != nil || string(res) != NOT_FOUND {
		t.Fatalf("Unexpected returned values of handling: ", err, res)
	}
}

func TestHandlingSuiteCas2(t *testing.T) {
	var storage = cache.New(42)
	if !storage.Set(tools.NewStoredData([]byte("test1"), "key"), 0, 0, 0) {
		t.Fatalf("Unexpecting behavior ")
	}
	var testEnum = Ascii_protocol_enum{"cas", []string{"key"}, 1, 0, 42, 424242, false, make([]byte, 42), ""}
	res, err := testEnum.HandleRequest(storage, nil)
	if err != nil || string(res) != NOT_FOUND {
		t.Fatalf("Unexpected returned values of handling: ", err, res)
	}
}

func TestHandlingSuiteGetMultiple(t *testing.T) {
	var storage = cache.New(42)
	var testEnum = Ascii_protocol_enum{"set", []string{"key1"}, 1, 0, 4, 0, false, []byte("TEST"), ""}
	testEnum.HandleRequest(storage, nil)
	testEnum = Ascii_protocol_enum{"set", []string{"key2"}, 1, 0, 4, 0, false, []byte("TEST"), ""}
	testEnum.HandleRequest(storage, nil)
	testEnum = Ascii_protocol_enum{"get", []string{"key1", "key2"}, 0, 0, 0, 0, false, nil, ""}
	res, err := testEnum.HandleRequest(storage, nil)
	if err != nil || string(res) != "VALUE key1 1 4\r\nTEST\r\nVALUE key2 1 4\r\nTEST\r\nEND\r\n" {
		t.Fatalf("Unexpected returned values of handling: ", err, res)
	}
}

func TestHandlingSuiteIncrDecr2(t *testing.T) {
	var storage = cache.New(42)
	var testEnum = Ascii_protocol_enum{"set", []string{"key"}, 1, 0, 6, 0, false, []byte("3.1459"), ""}
	testEnum.HandleRequest(storage, nil)
	testEnum = Ascii_protocol_enum{"incr", []string{"key"}, 0, 0, 0, 0, false, []byte("100"), ""}
	res, err := testEnum.HandleRequest(storage, nil)
	if err != nil || string(res) != "ERROR\r\n" {
		t.Fatalf("Unexpected returned values of handling: ", err, string(res))
	}
	testEnum = Ascii_protocol_enum{"decr", []string{"key1"}, 0, 0, 0, 0, false, []byte("100"), ""}
	res, err = testEnum.HandleRequest(storage, nil)
	if err != nil || string(res) != "NOT_FOUND\r\n" {
		t.Fatalf("Unexpected returned values of handling: ", err, string(res))
	}
}

// This public function raises up the server.
// Function receives following params:
// tcp_port string, which uses to open tcp socket at pointed port,
// udp_port string, which uses to open tcp socket at pointed port,
// address, which specified an only ip address which server will listen to,
// max_connections, sets a limit of maximal number of active connections,
// cas, flush - flags which forbids of usage such commands if value = true,
// verbosity - defines the dept of verbosity for server
// and bytes_of_memory, which uses for limiting allocated memory.
// Function returns a pointer to a server structure with filled and prepared to usage fields.
func NewServer(tcp_port string, udp_port string, address string, max_connections int, cas bool, flush bool,
	verbosity int, bytes_of_memory int64) *Server {
	server := new(Server)
	server.tcp_socket = nil
	server.tcp_port = tcp_port
	server.udp_port = udp_port
	server.cas_disabled = cas
	server.flush_disabled = flush
	server.connection_limit = max_connections
	server.listen_address = address
	server.storage = cache.New(bytes_of_memory)
	server.connections = make(map[string]net.Conn)
	server.Stat = statistic.New(bytes_of_memory, tcp_port, udp_port, max_connections, verbosity, cas, flush)
	server.Logger = NewServerLogger(verbosity)
	return server
}

func TestHandlingSuitePrepend2(t *testing.T) {
	var storage = cache.New(42)
	var testEnum = Ascii_protocol_enum{"set", []string{"key"}, 1, 0, 4, 0, false, []byte("TEST"), ""}
	res, err := testEnum.HandleRequest(storage, nil)
	if err != nil || string(res) != "STORED\r\n" {
		t.Fatalf("Unexpected returned values of handling: ", err, res)
	}
	testEnum = Ascii_protocol_enum{"prepend", []string{"key"}, 0, 0, 5, 0, false, []byte("TEST2"), ""}
	res, err = testEnum.HandleRequest(storage, nil)
	if err != nil || string(res) != "STORED\r\n" {
		t.Fatalf("Unexpected returned values of handling: ", err, res)
	}
	stored := tools.ExtractStoredData(storage.Get("key").Cacheable)
	if stored == nil || string(stored) != "TEST2TEST" {
		t.Fatalf("Stored value is invalid: ", err, stored)
	}
}

func TestHandlingSuiteGets1(t *testing.T) {
	var storage = cache.New(42)
	var testEnum = Ascii_protocol_enum{"set", []string{"key"}, 1, 0, 4, 0, false, []byte("TEST"), ""}
	res, err := testEnum.HandleRequest(storage, nil)
	testEnum = Ascii_protocol_enum{"gets", []string{"key"}, 0, 0, 0, 0, false, nil, ""}
	res, err = testEnum.HandleRequest(storage, nil)
	item := storage.Get("key")
	if item == nil {
		t.Fatalf("Item wasn't stored")
	}
	cas := item.Cas_unique
	if cas == 0 {
		t.Fatalf("Cas unique wasn't set.")
	}
	match_str := "VALUE key 1 4 " + tools.IntToString(cas) + "\r\nTEST\r\nEND\r\n"
	if err != nil || string(res) != match_str {
		t.Fatalf("Unexpected returned values of handling: ", err, res, testEnum)
	}
}

func TestHandlingStatsRecording(t *testing.T) {
	var testEnum = Ascii_protocol_enum{"set", []string{"key"}, 1, 0, 2, 0, true, []byte("42"), ""}
	stats := stat.New(42, "9999", "8888", 1024, 2, true, true)
	var storage = cache.New(42)
	res, err := testEnum.HandleRequest(storage, stats)
	if err != nil || res == nil {
		t.Fatalf("Unexpected returned values of handling: ", err, res)
	}
	if stats.Commands == nil || stats.Commands["cmd_set"] != 1 {
		t.Fatalf("Wrong stats handling: ", stats.Commands)
	}

	stats = stat.New(42, "9999", "8888", 1024, 2, true, true)
	testEnum = Ascii_protocol_enum{"get", []string{"not_key"}, 0, 0, 0, 0, false, nil, ""}
	res, err = testEnum.HandleRequest(storage, stats)
	if err != nil || res == nil {
		t.Fatalf("Unexpected returned values of handling: ", err, res)
	}
	if stats.Commands == nil || stats.Commands["cmd_get"] != 1 || stats.Commands["get_misses"] != 1 {
		t.Fatalf("Wrong stats handling: ", stats.Commands)
	}

	stats = stat.New(42, "9999", "8888", 1024, 2, true, true)
	testEnum = Ascii_protocol_enum{"get", []string{"key"}, 0, 0, 0, 0, false, nil, ""}
	res, err = testEnum.HandleRequest(storage, stats)
	if err != nil || res == nil {
		t.Fatalf("Unexpected returned values of handling: ", err, res)
	}
	if stats.Commands == nil || stats.Commands["cmd_get"] != 1 || stats.Commands["get_hits"] != 1 {
		t.Fatalf("Wrong stats handling: ", stats.Commands)
	}

	stats = stat.New(42, "9999", "8888", 1024, 2, true, true)
	testEnum = Ascii_protocol_enum{"cas", []string{"key"}, 1, 0, 42, 424242, false, make([]byte, 42), ""}
	res, err = testEnum.HandleRequest(storage, stats)
	if err != nil || res == nil {
		t.Fatalf("Unexpected returned values of handling: ", err, res)
	}
	if stats.Commands == nil || stats.Commands["cas_badval"] != 1 {
		t.Fatalf("Wrong stats handling: ", stats.Commands)
	}
}