X-Git-Url: https://git.saurik.com/redis.git/blobdiff_plain/93ea375904fa2a5d1cab110698d15f43e63d84f1..57172ffb316b5e681c4f515927894f5129739237:/client-libraries/cpp/test_client.cpp?ds=sidebyside

diff --git a/client-libraries/cpp/test_client.cpp b/client-libraries/cpp/test_client.cpp
new file mode 100644
index 00000000..c0891cb0
--- /dev/null
+++ b/client-libraries/cpp/test_client.cpp
@@ -0,0 +1,629 @@
+#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;
+}