Blueprint 'Test memcached mode of box':

Write method in the MemcachedConnection class was overlapped for correct
work with memcached protocols. Memcached tests was cleanupped.

test/box_memcached/binary-get.test

+# encoding: tarantool
 blobs_list = [ "mooo\0", "mumble\0\0\0\0\r\rblarg", "\0", "\r" ]
 
 for i in range(len(blobs_list)):
@@ -6,8 +7,8 @@ for i in range(len(blobs_list)):
     blob_len = len(blob)
 
     print "len is %d" % blob_len
-    server.memcached.execute("set %s 0 0 %d\r\n%s" % (key, blob_len, blob), silent=False)
-    server.memcached.execute("get %s" % key, silent=False)
+    exec memcached "set %s 0 0 %d\r\n%s\r\n" % (key, blob_len, blob)
+    exec memcached "get %s\r\n" % key
 
 # resore default suite config
 server.stop()

test/box_memcached/bogus-commands.result

-boguscommand slkdsldkfjsd
+boguscommand slkdsldkfjsd
 CLIENT_ERROR bad command line format
 

test/box_memcached/bogus-commands.test

-server.memcached.execute("boguscommand slkdsldkfjsd", silent=False)
+# encoding: tarantool
+exec memcached "boguscommand slkdsldkfjsd\r\n"
 # vim: syntax=python

test/box_memcached/cas.result

 cas bad blah 0 0 0
-
 CLIENT_ERROR bad command line format
 
 cas bad 0 blah 0 0
-
 CLIENT_ERROR bad command line format
 
 cas bad 0 0 blah 0
-
 CLIENT_ERROR bad command line format
 
 cas bad 0 0 0 blah
-
 CLIENT_ERROR bad command line format
 
 # gets foo (should not exist) 
-gets foo
+gets foo
 END
 
 # set foo 
 set foo 0 0 6
-barval
+barval
 STORED
 
 # gets foo and verify identifier exists 
-gets foo
+gets foo
 VALUE foo 0 6 42
 barval
 END
 
 # cas fail 
 cas foo 0 0 6 123
-barva2
+barva2
 EXISTS
 
 # gets foo and verify identifier exists 
-gets foo
+gets foo
+
 VALUE foo 0 6 42
 barval
 END
 
 # cas success 
 cas foo 0 0 6 42
-barva2
+barva2
 STORED
 
 # cas failure (reusing the same key) 
 cas foo 0 0 6 42
-barva2
+barva2
 EXISTS
 
 # delete foo 
 delete foo
-
 DELETED
 
 # cas missing 
 cas foo 0 0 6 42
-barva2
+barva2
 NOT_FOUND
 
 # set foo1 
 set foo1 0 0 1
-1
+1
 STORED
 
 # set foo2 
 set foo2 0 0 1
-2
+2
 STORED
 
 # gets foo1 check 
-gets foo1
+gets foo1
+
 VALUE foo1 0 1 44
 1
 END
 
 # gets foo2 check 
-gets foo2
+gets foo2
+
 VALUE foo2 0 1 45
 2
 END
 
 # validate foo1 != foo2 
-success: foo1_cas (44) != foo2_cas (45)
+pass: foo1_cas != foo2_cas
 # gets foo from memcached1 - should success 
-gets foo1
+gets foo1
+
 VALUE foo1 0 1 44
 1
 END
 
 # gets foo from memcached2 - should success 
-gets foo1
+gets foo1
+
 VALUE foo1 0 1 44
 1
 END
 
 # send 'cas foo1' from memcached1 
 cas foo1 0 0 6 44
-barva2
+barva2
+
 # send 'cas foo1' from memcached2 
 cas foo1 0 0 4 44
-pear
+pear
+
 # recv reply 'cas foo1' from memcached1 
 # recv reply 'cas foo1' from memcached2 
 race cas: pass
 # set bug15 
 set bug15 0 0 1
-0
+0
 STORED
 
 # Check out the first gets. 
 # Increment. 
-incr bug15 1
+incr bug15 1
 1
 
 # Validate a changed CAS. 
 # validate bug15_cas != next_bug15_cas 
-success: bug15_cas != next_bug15_cas
+pass: bug15_cas != next_bug15_cas

test/box_memcached/cas.test

-from lib.memcached import Memcached
+# encoding: tarantool
+from lib.memcached_connection import MemcachedConnection
 
