[redis.git] / client-libraries / cpp / test_client.cpp

#include "redisclient.h"

#include <iostream>

using namespace std;

#define ASSERT_EQUAL(x,y) assert_equal(x, y, __LINE__)
#define ASSERT_NOT_EQUAL(x,y) assert_not_equal(x, y, __LINE__)
#define ASSERT_GT(x,y) assert_gt(x, y, __LINE__)

template <typename T>
void assert_equal(const T & actual, const T & expected, int lineno)
{
#ifndef NDEBUG
  cerr << "assert_equal('" << expected << "', '" << actual << "')" << endl;
#endif

  if (expected != actual)
  {
    cerr << "expected '" << expected << "' got '" << actual << "'" << endl
         << "failing test called from line " << lineno << endl;
    
    exit(1);
  }

#ifndef NDEBUG
  cerr << "... OK" << endl;
#endif
}

template <typename T>
void assert_not_equal(const T & a, const T & b, int lineno)
{
  if (a == b)
  {
    cerr << "expected inequality" << endl
         << "failing test called from line " << lineno << endl;
    
    exit(1);
  }
}

template <typename T>
void assert_gt(const T & a, const T & b, int lineno)
{
#ifndef NDEBUG
  cerr << "assert_gt('" << a << "', '" << b << "')" << endl;
#endif

  if (a <= b)
  {
    cerr << "expected '" << a << "' > '" << b << "'" << endl
         << "failing test called from line " << lineno << endl;
    
    exit(1);
  }

#ifndef NDEBUG
  cerr << "... OK" << endl;
#endif
}

void test(const string & name)
{
#ifndef NDEBUG
  cerr << "------------------------------" << endl
       << "starting test: "                << name << endl;
#endif
}