-server.memcached.execute("cas bad blah 0 0 0\r\n", silent=False)
-server.memcached.execute("cas bad 0 blah 0 0\r\n", silent=False)
-server.memcached.execute("cas bad 0 0 blah 0\r\n", silent=False)
-server.memcached.execute("cas bad 0 0 0 blah\r\n", silent=False)
+exec memcached "cas bad blah 0 0 0\r\n"
+exec memcached "cas bad 0 blah 0 0\r\n"
+exec memcached "cas bad 0 0 blah 0\r\n"
+exec memcached "cas bad 0 0 0 blah\r\n"
 
 print """# gets foo (should not exist) """
-server.memcached.execute("gets foo", silent=False)
+exec memcached "gets foo\r\n"
 
 print """# set foo """
-server.memcached.execute("set foo 0 0 6\r\nbarval", silent=False)
+exec memcached "set foo 0 0 6\r\nbarval\r\n"
 
 print """# gets foo and verify identifier exists """
-server.memcached.execute("gets foo", silent=False)
+exec memcached "gets foo\r\n"
 
 print """# cas fail """
-server.memcached.execute("cas foo 0 0 6 123\r\nbarva2", silent=False)
+exec memcached "cas foo 0 0 6 123\r\nbarva2\r\n"
 
 print """# gets foo and verify identifier exists """
-result = server.memcached.execute("gets foo", silent=False)
+result = server.memcached.execute("gets foo\r\n", silent=False)
 identifier = int(result.split()[4])
 
 print """# cas success """
-server.memcached.execute("cas foo 0 0 6 %d\r\nbarva2" % identifier, silent=False)
+exec memcached "cas foo 0 0 6 %d\r\nbarva2\r\n" % identifier
 
 print """# cas failure (reusing the same key) """
-server.memcached.execute("cas foo 0 0 6 %d\r\nbarva2" % identifier, silent=False)
+exec memcached "cas foo 0 0 6 %d\r\nbarva2\r\n" % identifier
 
 print """# delete foo """
-server.memcached.execute("delete foo\r\n", silent=False);
+exec memcached "delete foo\r\n"
 
 print """# cas missing """
-server.memcached.execute("cas foo 0 0 6 %d\r\nbarva2" % identifier, silent=False)
+exec memcached "cas foo 0 0 6 %d\r\nbarva2\r\n" % identifier
 
 print """# set foo1 """
-server.memcached.execute("set foo1 0 0 1\r\n1", silent=False)
+exec memcached "set foo1 0 0 1\r\n1\r\n"
 
 print """# set foo2 """
-server.memcached.execute("set foo2 0 0 1\r\n2", silent=False)
+exec memcached "set foo2 0 0 1\r\n2\r\n"
 
 print """# gets foo1 check """
-result = server.memcached.execute("gets foo1", silent=False)
+result = server.memcached.execute("gets foo1\r\n", silent=False)
 foo1_cas = int(result.split()[4])
 
 print """# gets foo2 check """
-result = server.memcached.execute("gets foo2", silent=False)
+result = server.memcached.execute("gets foo2\r\n", silent=False)
 foo2_cas = int(result.split()[4])
 
 print """# validate foo1 != foo2 """
 if foo1_cas != foo2_cas:
-    print "success: foo1_cas (%d) != foo2_cas (%d)" % (foo1_cas, foo2_cas)
+    print "pass: foo1_cas != foo2_cas"
 else:
-    print "fail: foo1_cas (%d) == foo2_cas (%d)" % (foo1_cas, foo2_cas)
+    print "fail: foo1_cas == foo2_cas"
 
 memcached1 = server.memcached
-memcached2 = Memcached('localhost', server.memcached_port)
+memcached2 = MemcachedConnection('localhost', server.memcached_port)
 
 print """# gets foo from memcached1 - should success """
-result = memcached1.execute("gets foo1", silent = False)
+result = memcached1.execute("gets foo1\r\n", silent = False)
 mem1_cas = int(result.split()[4])
 
 print """# gets foo from memcached2 - should success """
-result = memcached2.execute("gets foo1", silent = False)
+result = memcached2.execute("gets foo1\r\n", silent = False)
 mem2_cas = int(result.split()[4])
 
 print """# send 'cas foo1' from memcached1 """
-memcached1.sendCommands("cas foo1 0 0 6 %d\r\nbarva2" % mem1_cas, silent = False)
+memcached1.send("cas foo1 0 0 6 %d\r\nbarva2\r\n" % mem1_cas, silent = False)
 print """# send 'cas foo1' from memcached2 """
-memcached2.sendCommands("cas foo1 0 0 4 %d\r\npear" % mem2_cas, silent = False)
+memcached2.send("cas foo1 0 0 4 %d\r\npear\r\n" % mem2_cas, silent = False)
 
 print """# recv reply 'cas foo1' from memcached1 """
-result = memcached1.recvReply(silent = True)
+result = memcached1.recv(silent = True)
 mem1_cas_result = result.split()[0]
 print """# recv reply 'cas foo1' from memcached2 """
-result = memcached2.recvReply(silent = True)
+result = memcached2.recv(silent = True)
 mem2_cas_result = result.split()[0]
 
 if mem1_cas_result == "STORED" and mem2_cas_result == "EXISTS":
@@ -86,22 +87,21 @@ else:
     print "cas 2 = %s" % mem2_cas_result
 
 print """# set bug15 """
-server.memcached.execute("set bug15 0 0 1\r\n0", silent=False)
+exec memcached "set bug15 0 0 1\r\n0\r\n"
 
 print """# Check out the first gets. """
-result = server.memcached.execute("gets bug15", silent=True)
+result = server.memcached.execute("gets bug15\r\n", silent=True)
 bug15_cas = int(result.split()[4])
 
 print """# Increment. """
-server.memcached.execute("incr bug15 1", silent=False)
-
+exec memcached "incr bug15 1\r\n"
 print """# Validate a changed CAS. """
-result = server.memcached.execute("gets bug15", silent=True)
+result = server.memcached.execute("gets bug15\r\n", silent=True)
 next_bug15_cas = int(result.split()[4])
 
 print """# validate bug15_cas != next_bug15_cas """
 if bug15_cas != next_bug15_cas:
-    print "success: bug15_cas != next_bug15_cas"
+    print "pass: bug15_cas != next_bug15_cas"
 else:
     print "fail: bug15_cas == next_bug15_cas"
 

test/box_memcached/expirations.result

 # expire: after 1 second
 # set foo
 set foo 0 1 6
-fooval
+fooval
 STORED
 
 # foo shoud be exists
-get foo
+get foo
 VALUE foo 0 6
 fooval
 END
 
 # foo shoud expired
-get foo
+get foo
 END
 
 # expire: time - 1 second
 # set foo
 # foo shoud expired
-get foo
+get foo
 END
 
 # expire: time + 1 second
 # set foo
 # foo shoud be exists
-get foo
+get foo
 VALUE foo 0 6
 fooval
 END
 
 # foo shoud expired
-get foo
+get foo
 END
 
 # expire: time - 20 second
 # set boo
 # foo shoud expired
-get boo
+get boo
 END
 
 # expire: after 2 second
 # add add
 add add 0 1 6
-addval
+addval
 STORED
 
 # readd add - shoud be fail
 add add 0 1 7
-addval1
+addval1
 NOT_STORED
 
 # readd add - shoud be success
 add add 0 1 7
-addval2
+addval2
 STORED
 

test/box_memcached/expirations.test

+# encoding: tarantool
 import time
 
 print """# expire: after 1 second"""
 
 print """# set foo"""
-server.memcached.execute("set foo 0 1 6\r\nfooval", silent=False)
+exec memcached "set foo 0 1 6\r\nfooval\r\n"
 
 print """# foo shoud be exists"""
-server.memcached.execute("get foo", silent=False)
+exec memcached "get foo\r\n"
 
 time.sleep(1.5)
 print """# foo shoud expired"""
-server.memcached.execute("get foo", silent=False)
+exec memcached "get foo\r\n"
 
 
 print """# expire: time - 1 second"""
 expire = time.time() - 1
 
 print """# set foo"""
-server.memcached.execute("set foo 0 %d 6\r\nfooval" % expire, silent=True)
+server.memcached.execute("set foo 0 %d 6\r\nfooval\r\n" % expire, silent=True)
 
 print """# foo shoud expired"""
-server.memcached.execute("get foo", silent=False)
+exec memcached "get foo\r\n"
 
 
 print """# expire: time + 1 second"""
 expire = time.time() + 1
 
 print """# set foo"""