int main(int argc, char ** argv)
{
  try 
  {
    redis::client c;

    // Test on high number databases

    c.select(14);
    c.flushdb();

    c.select(15);
    c.flushdb();

    string foo("foo"), bar("bar"), baz("baz"), buz("buz"), goo("goo");

    test("auth");
    {
      // TODO ... needs a conf for redis-server
    }

    test("info");
    {
      // doesn't throw? then, has valid numbers and known info-keys.
      redis::server_info info;
      c.info(info);
    }

    test("set, get");
    {
      c.set(foo, bar);
      ASSERT_EQUAL(c.get(foo), bar);
    }

    test("getset");
    {
      ASSERT_EQUAL(c.getset(foo, baz), bar);
      ASSERT_EQUAL(c.get(foo), baz);
    }

    test("mget");
    {
      string x_val("hello"), y_val("world");
      c.set("x", x_val);
      c.set("y", y_val);
      redis::client::string_vector keys;
      keys.push_back("x");
      keys.push_back("y");
      redis::client::string_vector vals;
      c.mget(keys, vals);
      ASSERT_EQUAL(vals.size(), size_t(2));
      ASSERT_EQUAL(vals[0], x_val);
      ASSERT_EQUAL(vals[1], y_val);
    }

    test("setnx");
    {
      ASSERT_EQUAL(c.setnx(foo, bar), false);
      ASSERT_EQUAL(c.setnx(buz, baz), true);
      ASSERT_EQUAL(c.get(buz), baz);
    }

    test("incr");
    {
      ASSERT_EQUAL(c.incr("goo"), 1L);test("nonexistent (0) -> 1");
      ASSERT_EQUAL(c.incr("goo"), 2L);test("1->2");
    }

    test("decr");
    {
      ASSERT_EQUAL(c.decr("goo"), 1L);test("2->1");
      ASSERT_EQUAL(c.decr("goo"), 0L);test("1->0");
    }

    test("incrby");
    {
      ASSERT_EQUAL(c.incrby("goo", 3), 3L);test("0->3");
      ASSERT_EQUAL(c.incrby("goo", 2), 5L);test("3->5");
    }

    test("exists");
    {
      ASSERT_EQUAL(c.exists("goo"), true);
    }

    test("del");
    {
      c.del("goo");
      ASSERT_EQUAL(c.exists("goo"), false);
    }

    test("type (basic)");
    {
      ASSERT_EQUAL(c.type(goo), redis::client::datatype_none);test("we deleted it");
      c.set(goo, "redis");
      ASSERT_EQUAL(c.type(goo), redis::client::datatype_string);
    }

    test("keys");
    {
      redis::client::string_vector keys;
      ASSERT_EQUAL(c.keys("*oo", keys), 2L);
      ASSERT_EQUAL(keys.size(), 2UL);
      ASSERT_EQUAL(keys[0], foo);
      ASSERT_EQUAL(keys[1], goo);
    }

    test("randomkey");
    {
      ASSERT_GT(c.randomkey().size(), 0UL);
    }

    test("rename");
    {
      ASSERT_EQUAL(c.exists("foo"), true);
      ASSERT_EQUAL(c.exists("doo"), false);
      c.rename("foo", "doo");
      ASSERT_EQUAL(c.exists("foo"), false);
      ASSERT_EQUAL(c.exists("doo"), true);
    }

    test("renamenx");
    {
      ASSERT_EQUAL(c.exists("doo"), true);
      ASSERT_EQUAL(c.exists("foo"), false);
      ASSERT_EQUAL(c.renamenx("doo", "foo"), true);
      ASSERT_EQUAL(c.exists("doo"), false);
      ASSERT_EQUAL(c.exists("foo"), true);
      ASSERT_EQUAL(c.renamenx("goo", "foo"), false);
      ASSERT_EQUAL(c.exists("foo"), true);
      ASSERT_EQUAL(c.exists("goo"), true);
    }

    test("dbsize");
    {
      ASSERT_GT(c.dbsize(), 0L);
    }

    test("expire");
    {
      c.expire("goo", 1);
#ifndef NDEBUG
      cerr << "please wait a few seconds.." << endl;
#endif
      sleep(2);
      ASSERT_EQUAL(c.exists("goo"), false);
    }

    test("rpush");
    {
      ASSERT_EQUAL(c.exists("list1"), false);
      c.rpush("list1", "val1");
      ASSERT_EQUAL(c.llen("list1"), 1L);
      ASSERT_EQUAL(c.type("list1"), redis::client::datatype_list);
      c.rpush("list1", "val2");
      ASSERT_EQUAL(c.llen("list1"), 2L);
      ASSERT_EQUAL(c.lindex("list1", 0), string("val1"));
      ASSERT_EQUAL(c.lindex("list1", 1), string("val2"));
    }

    test("lpush");
    {
      c.del("list1");
      ASSERT_EQUAL(c.exists("list1"), false);
      c.lpush("list1", "val1");
      ASSERT_EQUAL(c.type("list1"), redis::client::datatype_list);
      ASSERT_EQUAL(c.llen("list1"), 1L);
      c.lpush("list1", "val2");
      ASSERT_EQUAL(c.llen("list1"), 2L);
      ASSERT_EQUAL(c.lindex("list1", 0), string("val2"));
      ASSERT_EQUAL(c.lindex("list1", 1), string("val1"));
    }

    test("llen");
    {
      c.del("list1");
      ASSERT_EQUAL(c.exists("list1"), false);
      ASSERT_EQUAL(c.llen("list1"), 0L);
      c.lpush("list1", "x");
      ASSERT_EQUAL(c.llen("list1"), 1L);
      c.lpush("list1", "y");
      ASSERT_EQUAL(c.llen("list1"), 2L);
    }

    test("lrange");
    {
      ASSERT_EQUAL(c.exists("list1"), true);
      ASSERT_EQUAL(c.llen("list1"), 2L);
      redis::client::string_vector vals;
      ASSERT_EQUAL(c.lrange("list1", 0, -1, vals), 2L);
      ASSERT_EQUAL(vals.size(), 2UL);
      ASSERT_EQUAL(vals[0], string("y"));
      ASSERT_EQUAL(vals[1], string("x"));
    }

    test("lrange with subset of full list");
    {
      ASSERT_EQUAL(c.exists("list1"), true);
      ASSERT_EQUAL(c.llen("list1"), 2L);
      redis::client::string_vector vals;
      ASSERT_EQUAL(c.lrange("list1", 0, 1, vals), 2L); // inclusive, so entire list
      ASSERT_EQUAL(vals.size(), 2UL);
      ASSERT_EQUAL(vals[0], string("y"));
      ASSERT_EQUAL(vals[1], string("x"));

      redis::client::string_vector vals2;
      ASSERT_EQUAL(c.lrange("list1", 0, 0, vals2), 1L); // inclusive, so first item
      ASSERT_EQUAL(vals2.size(), 1UL);
      ASSERT_EQUAL(vals2[0], string("y"));

      redis::client::string_vector vals3;
      ASSERT_EQUAL(c.lrange("list1", -1, -1, vals3), 1L); // inclusive, so first item
      ASSERT_EQUAL(vals3.size(), 1UL);
      ASSERT_EQUAL(vals3[0], string("x"));
    }

    test("get_list");
    {
      ASSERT_EQUAL(c.exists("list1"), true);
      ASSERT_EQUAL(c.llen("list1"), 2L);
      redis::client::string_vector vals;
      ASSERT_EQUAL(c.get_list("list1", vals), 2L);
      ASSERT_EQUAL(vals.size(), 2UL);
      ASSERT_EQUAL(vals[0], string("y"));
      ASSERT_EQUAL(vals[1], string("x"));
    }

    test("ltrim");
    {
      ASSERT_EQUAL(c.exists("list1"), true);
      ASSERT_EQUAL(c.llen("list1"), 2L);
      c.ltrim("list1", 0, 0);
      ASSERT_EQUAL(c.exists("list1"), true);
      ASSERT_EQUAL(c.llen("list1"), 1L);
      redis::client::string_vector vals;
      ASSERT_EQUAL(c.get_list("list1", vals), 1L);
      ASSERT_EQUAL(vals[0], string("y"));
    }

    test("lindex");
    {
      ASSERT_EQUAL(c.lindex("list1", 0), string("y"));
      c.rpush("list1", "x");
      ASSERT_EQUAL(c.llen("list1"), 2L);
      ASSERT_EQUAL(c.lindex("list1", -1), string("x"));
      ASSERT_EQUAL(c.lindex("list1", 1), string("x"));
    }

    test("lset");
    {
      c.lset("list1", 1, "z");
      ASSERT_EQUAL(c.lindex("list1", 1), string("z"));
      ASSERT_EQUAL(c.llen("list1"), 2L);
    }

    test("lrem");
    {
      c.lrem("list1", 1, "z");
      ASSERT_EQUAL(c.llen("list1"), 1L);
      ASSERT_EQUAL(c.lindex("list1", 0), string("y"));

      // list1 = [ y ]
      ASSERT_EQUAL(c.lrem("list1", 0, "q"), 0L);

      c.rpush("list1", "z");
      c.rpush("list1", "z");
      c.rpush("list1", "z");
      c.rpush("list1", "a");     
      // list1 = [ y, z, z, z, a ]
      ASSERT_EQUAL(c.lrem("list1", 2, "z"), 2L);
      // list1 = [ y, z, a ]
      ASSERT_EQUAL(c.llen("list1"), 3L);
      ASSERT_EQUAL(c.lindex("list1", 0), string("y"));
      ASSERT_EQUAL(c.lindex("list1", 1), string("z"));
      ASSERT_EQUAL(c.lindex("list1", 2), string("a"));

      c.rpush("list1", "z");
      // list1 = [ y, z, a, z ]
      ASSERT_EQUAL(c.lrem("list1", -1, "z"), 1L);  // <0 => rm R to L 
      // list1 = [ y, z, a ]
      ASSERT_EQUAL(c.llen("list1"), 3L);
      ASSERT_EQUAL(c.lindex("list1", 0), string("y"));
      ASSERT_EQUAL(c.lindex("list1", 1), string("z"));
      ASSERT_EQUAL(c.lindex("list1", 2), string("a"));

      // list1 = [ y, z, a ]
      // try to remove 5 'a's but there's only 1 ... no problem.
      ASSERT_EQUAL(c.lrem("list1", 5, "a"), 1L);
      // list1 = [ y, z ]
      ASSERT_EQUAL(c.llen("list1"), 2L);
      ASSERT_EQUAL(c.lindex("list1", 0), string("y"));
      ASSERT_EQUAL(c.lindex("list1", 1), string("z"));
    }

    test("lrem_exact");
    {
      // list1 = [ y, z ]

      // try to remove 5 'z's but there's only 1 ... now it's a problem.

      bool threw = false;

      try 
      {
        c.lrem_exact("list1", 5, "z");
      }
      catch (redis::value_error & e)
      {
        threw = true;
      }

      ASSERT_EQUAL(threw, true);

      // This DOES remove the one 'z' though
      // list1 = [ y ]

      ASSERT_EQUAL(c.llen("list1"), 1L);
      ASSERT_EQUAL(c.lindex("list1", 0), string("y"));
    }

    test("lpop");
    {
      ASSERT_EQUAL(c.lpop("list1"), string("y")); 
      // list1 = []
      ASSERT_EQUAL(c.lpop("list1"), redis::client::missing_value);
    }

    test("rpop");
    {
      c.rpush("list1", "hello");
      c.rpush("list1", "world");
      ASSERT_EQUAL(c.rpop("list1"), string("world")); 
      ASSERT_EQUAL(c.rpop("list1"), string("hello")); 
      ASSERT_EQUAL(c.lpop("list1"), redis::client::missing_value);
    }

    test("sadd");
    {
      c.sadd("set1", "sval1");
      ASSERT_EQUAL(c.exists("set1"), true);
      ASSERT_EQUAL(c.type("set1"), redis::client::datatype_set);
      ASSERT_EQUAL(c.sismember("set1", "sval1"), true);
    }

    test("srem");
    {
      c.srem("set1", "sval1");
      ASSERT_EQUAL(c.exists("set1"), true);
      ASSERT_EQUAL(c.type("set1"), redis::client::datatype_set);
      ASSERT_EQUAL(c.sismember("set1", "sval1"), false);
    }

    test("smove");
    {
      c.sadd("set1", "hi");
      // set1 = { hi }
      ASSERT_EQUAL(c.exists("set2"), false);
      c.smove("set1", "set2", "hi");
      ASSERT_EQUAL(c.sismember("set1", "hi"), false);
      ASSERT_EQUAL(c.sismember("set2", "hi"), true); 
    }

    test("scard");
    {
      ASSERT_EQUAL(c.scard("set1"), 0L);
      ASSERT_EQUAL(c.scard("set2"), 1L);
    }

    test("sismember");
    {
      // see above
    }

    test("smembers");
    {
      c.sadd("set2", "bye");
      redis::client::string_set members;
      ASSERT_EQUAL(c.smembers("set2", members), 2L);
      ASSERT_EQUAL(members.size(), 2UL);
      ASSERT_NOT_EQUAL(members.find("hi"),  members.end());
      ASSERT_NOT_EQUAL(members.find("bye"), members.end());
    }

    test("sinter");
    {
      c.sadd("set3", "bye");
      c.sadd("set3", "bye2");
      redis::client::string_vector keys;
      keys.push_back("set2");
      keys.push_back("set3");
      redis::client::string_set intersection;
      ASSERT_EQUAL(c.sinter(keys, intersection), 1L);
      ASSERT_EQUAL(intersection.size(), 1UL);
      ASSERT_NOT_EQUAL(intersection.find("bye"), intersection.end());
    }

    test("sinterstore");
    {
      c.sadd("seta", "1");
      c.sadd("seta", "2");
      c.sadd("seta", "3");

      c.sadd("setb", "2");
      c.sadd("setb", "3");
      c.sadd("setb", "4");

      redis::client::string_vector keys;
      keys.push_back("seta");
      keys.push_back("setb");

      c.sinterstore("setc", keys);

      redis::client::string_set members;
      ASSERT_EQUAL(c.smembers("setc", members), 2L);
      ASSERT_EQUAL(members.size(), 2UL);
      ASSERT_NOT_EQUAL(members.find("2"), members.end());
      ASSERT_NOT_EQUAL(members.find("3"), members.end());
    }

    test("sunion");
    {
      c.sadd("setd", "1");
      c.sadd("sete", "2");
      redis::client::string_vector keys;
      keys.push_back("setd");
      keys.push_back("sete");
      redis::client::string_set a_union;
      ASSERT_EQUAL(c.sunion(keys, a_union), 2L);
      ASSERT_EQUAL(a_union.size(), 2UL);
      ASSERT_NOT_EQUAL(a_union.find("1"), a_union.end());
      ASSERT_NOT_EQUAL(a_union.find("2"), a_union.end());
    }

    test("sunionstore");
    {
      c.sadd("setf", "1");
      c.sadd("setg", "2");

      redis::client::string_vector keys;
      keys.push_back("setf");
      keys.push_back("setg");

      c.sunionstore("seth", keys);

      redis::client::string_set members;
      ASSERT_EQUAL(c.smembers("seth", members), 2L);
      ASSERT_EQUAL(members.size(), 2UL);
      ASSERT_NOT_EQUAL(members.find("1"), members.end());
      ASSERT_NOT_EQUAL(members.find("2"), members.end());
    }

    test("move");
    {
      c.select(14);
      ASSERT_EQUAL(c.exists("ttt"), false);
      c.select(15);
      c.set("ttt", "uuu");
      c.move("ttt", 14);
      c.select(14);
      ASSERT_EQUAL(c.exists("ttt"), true);
      c.select(15);
      ASSERT_EQUAL(c.exists("ttt"), false);
    }

    test("move should fail since key exists already");
    {
      c.select(14);
      c.set("ttt", "xxx");
      c.select(15);
      c.set("ttt", "uuu");

      bool threw = false;

      try 
      {
        c.move("ttt", 14);
      }
      catch (redis::protocol_error & e)
      {
        threw = true;
      }

      ASSERT_EQUAL(threw, true);

      c.select(14);
      ASSERT_EQUAL(c.exists("ttt"), true);
      c.select(15);
      ASSERT_EQUAL(c.exists("ttt"), true);
    }

    test("sort ascending");
    {
      c.sadd("sort1", "3");
      c.sadd("sort1", "2");
      c.sadd("sort1", "1");

      redis::client::string_vector sorted;
      ASSERT_EQUAL(c.sort("sort1", sorted), 3L);
      ASSERT_EQUAL(sorted.size(), 3UL);
      ASSERT_EQUAL(sorted[0], string("1"));
      ASSERT_EQUAL(sorted[1], string("2"));
      ASSERT_EQUAL(sorted[2], string("3"));
    }

    test("sort descending");
    {
      redis::client::string_vector sorted;
      ASSERT_EQUAL(c.sort("sort1", sorted, redis::client::sort_order_descending), 3L);
      ASSERT_EQUAL(sorted.size(), 3UL);
      ASSERT_EQUAL(sorted[0], string("3"));
      ASSERT_EQUAL(sorted[1], string("2"));
      ASSERT_EQUAL(sorted[2], string("1"));
    }

    test("sort with limit");
    {
      // TODO
    }

    test("sort lexicographically");
    {
      // TODO
    }

    test("sort with pattern and weights");
    {
      // TODO
    }

    test("save");
    {
      c.save();
    }

    test("bgsave");
    {
      c.bgsave();
    }

    test("lastsave");
    {
      ASSERT_GT(c.lastsave(), 0L);
    }

    test("shutdown");
    {
// You can test this if you really want to ...
//      c.shutdown();
    }
  } 
  catch (redis::redis_error & e) 
  {
    cerr << "got exception: " << string(e) << endl << "FAIL" << endl;
    return 1;
  }

  cout << endl << "testing completed successfully" << endl;
  return 0;
}
Commit	Line	Data
57172ffb	1	#include "redisclient.h"
	2
	3	#include <iostream>
	4
	5	using namespace std;
	6
	7	#define ASSERT_EQUAL(x,y) assert_equal(x, y, __LINE__)
	8	#define ASSERT_NOT_EQUAL(x,y) assert_not_equal(x, y, __LINE__)
	9	#define ASSERT_GT(x,y) assert_gt(x, y, __LINE__)
	10
	11	template <typename T>
	12	void assert_equal(const T & actual, const T & expected, int lineno)
	13	{
	14	#ifndef NDEBUG
	15	cerr << "assert_equal('" << expected << "', '" << actual << "')" << endl;
	16	#endif
	17
	18	if (expected != actual)
	19	{
	20	cerr << "expected '" << expected << "' got '" << actual << "'" << endl
	21	<< "failing test called from line " << lineno << endl;
	22
	23	exit(1);
	24	}
	25
	26	#ifndef NDEBUG
	27	cerr << "... OK" << endl;
	28	#endif
	29	}
	30
	31	template <typename T>
	32	void assert_not_equal(const T & a, const T & b, int lineno)
	33	{
	34	if (a == b)
	35	{
	36	cerr << "expected inequality" << endl
	37	<< "failing test called from line " << lineno << endl;
	38
	39	exit(1);
	40	}
	41	}
	42
	43	template <typename T>
	44	void assert_gt(const T & a, const T & b, int lineno)
	45	{
	46	#ifndef NDEBUG
	47	cerr << "assert_gt('" << a << "', '" << b << "')" << endl;
	48	#endif
	49
	50	if (a <= b)
	51	{
	52	cerr << "expected '" << a << "' > '" << b << "'" << endl
	53	<< "failing test called from line " << lineno << endl;
	54
	55	exit(1);
	56	}
	57
	58	#ifndef NDEBUG
	59	cerr << "... OK" << endl;
	60	#endif
	61	}
	62
	63	void test(const string & name)
	64	{
65	#ifndef NDEBUG
66	cerr << "------------------------------" << endl
67	<< "starting test: " << name << endl;
68	#endif
69	}
70
71	int main(int argc, char ** argv)
72	{
73	try
74	{
75	redis::client c;
76
77	// Test on high number databases
78
79	c.select(14);
80	c.flushdb();
81
82	c.select(15);
83	c.flushdb();
84
85	string foo("foo"), bar("bar"), baz("baz"), buz("buz"), goo("goo");
86
87	test("auth");
88	{
89	// TODO ... needs a conf for redis-server
90	}
91
92	test("info");
93	{
94	// doesn't throw? then, has valid numbers and known info-keys.
95	redis::server_info info;
96	c.info(info);
97	}
98
99	test("set, get");
100	{
101	c.set(foo, bar);
102	ASSERT_EQUAL(c.get(foo), bar);
103	}
104
105	test("getset");
106	{
107	ASSERT_EQUAL(c.getset(foo, baz), bar);
108	ASSERT_EQUAL(c.get(foo), baz);
109	}
110
111	test("mget");
112	{
113	string x_val("hello"), y_val("world");
114	c.set("x", x_val);
115	c.set("y", y_val);
116	redis::client::string_vector keys;
117	keys.push_back("x");
118	keys.push_back("y");
119	redis::client::string_vector vals;
120	c.mget(keys, vals);
121	ASSERT_EQUAL(vals.size(), size_t(2));
122	ASSERT_EQUAL(vals[0], x_val);
123	ASSERT_EQUAL(vals[1], y_val);
124	}
125
126	test("setnx");
127	{
128	ASSERT_EQUAL(c.setnx(foo, bar), false);
129	ASSERT_EQUAL(c.setnx(buz, baz), true);
130	ASSERT_EQUAL(c.get(buz), baz);
131	}
132
133	test("incr");
134	{
135	ASSERT_EQUAL(c.incr("goo"), 1L);test("nonexistent (0) -> 1");
136	ASSERT_EQUAL(c.incr("goo"), 2L);test("1->2");
137	}
138
139	test("decr");
140	{
141	ASSERT_EQUAL(c.decr("goo"), 1L);test("2->1");
142	ASSERT_EQUAL(c.decr("goo"), 0L);test("1->0");
143	}
144
145	test("incrby");
146	{
147	ASSERT_EQUAL(c.incrby("goo", 3), 3L);test("0->3");
148	ASSERT_EQUAL(c.incrby("goo", 2), 5L);test("3->5");
149	}
150
151	test("exists");
152	{
153	ASSERT_EQUAL(c.exists("goo"), true);
154	}
155
156	test("del");
157	{
158	c.del("goo");
159	ASSERT_EQUAL(c.exists("goo"), false);
160	}
161
162	test("type (basic)");
163	{
164	ASSERT_EQUAL(c.type(goo), redis::client::datatype_none);test("we deleted it");
165	c.set(goo, "redis");
166	ASSERT_EQUAL(c.type(goo), redis::client::datatype_string);
167	}
168
169	test("keys");
170	{
171	redis::client::string_vector keys;
172	ASSERT_EQUAL(c.keys("*oo", keys), 2L);
173	ASSERT_EQUAL(keys.size(), 2UL);
174	ASSERT_EQUAL(keys[0], foo);
175	ASSERT_EQUAL(keys[1], goo);
176	}
177
178	test("randomkey");
179	{
180	ASSERT_GT(c.randomkey().size(), 0UL);
181	}
182
183	test("rename");
184	{
185	ASSERT_EQUAL(c.exists("foo"), true);
186	ASSERT_EQUAL(c.exists("doo"), false);
187	c.rename("foo", "doo");
188	ASSERT_EQUAL(c.exists("foo"), false);
189	ASSERT_EQUAL(c.exists("doo"), true);
190	}
191
192	test("renamenx");
193	{
194	ASSERT_EQUAL(c.exists("doo"), true);
195	ASSERT_EQUAL(c.exists("foo"), false);
196	ASSERT_EQUAL(c.renamenx("doo", "foo"), true);
197	ASSERT_EQUAL(c.exists("doo"), false);
198	ASSERT_EQUAL(c.exists("foo"), true);
199	ASSERT_EQUAL(c.renamenx("goo", "foo"), false);
200	ASSERT_EQUAL(c.exists("foo"), true);
201	ASSERT_EQUAL(c.exists("goo"), true);
202	}
203
204	test("dbsize");
205	{
206	ASSERT_GT(c.dbsize(), 0L);
207	}
208
209	test("expire");
210	{
211	c.expire("goo", 1);
212	#ifndef NDEBUG
213	cerr << "please wait a few seconds.." << endl;
214	#endif
215	sleep(2);
216	ASSERT_EQUAL(c.exists("goo"), false);
217	}
218
219	test("rpush");
220	{
221	ASSERT_EQUAL(c.exists("list1"), false);
222	c.rpush("list1", "val1");
223	ASSERT_EQUAL(c.llen("list1"), 1L);
224	ASSERT_EQUAL(c.type("list1"), redis::client::datatype_list);
225	c.rpush("list1", "val2");
226	ASSERT_EQUAL(c.llen("list1"), 2L);
227	ASSERT_EQUAL(c.lindex("list1", 0), string("val1"));
228	ASSERT_EQUAL(c.lindex("list1", 1), string("val2"));
229	}
230
231	test("lpush");
232	{
233	c.del("list1");
234	ASSERT_EQUAL(c.exists("list1"), false);
235	c.lpush("list1", "val1");
236	ASSERT_EQUAL(c.type("list1"), redis::client::datatype_list);
237	ASSERT_EQUAL(c.llen("list1"), 1L);
238	c.lpush("list1", "val2");
239	ASSERT_EQUAL(c.llen("list1"), 2L);
240	ASSERT_EQUAL(c.lindex("list1", 0), string("val2"));
241	ASSERT_EQUAL(c.lindex("list1", 1), string("val1"));
242	}
243
244	test("llen");
245	{
246	c.del("list1");
247	ASSERT_EQUAL(c.exists("list1"), false);
248	ASSERT_EQUAL(c.llen("list1"), 0L);
249	c.lpush("list1", "x");
250	ASSERT_EQUAL(c.llen("list1"), 1L);
251	c.lpush("list1", "y");
252	ASSERT_EQUAL(c.llen("list1"), 2L);
253	}
254
255	test("lrange");
256	{
257	ASSERT_EQUAL(c.exists("list1"), true);
258	ASSERT_EQUAL(c.llen("list1"), 2L);
259	redis::client::string_vector vals;
260	ASSERT_EQUAL(c.lrange("list1", 0, -1, vals), 2L);
261	ASSERT_EQUAL(vals.size(), 2UL);
262	ASSERT_EQUAL(vals[0], string("y"));
263	ASSERT_EQUAL(vals[1], string("x"));
264	}
265
266	test("lrange with subset of full list");
267	{
268	ASSERT_EQUAL(c.exists("list1"), true);
269	ASSERT_EQUAL(c.llen("list1"), 2L);
270	redis::client::string_vector vals;
271	ASSERT_EQUAL(c.lrange("list1", 0, 1, vals), 2L); // inclusive, so entire list
272	ASSERT_EQUAL(vals.size(), 2UL);
273	ASSERT_EQUAL(vals[0], string("y"));
274	ASSERT_EQUAL(vals[1], string("x"));
275
276	redis::client::string_vector vals2;
277	ASSERT_EQUAL(c.lrange("list1", 0, 0, vals2), 1L); // inclusive, so first item
278	ASSERT_EQUAL(vals2.size(), 1UL);
279	ASSERT_EQUAL(vals2[0], string("y"));
280
281	redis::client::string_vector vals3;
282	ASSERT_EQUAL(c.lrange("list1", -1, -1, vals3), 1L); // inclusive, so first item
283	ASSERT_EQUAL(vals3.size(), 1UL);
284	ASSERT_EQUAL(vals3[0], string("x"));
285	}
286
287	test("get_list");
288	{
289	ASSERT_EQUAL(c.exists("list1"), true);
290	ASSERT_EQUAL(c.llen("list1"), 2L);
291	redis::client::string_vector vals;
292	ASSERT_EQUAL(c.get_list("list1", vals), 2L);
293	ASSERT_EQUAL(vals.size(), 2UL);
294	ASSERT_EQUAL(vals[0], string("y"));
295	ASSERT_EQUAL(vals[1], string("x"));
296	}
297
298	test("ltrim");
299	{
300	ASSERT_EQUAL(c.exists("list1"), true);
301	ASSERT_EQUAL(c.llen("list1"), 2L);
302	c.ltrim("list1", 0, 0);
303	ASSERT_EQUAL(c.exists("list1"), true);
304	ASSERT_EQUAL(c.llen("list1"), 1L);
305	redis::client::string_vector vals;
306	ASSERT_EQUAL(c.get_list("list1", vals), 1L);
307	ASSERT_EQUAL(vals[0], string("y"));
308	}
309
310	test("lindex");
311	{
312	ASSERT_EQUAL(c.lindex("list1", 0), string("y"));
313	c.rpush("list1", "x");
314	ASSERT_EQUAL(c.llen("list1"), 2L);
315	ASSERT_EQUAL(c.lindex("list1", -1), string("x"));
316	ASSERT_EQUAL(c.lindex("list1", 1), string("x"));
317	}
318
319	test("lset");
320	{
321	c.lset("list1", 1, "z");
322	ASSERT_EQUAL(c.lindex("list1", 1), string("z"));
323	ASSERT_EQUAL(c.llen("list1"), 2L);
324	}
325
326	test("lrem");
327	{
328	c.lrem("list1", 1, "z");
329	ASSERT_EQUAL(c.llen("list1"), 1L);
330	ASSERT_EQUAL(c.lindex("list1", 0), string("y"));
331
332	// list1 = [ y ]
333	ASSERT_EQUAL(c.lrem("list1", 0, "q"), 0L);
334
335	c.rpush("list1", "z");
336	c.rpush("list1", "z");
337	c.rpush("list1", "z");
338	c.rpush("list1", "a");
339	// list1 = [ y, z, z, z, a ]
340	ASSERT_EQUAL(c.lrem("list1", 2, "z"), 2L);
341	// list1 = [ y, z, a ]
342	ASSERT_EQUAL(c.llen("list1"), 3L);
343	ASSERT_EQUAL(c.lindex("list1", 0), string("y"));
344	ASSERT_EQUAL(c.lindex("list1", 1), string("z"));
345	ASSERT_EQUAL(c.lindex("list1", 2), string("a"));
346
347	c.rpush("list1", "z");
348	// list1 = [ y, z, a, z ]
349	ASSERT_EQUAL(c.lrem("list1", -1, "z"), 1L); // <0 => rm R to L
350	// list1 = [ y, z, a ]
351	ASSERT_EQUAL(c.llen("list1"), 3L);
352	ASSERT_EQUAL(c.lindex("list1", 0), string("y"));
353	ASSERT_EQUAL(c.lindex("list1", 1), string("z"));
354	ASSERT_EQUAL(c.lindex("list1", 2), string("a"));
355
356	// list1 = [ y, z, a ]
357	// try to remove 5 'a's but there's only 1 ... no problem.
358	ASSERT_EQUAL(c.lrem("list1", 5, "a"), 1L);
359	// list1 = [ y, z ]
360	ASSERT_EQUAL(c.llen("list1"), 2L);
361	ASSERT_EQUAL(c.lindex("list1", 0), string("y"));
362	ASSERT_EQUAL(c.lindex("list1", 1), string("z"));
363	}
364
365	test("lrem_exact");
366	{
367	// list1 = [ y, z ]
368
369	// try to remove 5 'z's but there's only 1 ... now it's a problem.
370
371	bool threw = false;
372
373	try
374	{
375	c.lrem_exact("list1", 5, "z");
376	}
377	catch (redis::value_error & e)
378	{
379	threw = true;
380	}
381
382	ASSERT_EQUAL(threw, true);
383
384	// This DOES remove the one 'z' though
385	// list1 = [ y ]
386
387	ASSERT_EQUAL(c.llen("list1"), 1L);
388	ASSERT_EQUAL(c.lindex("list1", 0), string("y"));
389	}
390
391	test("lpop");
392	{
393	ASSERT_EQUAL(c.lpop("list1"), string("y"));
394	// list1 = []
395	ASSERT_EQUAL(c.lpop("list1"), redis::client::missing_value);
396	}
397
398	test("rpop");
399	{
400	c.rpush("list1", "hello");
401	c.rpush("list1", "world");
402	ASSERT_EQUAL(c.rpop("list1"), string("world"));
403	ASSERT_EQUAL(c.rpop("list1"), string("hello"));
404	ASSERT_EQUAL(c.lpop("list1"), redis::client::missing_value);
405	}
406
407	test("sadd");
408	{
409	c.sadd("set1", "sval1");
410	ASSERT_EQUAL(c.exists("set1"), true);
411	ASSERT_EQUAL(c.type("set1"), redis::client::datatype_set);
412	ASSERT_EQUAL(c.sismember("set1", "sval1"), true);
413	}
414
415	test("srem");
416	{
417	c.srem("set1", "sval1");
418	ASSERT_EQUAL(c.exists("set1"), true);
419	ASSERT_EQUAL(c.type("set1"), redis::client::datatype_set);
420	ASSERT_EQUAL(c.sismember("set1", "sval1"), false);
421	}
422
423	test("smove");
424	{
425	c.sadd("set1", "hi");
426	// set1 = { hi }
427	ASSERT_EQUAL(c.exists("set2"), false);
428	c.smove("set1", "set2", "hi");
429	ASSERT_EQUAL(c.sismember("set1", "hi"), false);
430	ASSERT_EQUAL(c.sismember("set2", "hi"), true);
431	}
432
433	test("scard");
434	{
435	ASSERT_EQUAL(c.scard("set1"), 0L);
436	ASSERT_EQUAL(c.scard("set2"), 1L);
437	}
438
439	test("sismember");
440	{
441	// see above
442	}
443
444	test("smembers");
445	{
446	c.sadd("set2", "bye");
447	redis::client::string_set members;
448	ASSERT_EQUAL(c.smembers("set2", members), 2L);
449	ASSERT_EQUAL(members.size(), 2UL);
450	ASSERT_NOT_EQUAL(members.find("hi"), members.end());
451	ASSERT_NOT_EQUAL(members.find("bye"), members.end());
452	}
453
454	test("sinter");
455	{
456	c.sadd("set3", "bye");
457	c.sadd("set3", "bye2");
458	redis::client::string_vector keys;
459	keys.push_back("set2");
460	keys.push_back("set3");
461	redis::client::string_set intersection;
462	ASSERT_EQUAL(c.sinter(keys, intersection), 1L);
463	ASSERT_EQUAL(intersection.size(), 1UL);
464	ASSERT_NOT_EQUAL(intersection.find("bye"), intersection.end());
465	}
466
467	test("sinterstore");
468	{
469	c.sadd("seta", "1");
470	c.sadd("seta", "2");
471	c.sadd("seta", "3");
472
473	c.sadd("setb", "2");
474	c.sadd("setb", "3");
475	c.sadd("setb", "4");
476
477	redis::client::string_vector keys;
478	keys.push_back("seta");
479	keys.push_back("setb");
480
481	c.sinterstore("setc", keys);
482
483	redis::client::string_set members;
484	ASSERT_EQUAL(c.smembers("setc", members), 2L);
485	ASSERT_EQUAL(members.size(), 2UL);
486	ASSERT_NOT_EQUAL(members.find("2"), members.end());
487	ASSERT_NOT_EQUAL(members.find("3"), members.end());
488	}
489
490	test("sunion");
491	{
492	c.sadd("setd", "1");
493	c.sadd("sete", "2");
494	redis::client::string_vector keys;
495	keys.push_back("setd");
496	keys.push_back("sete");
497	redis::client::string_set a_union;
498	ASSERT_EQUAL(c.sunion(keys, a_union), 2L);
499	ASSERT_EQUAL(a_union.size(), 2UL);
500	ASSERT_NOT_EQUAL(a_union.find("1"), a_union.end());
501	ASSERT_NOT_EQUAL(a_union.find("2"), a_union.end());
502	}
503
504	test("sunionstore");
505	{
506	c.sadd("setf", "1");
507	c.sadd("setg", "2");
508
509	redis::client::string_vector keys;
510	keys.push_back("setf");
511	keys.push_back("setg");
512
513	c.sunionstore("seth", keys);
514
515	redis::client::string_set members;
516	ASSERT_EQUAL(c.smembers("seth", members), 2L);
517	ASSERT_EQUAL(members.size(), 2UL);
518	ASSERT_NOT_EQUAL(members.find("1"), members.end());
519	ASSERT_NOT_EQUAL(members.find("2"), members.end());
520	}
521
522	test("move");
523	{
524	c.select(14);
525	ASSERT_EQUAL(c.exists("ttt"), false);
526	c.select(15);
527	c.set("ttt", "uuu");
528	c.move("ttt", 14);
529	c.select(14);
530	ASSERT_EQUAL(c.exists("ttt"), true);
531	c.select(15);
532	ASSERT_EQUAL(c.exists("ttt"), false);
533	}
534
535	test("move should fail since key exists already");
536	{
537	c.select(14);
538	c.set("ttt", "xxx");
539	c.select(15);
540	c.set("ttt", "uuu");
541
542	bool threw = false;
543
544	try
545	{
546	c.move("ttt", 14);
547	}
548	catch (redis::protocol_error & e)
549	{
550	threw = true;
551	}
552
553	ASSERT_EQUAL(threw, true);
554
555	c.select(14);
556	ASSERT_EQUAL(c.exists("ttt"), true);
557	c.select(15);
558	ASSERT_EQUAL(c.exists("ttt"), true);
559	}
560
561	test("sort ascending");
562	{
563	c.sadd("sort1", "3");
564	c.sadd("sort1", "2");
565	c.sadd("sort1", "1");
566
567	redis::client::string_vector sorted;
568	ASSERT_EQUAL(c.sort("sort1", sorted), 3L);
569	ASSERT_EQUAL(sorted.size(), 3UL);
570	ASSERT_EQUAL(sorted[0], string("1"));
571	ASSERT_EQUAL(sorted[1], string("2"));
572	ASSERT_EQUAL(sorted[2], string("3"));
573	}
574
575	test("sort descending");
576	{
577	redis::client::string_vector sorted;
578	ASSERT_EQUAL(c.sort("sort1", sorted, redis::client::sort_order_descending), 3L);
579	ASSERT_EQUAL(sorted.size(), 3UL);
580	ASSERT_EQUAL(sorted[0], string("3"));
581	ASSERT_EQUAL(sorted[1], string("2"));
582	ASSERT_EQUAL(sorted[2], string("1"));
583	}
584
585	test("sort with limit");
586	{
587	// TODO
588	}
589
590	test("sort lexicographically");
591	{
592	// TODO
593	}
594
595	test("sort with pattern and weights");
596	{
597	// TODO
598	}
599
600	test("save");
601	{
602	c.save();
603	}
604
605	test("bgsave");
606	{
607	c.bgsave();
608	}
609
610	test("lastsave");
611	{
612	ASSERT_GT(c.lastsave(), 0L);
613	}
614
615	test("shutdown");
616	{
617	// You can test this if you really want to ...
618	// c.shutdown();
619	}
620	}
621	catch (redis::redis_error & e)
622	{
623	cerr << "got exception: " << string(e) << endl << "FAIL" << endl;
624	return 1;
625	}
626
627	cout << endl << "testing completed successfully" << endl;
628	return 0;
629	}