-server.memcached.execute("set foo 0 %d 6\r\nfooval" % expire, silent=True)
+server.memcached.execute("set foo 0 %d 6\r\nfooval\r\n" % expire, silent=True)
 
 print """# foo shoud be exists"""
-server.memcached.execute("get foo", silent=False)
+exec memcached "get foo\r\n"
 
 time.sleep(2.2)
 print """# foo shoud expired"""
-server.memcached.execute("get foo", silent=False)
+exec memcached "get foo\r\n"
 
 
 print """# expire: time - 20 second"""
 expire = time.time() - 20
 
 print """# set boo"""
-server.memcached.execute("set boo 0 %d 6\r\nbooval" % expire, silent=True)
+server.memcached.execute("set boo 0 %d 6\r\nbooval\r\n" % expire, silent=True)
 
 print """# foo shoud expired"""
-server.memcached.execute("get boo", silent=False)
+exec memcached "get boo\r\n"
 
 
 print """# expire: after 2 second"""
 
 print """# add add"""
-server.memcached.execute("add add 0 1 6\r\naddval", silent=False)
+exec memcached "add add 0 1 6\r\naddval\r\n"
 
 print """# readd add - shoud be fail"""
-server.memcached.execute("add add 0 1 7\r\naddval1", silent=False)
+exec memcached "add add 0 1 7\r\naddval1\r\n"
 
 time.sleep(2.2)
 print """# readd add - shoud be success"""
-server.memcached.execute("add add 0 1 7\r\naddval2", silent=False)
+exec memcached "add add 0 1 7\r\naddval2\r\n"
 
 # resore default suite config
 server.stop()

test/box_memcached/flags.result

 set foo 0 0 6
-fooval
+fooval
 STORED
 
-gets foo
+gets foo
+
 VALUE foo 0 6 42
 fooval
 END
 
 success: flags (0x0) == ret_flags (0x0)
 set foo 123 0 6
-fooval
+fooval
 STORED
 
-gets foo
+gets foo
+
 VALUE foo 123 6 43
 fooval
 END
 
 success: flags (0x7b) == ret_flags (0x7b)
 set foo 65535 0 6
-fooval
+fooval
 STORED
 
-gets foo
+gets foo
+
 VALUE foo 65535 6 44
 fooval
 END

test/box_memcached/flags.test

+# encoding: tarantool
 flags_list = [ 0x0, 0x7b, 0xffff ]
 
 for flags in flags_list:
-    server.memcached.execute("set foo %d 0 6\r\nfooval" % flags, silent=False)
-    result = server.memcached.execute("gets foo", silent=False);
+    exec memcached "set foo %d 0 6\r\nfooval\r\n" % flags
+    result = server.memcached.execute("gets foo\r\n", silent=False);
     ret_flags = int(result.split()[2])
     if flags == ret_flags:
         print "success: flags (0x%x) == ret_flags (0x%x)" % (flags, ret_flags)

test/box_memcached/flush-all.result

 # Test flush_all with zero delay. 
 set foo 0 0 6
-fooval
+fooval
 STORED
 
-get foo
+get foo
 VALUE foo 0 6
 fooval
 END
 
-flush_all
+flush_all
 OK
 
-get foo
+get foo
 END
 
 # check that flush_all doesn't blow away items that immediately get set 
 set foo 0 0 3
-new
+new
 STORED
 
-get foo
+get foo
 VALUE foo 0 3
 new
 END
@@ -28,20 +28,20 @@ END
 flush_all time + 2
 OK
 
-get foo
+get foo
 VALUE foo 0 3
 new
 END
 
 set foo 0 0 3
-123
+123
 STORED
 
-get foo
+get foo
 VALUE foo 0 3
 123
 END
 
-get foo
+get foo
 END
 

test/box_memcached/flush-all.test

+# encoding: tarantool
 import time
 
 print """# Test flush_all with zero delay. """
-server.memcached.execute("set foo 0 0 6\r\nfooval", silent=False)
-server.memcached.execute("get foo", silent=False)
-server.memcached.execute("flush_all", silent=False)
-server.memcached.execute("get foo", silent=False)
+exec memcached "set foo 0 0 6\r\nfooval\r\n"
+exec memcached "get foo\r\n"
+exec memcached "flush_all\r\n"
+exec memcached "get foo\r\n"
 
 print """# check that flush_all doesn't blow away items that immediately get set """
-server.memcached.execute("set foo 0 0 3\r\nnew", silent=False)
-server.memcached.execute("get foo", silent=False)
+exec memcached "set foo 0 0 3\r\nnew\r\n"
+exec memcached "get foo\r\n"
 
 print """# and the other form, specifying a flush_all time... """
 expire = time.time() + 2
 print "flush_all time + 2"
-print server.memcached.execute("flush_all %d" % expire, silent=True)
-server.memcached.execute("get foo", silent=False)
+print server.memcached.execute("flush_all %d\r\n" % expire, silent=True)
+exec memcached "get foo\r\n"
 
-server.memcached.execute("set foo 0 0 3\r\n123", silent=False)
-server.memcached.execute("get foo", silent=False)
+exec memcached "set foo 0 0 3\r\n123\r\n"
+exec memcached "get foo\r\n"
 time.sleep(2.2)
-server.memcached.execute("get foo", silent=False)
+exec memcached "get foo\r\n"
 
 # resore default suite config
 server.stop()

test/box_memcached/getset.test

+# encoding: tarantool
 print """# set foo (and should get it) """
-server.memcached.execute("set foo 0 0 6\r\nfooval", silent=False)
-server.memcached.execute("get foo", silent=False)
+exec memcached "set foo 0 0 6\r\nfooval\r\n"
+exec memcached "get foo\r\n"
 
 print """# add bar (and should get it)"""
-server.memcached.execute("set bar 0 0 6\r\nbarval", silent=False)
-server.memcached.execute("get bar", silent=False)
+exec memcached "set bar 0 0 6\r\nbarval\r\n"
+exec memcached "get bar\r\n"
 
 print """# add foo (but shouldn't get new value)"""
-server.memcached.execute("add foo 0 0 5\r\nfoov2", silent=False)
-server.memcached.execute("get foo", silent=False)
+exec memcached "add foo 0 0 5\r\nfoov2\r\n"
+exec memcached "get foo\r\n"
 
 print """# replace bar (should work)"""
-server.memcached.execute("replace bar 0 0 6\r\nbarva2", silent=False);
-server.memcached.execute("get bar", silent=False)
+exec memcached "replace bar 0 0 6\r\nbarva2\r\n"
+exec memcached "get bar\r\n"
 
 print """# replace notexist (shouldn't work)"""
-server.memcached.execute("replace notexist 0 0 6\r\nbarva2", silent=False);
-server.memcached.execute("get notexist", silent=False)
+exec memcached "replace notexist 0 0 6\r\nbarva2\r\n"
+exec memcached "get notexist\r\n"
 
 print """# delete foo"""
-server.memcached.execute("delete foo", silent=False);
-server.memcached.execute("get foo", silent=False)
+exec memcached "delete foo\r\n"
+exec memcached "get foo\r\n"
 
 print """# delete foo again. not found this time."""
-server.memcached.execute("delete foo", silent=False);
-server.memcached.execute("get foo", silent=False)
+exec memcached "delete foo\r\n"
+exec memcached "get foo\r\n"
 
 print """# add moo"""
-server.memcached.execute("add moo 0 0 6\r\nmooval", silent=False);
-server.memcached.execute("get moo", silent=False);
+exec memcached "add moo 0 0 6\r\nmooval\r\n"
+exec memcached "get moo\r\n"
 
 print """# check-and-set (cas) failure case, try to set value with incorrect cas unique val"""
-server.memcached.execute("cas moo 0 0 6 0\r\nMOOVAL", silent=False);
-server.memcached.execute("get moo", silent=False);
+exec memcached "cas moo 0 0 6 0\r\nMOOVAL\r\n"
+exec memcached "get moo\r\n"
 
-result = server.memcached.execute("gets moo", silent=False);
+result = server.memcached.execute("gets moo\r\n", silent=True)
 unique_id = int(result.split()[4])
 
 print """# now test that we can store moo with the correct unique id"""
-server.memcached.execute("cas moo 0 0 6 %d\r\nMOOVAL" % unique_id, silent=False);
-server.memcached.execute("get moo", silent=False);
+server.memcached.execute("cas moo 0 0 6 %d\r\nMOOVAL\r\n" % unique_id, silent=True)
+exec memcached "get moo\r\n"
 
-server.memcached.execute("set foo 0 0 6\r\nfooval\r\ndelete foo\r\nset foo 0 0 6\r\nfooval\r\ndelete foo", silent=False);
+exec memcached "set foo 0 0 6\r\nfooval\r\ndelete foo\r\nset foo 0 0 6\r\nfooval\r\ndelete foo\r\n"
 
 len = 1024
 while len < (1024 * 1028):
@@ -49,15 +50,15 @@ while len < (1024 * 1028):
     if len > (1024 * 1024):
         print """# Ensure causing a memory overflow doesn't leave stale data."""
         print "# set small data: - should pass"
-        server.memcached.execute("set foo_%d 0 0 3\r\nMOO" % (len), silent=False)
-        server.memcached.execute("get moo", silent=False)
+        exec memcached "set foo_%d 0 0 3\r\nMOO\r\n" % (len)
+        exec memcached "get foo_%d\r\n" % (len)
         print "# set big data: - should fail"
-        print server.memcached.execute("set foo_%d 0 0 %d\r\n%s" % (len, len, val), silent=False)
-        server.memcached.execute("get moo", silent=False)
+        print "set foo_%d 0 0 %d\r\n<big-data>\r\n" % (len, len)
+        print server.memcached.execute("set foo_%d 0 0 %d\r\n%s\r\n" % (len, len, val), silent=True)
     else:
         print "# set big data: - should pass"
-        print server.memcached.execute("set foo_%d 0 0 %d\r\n%s" % (len, len, val), silent=False)
-        server.memcached.execute("get moo", silent=False)
+        print "set foo_%d 0 0 %d\r\n<big-data>\r\n" % (len, len)
+        print server.memcached.execute("set foo_%d 0 0 %d\r\n%s\r\n" % (len, len, val), silent=True)
     len += 1024 * 512
 
 # resore default suite config

test/box_memcached/incrdecr.result

 # incr/decr big value 
 set bug21 0 0 19
-9223372036854775807
+9223372036854775807
 STORED
 
-incr bug21 1
+incr bug21 1
 9223372036854775808
 
-incr bug21 1
+incr bug21 1
 9223372036854775809
 
-decr bug21 1
+decr bug21 1
 9223372036854775808
 
 # underflow protection 
 set num 0 0 1
-1
+1
 STORED
 
-incr num 1
+incr num 1
 2
 
-incr num 8
+incr num 8
 10
 
-decr num 1
+decr num 1
 9
 
-decr num 9
+decr num 9
 0
 
-decr num 5
+decr num 5
 0
 
 # 32-bit value 
 set num 0 0 10
-4294967296
+4294967296
 STORED
 
-incr num 1
+incr num 1
 4294967297
 
 # overflow value 
 set num 0 0 20
-18446744073709551615
+18446744073709551615
 STORED
 
-incr num 1
+incr num 1
 0
 
 # bogus 
-decr bogus 1
+decr bogus 1
 NOT_FOUND
 
-decr incr 1
+decr incr 1
 NOT_FOUND
 
 # bit increment 
 set bigincr 0 0 1
-0
+0
 STORED
 
-incr num 18446744073709551610
+incr num 18446744073709551610
 18446744073709551610
 
 # incr text value error 
 set text 0 0 2
-hi
+hi
 STORED
 
-incr text 1
+incr text 1
 CLIENT_ERROR cannot increment or decrement non-numeric value
 

test/box_memcached/incrdecr.test

+# encoding: tarantool
 print """# incr/decr big value """
-server.memcached.execute("set bug21 0 0 19\r\n9223372036854775807", silent=False)
-server.memcached.execute("incr bug21 1", silent=False)
-server.memcached.execute("incr bug21 1", silent=False)
-server.memcached.execute("decr bug21 1", silent=False)
+exec memcached "set bug21 0 0 19\r\n9223372036854775807\r\n"
+exec memcached "incr bug21 1\r\n"
+exec memcached "incr bug21 1\r\n"
+exec memcached "decr bug21 1\r\n"
 
 print """# underflow protection """
-server.memcached.execute("set num 0 0 1\r\n1", silent=False)
-server.memcached.execute("incr num 1", silent=False)
-server.memcached.execute("incr num 8", silent=False)
-server.memcached.execute("decr num 1", silent=False)
-server.memcached.execute("decr num 9", silent=False)
-server.memcached.execute("decr num 5", silent=False)
+exec memcached "set num 0 0 1\r\n1\r\n"
+exec memcached "incr num 1\r\n"
+exec memcached "incr num 8\r\n"
+exec memcached "decr num 1\r\n"
+exec memcached "decr num 9\r\n"
+exec memcached "decr num 5\r\n"
 
 print """# 32-bit value """
-server.memcached.execute("set num 0 0 10\r\n4294967296", silent=False)
-server.memcached.execute("incr num 1", silent=False)
+exec memcached "set num 0 0 10\r\n4294967296\r\n"
+exec memcached "incr num 1\r\n"
 
 print """# overflow value """
-server.memcached.execute("set num 0 0 20\r\n18446744073709551615", silent=False)
-server.memcached.execute("incr num 1", silent=False)
+exec memcached "set num 0 0 20\r\n18446744073709551615\r\n"
+exec memcached "incr num 1\r\n"
 
 print """# bogus """
-server.memcached.execute("decr bogus 1", silent=False)
-server.memcached.execute("decr incr 1", silent=False)
+exec memcached "decr bogus 1\r\n"
+exec memcached "decr incr 1\r\n"
 
 print """# bit increment """
-server.memcached.execute("set bigincr 0 0 1\r\n0", silent=False)
-server.memcached.execute("incr num 18446744073709551610", silent=False)
+exec memcached "set bigincr 0 0 1\r\n0\r\n"
+exec memcached "incr num 18446744073709551610\r\n"
 
 print """# incr text value error """
-server.memcached.execute("set text 0 0 2\r\nhi", silent=False)
-server.memcached.execute("incr text 1", silent=False)
+exec memcached "set text 0 0 2\r\nhi\r\n"
+exec memcached "incr text 1\r\n"
 
 # resore default suite config
 server.stop()

test/box_memcached/multiversioning.result

@@ -4,7 +4,8 @@ set big 0 0 262144
 STORED
 
 # send command 'get big' to firs memcached client 
-get big
+get big
+
 # send command 'delete big' to second client 
 # Store big in lower case via first memcached client 
 set big 0 0 262144

test/box_memcached/multiversioning.test

@@ -10,20 +10,20 @@ memcached2 = MemcachedConnection('localhost', server.memcached_port)
 
 print """# Store big in lower case via first memcached client """
 print "set big 0 0 %d\r\n<big-value-lower-case>" % buf_size
-print memcached1.execute("set big 0 0 %d\r\n%s" % (buf_size, buf), silent = True)
+print memcached1.execute("set big 0 0 %d\r\n%s\r\n" % (buf_size, buf), silent = True)
 
 print """# send command 'get big' to firs memcached client """
-memcached1.send_commands("get big", silent = False)
+memcached1.send("get big\r\n", silent = False)
 
 print """# send command 'delete big' to second client """
-memcached2.execute("delete big")
+memcached2.execute("delete big\r\n")
 
 print """# Store big in lower case via first memcached client """
 print "set big 0 0 %d\r\n<big-value-upper-case>" % buf_size
-print memcached2.execute("set big 0 0 %d\r\n%s" % (buf_size, buf_upper), silent = True)
+print memcached2.execute("set big 0 0 %d\r\n%s\r\n" % (buf_size, buf_upper), silent = True)
 
 print """# recv reply 'get big' from firs memcached client """
-reply = memcached1.recv_reply(silent = True).split('\r\n')[1]
+reply = memcached1.recv(silent = True).split('\r\n')[1]
 if buf == reply:
     print "succes: buf == reply"
 else:

test/box_memcached/noreply.result

 # Test that commands can take 'noreply' parameter. 
-flush_all noreply
+flush_all noreply
 
-flush_all 0 noreply
+flush_all 0 noreply
 
 add noreply:foo 0 0 1 noreply
-1
+1
 
-get noreply:foo
+get noreply:foo
 VALUE noreply:foo 0 1
 1
 END
 
 set noreply:foo 0 0 1 noreply
-2
+2
 
-get noreply:foo
+get noreply:foo
 VALUE noreply:foo 0 1
 2
 END
 
 replace noreply:foo 0 0 1 noreply
-3
+3
 
-get noreply:foo
+get noreply:foo
 VALUE noreply:foo 0 1
 3
 END
 
 append noreply:foo 0 0 1 noreply
-4
+4
 
-get noreply:foo
+get noreply:foo
 VALUE noreply:foo 0 2
 34
 END
 
 prepend noreply:foo 0 0 1 noreply
-5
+5
 
-get noreply:foo
+get noreply:foo
 VALUE noreply:foo 0 3
 534
 END
 
-gets noreply:foo
+gets noreply:foo
+
 VALUE noreply:foo 0 3 46
 534
 END
 
 cas noreply:foo 0 0 1 46 noreply
-6
+6
 
-get noreply:foo
+get noreply:foo
 VALUE noreply:foo 0 1
 6
 END
 
-incr noreply:foo 3 noreply
+incr noreply:foo 3 noreply
 
-get noreply:foo
+get noreply:foo
 VALUE noreply:foo 0 1
 9
 END
 
-decr noreply:foo 2 noreply
+decr noreply:foo 2 noreply
 
-get noreply:foo
+get noreply:foo
 VALUE noreply:foo 0 1
 7
 END
 
-delete noreply:foo noreply
+delete noreply:foo noreply
 
-get noreply:foo
+get noreply:foo
 END
 

test/box_memcached/noreply.test

+# encoding: tarantool
 print """# Test that commands can take 'noreply' parameter. """
-server.memcached.execute("flush_all noreply", silent = False)
-server.memcached.execute("flush_all 0 noreply", silent = False)
+exec memcached "flush_all noreply\r\n"
+exec memcached "flush_all 0 noreply\r\n"
 
-server.memcached.execute("add noreply:foo 0 0 1 noreply\r\n1", silent = False)
-server.memcached.execute("get noreply:foo", silent = False)
+exec memcached "add noreply:foo 0 0 1 noreply\r\n1\r\n"
+exec memcached "get noreply:foo\r\n"
 
-server.memcached.execute("set noreply:foo 0 0 1 noreply\r\n2", silent = False)
-server.memcached.execute("get noreply:foo", silent = False)
+exec memcached "set noreply:foo 0 0 1 noreply\r\n2\r\n"
+exec memcached "get noreply:foo\r\n"
 
-server.memcached.execute("replace noreply:foo 0 0 1 noreply\r\n3", silent = False)
-server.memcached.execute("get noreply:foo", silent = False)
+exec memcached "replace noreply:foo 0 0 1 noreply\r\n3\r\n"
+exec memcached "get noreply:foo\r\n"
 
-server.memcached.execute("append noreply:foo 0 0 1 noreply\r\n4", silent = False)
-server.memcached.execute("get noreply:foo", silent = False)
+exec memcached "append noreply:foo 0 0 1 noreply\r\n4\r\n"
+exec memcached "get noreply:foo\r\n"
 
-server.memcached.execute("prepend noreply:foo 0 0 1 noreply\r\n5", silent = False)
-server.memcached.execute("get noreply:foo", silent = False)
+exec memcached "prepend noreply:foo 0 0 1 noreply\r\n5\r\n"
+exec memcached "get noreply:foo\r\n"
 
-result = server.memcached.execute("gets noreply:foo", silent = False);
+result = server.memcached.execute("gets noreply:foo\r\n", silent = False);
 unique_id = int(result.split()[4])
 
-server.memcached.execute("cas noreply:foo 0 0 1 %d noreply\r\n6" % unique_id, silent = False)
-server.memcached.execute("get noreply:foo", silent = False)
+exec memcached "cas noreply:foo 0 0 1 %d noreply\r\n6\r\n" % unique_id
+exec memcached "get noreply:foo\r\n"
 
-server.memcached.execute("incr noreply:foo 3 noreply", silent = False)
-server.memcached.execute("get noreply:foo", silent = False)
+exec memcached "incr noreply:foo 3 noreply\r\n"
+exec memcached "get noreply:foo\r\n"
 
-server.memcached.execute("decr noreply:foo 2 noreply", silent = False)
-server.memcached.execute("get noreply:foo", silent = False)
+exec memcached "decr noreply:foo 2 noreply\r\n"
+exec memcached "get noreply:foo\r\n"
 
-server.memcached.execute("delete noreply:foo noreply", silent = False)
-server.memcached.execute("get noreply:foo", silent = False)
+exec memcached "delete noreply:foo noreply\r\n"
+exec memcached "get noreply:foo\r\n"
 
 # resore default suite config
 server.stop()