/*
* Copyright 2009-2010 Joubin Houshyar
*
* 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 org.jredis.ri.alphazero;
import static org.jredis.ri.alphazero.support.DefaultCodec.decode;
import static org.jredis.ri.alphazero.support.DefaultCodec.toLong;
import static org.jredis.ri.alphazero.support.DefaultCodec.toStr;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertFalse;
import static org.testng.Assert.assertNotNull;
import static org.testng.Assert.assertNull;
import static org.testng.Assert.assertTrue;
import static org.testng.Assert.fail;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import org.jredis.JRedis;
import org.jredis.ObjectInfo;
import org.jredis.Query;
import org.jredis.RedisException;
import org.jredis.RedisInfo;
import org.jredis.RedisType;
import org.jredis.ZSetEntry;
import org.jredis.protocol.Command;
import org.jredis.ri.JRedisTestSuiteBase;
import org.jredis.ri.RI.Version;
import org.jredis.ri.alphazero.support.DefaultCodec;
import org.jredis.ri.alphazero.support.Log;
import org.testng.annotations.Test;
/**
* This class is abstract and it is to remain abstract.
* It provides the comprehensive set of tests of all {@link JRedis} methods.
*/
@Version(major=2, minor=0)
public abstract class JRedisProviderTestsBase extends JRedisTestSuiteBase<JRedis>{
// ------------------------------------------------------------------------
// Properties
// ------------------------------------------------------------------------
/** JRedis Command being tested -- for log info */
private String cmd;
// ------------------------------------------------------------------------
// The Tests
// ========================================================= JRedis =======
/**
* We define and run provider agnostic tests here. This means we run a set
* of JRedis interface method tests that every connected JRedis implementation
* should be able to support.
*
* The following commands are omitted:
* 1 - QUIT: since we may be testing a multi-connection provider
* 2 - SHUTDOWN: for the same reason as QUIT
* 3 - MOVE and SELECT
*/
// ------------------------------------------------------------------------
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#auth(java.lang.String)}.
*/
@Test
public void testElicitErrors() {
Log.log("TEST: Elicit errors");
try {
provider.flushdb();
String key = keys.get(0);
provider.set(key, smallData);
boolean expectedError;
// -- commands returning status response
expectedError = false;
try {
Log.log("Expecting an operation against key holding the wrong kind of value ERROR..");
provider.sadd(key, dataList.get(0));
}
catch (RedisException e) { expectedError = true; }
assertTrue(expectedError, "should have raised an exception but did not");
// -- commands returning value response
expectedError = false;
try {
Log.log("Expecting an operation against key holding the wrong kind of value ERROR..");
provider.scard(key);
}
catch (RedisException e) { expectedError = true; }
assertTrue(expectedError, "should have raised an exception but did not");
// -- commands returning bulk response
expectedError = false;
try {
Log.log("Expecting an operation against key holding the wrong kind of value ERROR..");
provider.lpop(key);
}
catch (RedisException e) { expectedError = true; }
assertTrue(expectedError, "should have raised an exception but did not");
// -- commands returning multi-bulk response
expectedError = false;
try {
Log.log("Expecting an operation against key holding the wrong kind of value ERROR..");
provider.smembers(key);
}
catch (RedisException e) { expectedError = true; }
assertTrue(expectedError, "should have raised an exception but did not");
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
// /**
// * Test method for {@link org.jredis.ri.alphazero.JRedisSupport#auth(java.lang.String)}.
// */
// @Test
// public void testAuth() {
// test = Command.AUTH.code;
// Log.log("TEST: %s command", test);
// try {
// jredis.auth(password);
// }
// catch (RedisException e) {
// fail(test + " with password: " + password, e);
// }
// }
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#ping()}.
*/
@Test
public void testPing() {
cmd = Command.PING.code;
Log.log("TEST: %s command", cmd);
try {
provider.ping();
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
/**
* Tests:
* <li>Test method for {@link org.jredis.ri.alphazero.JRedisSupport#exists(java.lang.String)}.
* <li>Test method for {@link org.jredis.ri.alphazero.JRedisSupport#expire(java.lang.String, int)}.
* <li>Test method for {@link org.jredis.ri.alphazero.JRedisSupport#ttl (java.lang.String)}.
*/
@Test
public void testExists_Expire_TTL() {
cmd = Command.EXISTS.code + " | " + Command.EXPIRE.code + " | " + Command.TTL.code;
Log.log("TEST: %s command(s)", cmd);
try {
provider.flushdb();
assertTrue(provider.dbsize() == 0);
String keyToExpire = "expire-me";
String keyToKeep = "keep-me";
provider.set(keyToKeep, "master");
provider.set(keyToExpire, System.currentTimeMillis());
assertTrue (provider.exists(keyToExpire));
Log.log("TEST: %s with expire time of %d", Command.EXPIRE, expire_secs);
provider.expire(keyToExpire, expire_secs);
assertTrue (provider.exists(keyToExpire));
assertTrue (provider.ttl(keyToExpire) > 0, "key to expire ttl is less than zero");
// NOTE: IT SIMPLY WON'T WORK WITHOUT GIVING REDIS A CHANCE
// could be network latency, or whatever, but the expire command is NOT
// that precise
Thread.sleep(500);
assertTrue (provider.exists(keyToExpire));
Thread.sleep(this.expire_wait_millisecs);
assertFalse (provider.exists(keyToExpire));
assertTrue (provider.ttl(keyToExpire) == -1, "expired key ttl is not -1");
assertTrue (provider.ttl(keyToKeep) == -1, "key to keep ttl is not -1");
}
catch (RedisException e) {
fail(cmd + " with password: " + password, e);
}
catch (InterruptedException e) {
fail (cmd + "thread was interrupted and test did not conclude" + e.getLocalizedMessage());
}
}
@Test
public void testExpireat() {
cmd = Command.EXPIREAT.code;
Log.log("TEST: %s command(s)", cmd);
try {
provider.flushdb();
assertTrue(provider.dbsize() == 0);
String keyToExpire = "expire-me";
provider.set(keyToExpire, dataList.get(0));
assertTrue (provider.exists(keyToExpire));
Log.log("TEST: %s with expire time 1000 msecs in future", Command.EXPIREAT);
assertTrue(provider.expireat(keyToExpire, System.currentTimeMillis() + 2000), "expireat for existing key should be true");
assertTrue (provider.exists(keyToExpire));
assertTrue(!provider.expireat("no-such-key", System.currentTimeMillis() + 500), "expireat for non-existant key should be false");
// NOTE: IT SIMPLY WON'T WORK WITHOUT GIVING REDIS A CHANCE
// could be network latency, or whatever, but the expire command is NOT
// that precise, so we need to wait a bit longer
Thread.sleep(5000);
assertTrue (!provider.exists(keyToExpire), "key should have expired by now");
}
catch (RedisException e) {
fail(cmd + " with password: " + password, e);
}
catch (InterruptedException e) {
fail (cmd + "thread was interrupted and test did not conclude" + e.getLocalizedMessage());
}
}
// CANT test this without risking hosing the user's DBs
// TODO: use a flag
// /**
// * Test method for {@link org.jredis.ri.alphazero.JRedisSupport#flushall()}.
// */
// @Test
// public void testFlushall() {
// fail("Not yet implemented");
// }
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#flushdb()}.
*/
@Test
public void testSetAndFlushdbAndExistsAndKeys() {
cmd =
Command.FLUSHDB.code + " | " +
Command.SET.code + " | " +
Command.EXISTS.code + " | " +
Command.FLUSHDB.code + " | " +
Command.KEYS.code;
Log.log("TEST: %s commands", cmd);
try {
key = "woof";
provider.flushdb();
provider.set(key, "meow");
assertTrue (provider.exists(key));
provider.flushdb();
assertTrue(provider.keys().size()==0);
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#rename(java.lang.String, java.lang.String)}.
*/
@Test
public void testRename() {
cmd = Command.RENAME.code;
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
String newkey = null;
byte[] value = dataList.get(0);
key = getRandomAsciiString (random.nextInt(24)+2);
newkey = getRandomAsciiString (random.nextInt(24)+2);
provider.set (key, value);
assertEquals(value, provider.get(key));
provider.rename (key, newkey);
assertEquals(value, provider.get(newkey));
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
@Test
public void testBitCommands() {
cmd = Command.SETBIT.code;
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
key = getRandomAsciiString (random.nextInt(24)+2);
provider.del(key);
provider.setbit(key, 0, true);
provider.setbit(key, 32, true);
assertEquals(true, provider.getbit(key,0));
assertEquals(true, provider.getbit(key,32));
assertEquals(false, provider.getbit(key,64));
assertEquals(false, provider.getbit(key,1));
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#renamenx(java.lang.String, java.lang.String)}.
*/
@Test
public void testRenamenx() {
cmd = Command.RENAMENX.code;
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
provider.set (keys.get(0), dataList.get(0));
assertEquals(dataList.get(0), provider.get(keys.get(0)));
// should work
assertTrue(provider.renamenx (keys.get(0), keys.get(2)));
assertEquals(dataList.get(0), provider.get(keys.get(2)));
provider.flushdb();
// set key1
provider.set (keys.get(1), dataList.get(1));
assertEquals(dataList.get(1), provider.get(keys.get(1)));
// set key2
provider.set (keys.get(2), dataList.get(2));
assertEquals(dataList.get(2), provider.get(keys.get(2)));
// rename key1 to key 2
// should not
assertFalse(provider.renamenx (keys.get(1), keys.get(2)));
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#save()}.
*/
@Test
public void testSaveAndLastSave() {
cmd = Command.SAVE.code + " | " + Command.LASTSAVE;
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
provider.save();
long when = provider.lastsave();
Thread.sleep (this.expire_wait_millisecs);
provider.save();
long when2 = provider.lastsave();
assertTrue(when != when2);
}
catch (RedisException e) {
if(e.getLocalizedMessage().indexOf("background save in progress") != -1){
Log.problem ("** NOTE ** Redis background save in progress prevented effective test of SAVE and LASTSAVE.");
}
else
fail(cmd + " ERROR => " + e.getLocalizedMessage(), e);
}
catch (InterruptedException e) {
fail ("thread was interrupted and test did not conclude" + e.getLocalizedMessage());
}
}
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#bgsave()}.
*/
@Test
public void testBgsave() {
cmd = Command.BGSAVE.code;
Log.log("TEST: %s command", cmd);
// final long start = System.nanoTime();
// final long until = start + TimeUnit.SECONDS.toNanos(10);
// while(System.nanoTime() < until){
try {
// if(!didflush) {
provider.flushdb();
// didflush = true;
// }
// TODO: what's a meaningful test for this besides asserting command works?
provider.bgsave();
}
catch (RedisException e) {
/* can fail due if server is in middle of AOF */
if(e.getMessage().contains("ERR Can't BGSAVE")){
try {
Log.log("NOTE: Ignoring error <<%s>> finish with AOF during test for %s", e.getMessage(), cmd);
Thread.sleep(1000L);
Log.log(".. let's try again");
}catch (InterruptedException ie) {
Log.log("sleep interrupted while waiting for Redis server to finish with AOF during test for %s", cmd);
}
}
else {
fail(cmd + " ERROR => " + e.getLocalizedMessage(), e);
}
}
// }
}
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#bgrewriteaof()}.
*/
@Test
public void testBgrewriteaofe() {
cmd = Command.BGREWRITEAOF.code;
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
// TODO: what's a meaningful test for this besides asserting command works?
String msg = provider.bgrewriteaof();
assertTrue(msg != null, "expecting a non null response message - msg details may change so will not be checked here");
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#set(java.lang.String, byte[])}.
*/
@Test
public void testSetStringByteArray() {
cmd = Command.SET.code + " | " + Command.SETNX.code + " byte[] | " + Command.GET;
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
provider.set(keys.get(keys.size()-1), emptyBytes);
assertEquals(provider.get(keys.get(keys.size()-1)), emptyBytes, "set and get results for empty byte[]");
provider.set(keys.get(0), dataList.get(0));
assertEquals(dataList.get(0), provider.get(keys.get(0)), "data and get results");
assertTrue(provider.setnx(keys.get(1), dataList.get(1)), "set key");
assertNotNull(provider.get(keys.get(1)));
assertFalse(provider.setnx(keys.get(1), dataList.get(2)), "key was already set");
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#append(java.lang.String, byte[])}.
*/
@Test
public void testAppendStringByteArray() {
cmd = Command.SET.code + " | " + Command.APPEND.code + " byte[] | " + Command.GET;
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
// append to a non-existent key
// as of Redis 1.3.7 it behaves just like set but returns value len instead of status
String key1 = keys.get(0);
long key1len = 0;
key1len = provider.append(key1, emptyBytes);
assertEquals(key1len, 0, "append of emtpy bytes to new key should be zero");
assertEquals(provider.get(key1), emptyBytes, "get results after append to new key for empty byte[]");
long len = 0;
len = provider.append(key1, dataList.get(0));
assertEquals(len+key1len, dataList.get(0).length, "append results");
assertEquals(provider.get(key1), dataList.get(0), "get results after append");
key1len += len;
len = provider.append(key1, dataList.get(1));
assertEquals(len, dataList.get(0).length + dataList.get(1).length, "append results");
byte[] appendedBytes = new byte[dataList.get(0).length + dataList.get(1).length];
System.arraycopy(dataList.get(0), 0, appendedBytes, 0, dataList.get(0).length);
System.arraycopy(dataList.get(1), 0, appendedBytes, dataList.get(0).length, dataList.get(1).length);
assertEquals(provider.get(key1), appendedBytes, "get results after 2nd append");
// raise errors
boolean expected = false;
try {
String nonStringKey = keys.get(1);
provider.sadd(nonStringKey, dataList.get(0));
provider.append(nonStringKey, dataList.get(3));
}
catch(RedisException e) { expected = true; }
assertTrue(expected, "expecting RedisException for append to a non-string key");
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#append(java.lang.String, java.lang.String)}.
*/
@Test
public void testAppendStringString() {
cmd = Command.SET.code + " | " + Command.APPEND.code + " String | " + Command.GET;
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
// append to a non-existent key
// as of Redis 1.3.7 it behaves just like set but returns value len instead of status
String key1 = keys.get(0);
long key1len = 0;
long len = 0;
// append empty string to non-existent key
key1len = provider.append(key1, emptyString);
assertEquals(key1len, 0, "append of emtpy string to new key should be zero");
assertEquals(DefaultCodec.toStr(provider.get(key1)), emptyString, "get results after append to new key for empty string");
// append a string
len = provider.append(key1, stringList.get(0));
assertEquals(len+key1len, stringList.get(0).length(), "append results");
assertEquals(DefaultCodec.toStr(provider.get(key1)), stringList.get(0), "get results after append");
key1len += len;
// append a string again
len = provider.append(key1, stringList.get(1));
assertEquals(len, stringList.get(0).length() + stringList.get(1).length(), "append results");
StringBuffer appendedString = new StringBuffer();
appendedString.append(stringList.get(0));
appendedString.append(stringList.get(1));
assertEquals(DefaultCodec.toStr(provider.get(key1)), appendedString.toString(), "get results after 2nd append");
// raise RedisException
boolean expected = false;
try {
String nonStringKey = keys.get(1);
provider.sadd(nonStringKey, stringList.get(0));
provider.append(nonStringKey, stringList.get(3));
}
catch(RedisException e) { expected = true; }
assertTrue(expected, "expecting RedisException for append to a non-string key");
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#set(java.lang.String, java.lang.String)}.
*/
@Test
public void testSetStringString() {
cmd = Command.SET.code + " | " + Command.SETNX.code + " String | " + Command.GET;
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
provider.set(keys.get(keys.size()-1), emptyString);
assertEquals(toStr(provider.get(keys.get(keys.size()-1))), emptyString, "set and get results for empty String");
provider.set(keys.get(0), stringList.get(0));
assertEquals(stringList.get(0), toStr(provider.get(keys.get(0))), "string and get results");
assertTrue(provider.setnx(keys.get(1), stringList.get(1)), "set key");
assertNotNull(provider.get(keys.get(1)));
assertFalse(provider.setnx(keys.get(1), stringList.get(2)), "key was already set");
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#set(java.lang.String, java.lang.Number)}.
*/
@Test
public void testSetStringNumber() {
cmd = Command.SET.code + " | " + Command.SETNX.code + " Long | " + Command.GET;
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
provider.set(keys.get(0), longList.get(0));
assertTrue(longList.get(0).equals(toLong(provider.get(keys.get(0)))), "long and get results");
assertTrue(provider.setnx(keys.get(1), longList.get(1)), "set key");
assertNotNull(provider.get(keys.get(1)));
assertFalse(provider.setnx(keys.get(1), longList.get(2)), "key was already set");
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#set(java.lang.String, java.io.Serializable)}.
*/
@Test
public void testSetStringT() {
cmd = Command.SET.code + " | " + Command.SETNX.code + " Java Object | " + Command.GET;
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
provider.set(keys.get(0), objectList.get(0));
assertTrue(objectList.get(0).equals(decode(provider.get(keys.get(0)))), "object and get results");
assertTrue(provider.setnx(keys.get(1), objectList.get(1)), "set key");
assertNotNull(provider.get(keys.get(1)));
assertFalse(provider.setnx(keys.get(1), objectList.get(2)), "key was already set");
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
@Test
public void testHsetHgetHexists() {
cmd = Command.HSET.code + " | " + Command.HGET + " | " + Command.HEXISTS;
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
assertTrue( provider.hset(keys.get(0), keys.get(1), dataList.get(0)), "hset using byte[] value");
assertTrue( provider.hexists(keys.get(0), keys.get(1)), "field should exist");
assertTrue( !provider.hexists(keys.get(0), keys.get(2)), "field should NOT exist");
assertTrue( !provider.hset(keys.get(0), keys.get(1), dataList.get(0)), "repeated hset using byte[] value should return false");
assertTrue( provider.hset(keys.get(0), keys.get(2), stringList.get(0)), "hset using String value");
assertTrue( provider.hset(keys.get(0), keys.get(3), 222), "hset using Number value");
objectList.get(0).setName("Hash Stash");
assertTrue( provider.hset(keys.get(0), keys.get(4), objectList.get(0)), "hset using Object value");
assertEquals( provider.hlen(keys.get(0)), 4, "hlen value");
assertEquals( provider.hlen("some-random-key"), 0, "hlen of non-existent hash should be zero");
assertEquals (provider.hget(keys.get(0), keys.get(1)), dataList.get(0), "hget of field with byte[] value");
assertEquals (DefaultCodec.toStr(provider.hget(keys.get(0), keys.get(2))), stringList.get(0), "hget of field with String value");
assertEquals (DefaultCodec.toLong(provider.hget(keys.get(0), keys.get(3))).longValue(), 222, "hget of field with Number value");
TestBean objval = DefaultCodec.decode(provider.hget(keys.get(0), keys.get(4)));
assertEquals (objval.getName(), objectList.get(0).getName(), "hget of field with Object value");
assertTrue( provider.hdel(keys.get(0), keys.get(1)), "hdel of existing field should be true");
assertTrue( !provider.hdel(keys.get(0), keys.get(1)), "hdel of non-existing field should be false");
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#hkeys(java.lang.String, java.io.Serializable)}.
*/
@Test
public void testHkeys() {
cmd = Command.HKEYS.code + " | " + Command.HSET + " | " + Command.HDEL;
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
assertTrue( provider.hset(keys.get(0), keys.get(1), dataList.get(0)), "hset using byte[] value");
assertTrue( provider.hset(keys.get(0), keys.get(2), stringList.get(0)), "hset using String value");
assertTrue( provider.hset(keys.get(0), keys.get(3), 222), "hset using Number value");
objectList.get(0).setName("Hash Stash");
assertTrue( provider.hset(keys.get(0), keys.get(4), objectList.get(0)), "hset using Object value");
List<byte[]> hkeys = provider.hkeys(keys.get(0));
assertEquals( hkeys.size(), 4, "keys list length");
for(byte[] key : hkeys){
assertTrue(provider.hdel(keys.get(0), key), "deleting existing field should be true");
}
assertEquals(provider.hlen(keys.get(0)), 0, "hash should empty");
List<byte[]> hkeys2 = provider.hkeys(keys.get(0));
assertEquals(hkeys2, Collections.EMPTY_LIST, "keys list should be empty");
List<byte[]> hkeys3 = provider.hkeys("no-such-hash");
assertEquals(hkeys3, Collections.EMPTY_LIST, "keys list of non-existent hash should be empty.");
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#hvals(java.lang.String, java.io.Serializable)}.
*/
@Test
public void testHvals() {
cmd = Command.HVALS.code + " | " + Command.HSET + " | " + Command.HDEL;
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
assertTrue( provider.hset(keys.get(0), keys.get(1), dataList.get(0)), "hset using byte[] value");
assertTrue( provider.hset(keys.get(0), keys.get(2), stringList.get(0)), "hset using String value");
assertTrue( provider.hset(keys.get(0), keys.get(3), 222), "hset using Number value");
objectList.get(0).setName("Hash Stash");
assertTrue( provider.hset(keys.get(0), keys.get(4), objectList.get(0)), "hset using Object value");
List<byte[]> hvals = provider.hvals(keys.get(0));
assertEquals( hvals.size(), 4, "value list length");
List<byte[]> hkeys = provider.hkeys(keys.get(0));
assertEquals( hkeys.size(), 4, "keys list length");
for(byte[] key : hkeys){
assertTrue(provider.hdel(keys.get(0), key), "deleting existing field should be true");
}
assertEquals(provider.hlen(keys.get(0)), 0, "hash should empty");
List<byte[]> hvals2 = provider.hvals(keys.get(0));
assertEquals(hvals2, Collections.EMPTY_LIST, "keys list should be empty");
List<byte[]> hvals3 = provider.hvals("no-such-hash");
assertEquals(hvals3, Collections.EMPTY_LIST, "values list of non-existent hash should be empty.");
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#hvals(java.lang.String, java.io.Serializable)}.
*/
@Test
public void testHgetall() {
cmd = Command.HGETALL.code + " | " + Command.HSET + " | " + Command.HDEL;
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
assertTrue( provider.hset(keys.get(0), keys.get(1), dataList.get(0)), "hset using byte[] value");
assertTrue( provider.hset(keys.get(0), keys.get(2), stringList.get(0)), "hset using String value");
assertTrue( provider.hset(keys.get(0), keys.get(3), 222), "hset using Number value");
objectList.get(0).setName("Hash Stash");
assertTrue( provider.hset(keys.get(0), keys.get(4), objectList.get(0)), "hset using Object value");
Map<byte[], byte[]> hbinmap = provider.hgetall(keys.get(0));
assertEquals( hbinmap.size(), 4, "hash map length");
List<byte[]> hbinkeys = provider.hkeys(keys.get(0));
assertEquals( hbinkeys.size(), 4, "keys list length");
Map<String, byte[]> hmap = DefaultCodec.toDataDictionary(hbinmap);
int i = 0;
for(String key : DefaultCodec.toStr(hbinkeys)) {
assertTrue(hmap.get(key) != null, String.format("key %d should exists in map and have a corresponding non null value", i++));
}
assertEquals(hmap.get(keys.get(1)), dataList.get(0), "byte[] value mapping should correspond to prior HSET");
assertEquals(DefaultCodec.toStr(hmap.get(keys.get(2))), stringList.get(0), "String value mapping should correspond to prior HSET");
assertEquals(DefaultCodec.toLong(hmap.get(keys.get(3))).longValue(), 222, "Number value mapping should correspond to prior HSET");
assertEquals(DefaultCodec.decode(hmap.get(keys.get(4))), objectList.get(0), "Object value mapping should correspond to prior HSET");
for(byte[] key : hbinkeys)
assertTrue(provider.hdel(keys.get(0), key), "deletion of existing key in hash should be true");
Map<byte[], byte[]> hmap2 = provider.hgetall(keys.get(0));
assertEquals(hmap2, Collections.EMPTY_MAP, "hash map should be empty");
Map<byte[], byte[]> hmap3 = provider.hgetall("no-such-hash");
assertEquals(hmap3, Collections.EMPTY_MAP, "hgetall for non existent hash should be empty");
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#set(java.lang.String, byte[])}.
*/
@Test
public void testGetSetStringByteArray() {
cmd = Command.SET.code + " | " + Command.GETSET.code + " byte[] ";
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
provider.set(keys.get(0), dataList.get(0));
assertEquals(dataList.get(0), provider.get(keys.get(0)), "data and get results");
assertEquals (provider.getset(keys.get(0), dataList.get(1)), dataList.get(0), "getset key");
assertEquals (provider.get(keys.get(1)), null, "non existent key should be null");
assertEquals (provider.getset(keys.get(1), dataList.get(1)), null, "getset on null key should be null");
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#set(java.lang.String, java.lang.String)}.
*/
// @Test
// public void testGetSetStringString() {
// test = Command.SET.code + " | " + Command.GETSET.code + " String ";
// Log.log("TEST: %s command", test);
// try {
// jredis.flushdb();
//
// jredis.set(keys.get(0), stringList.get(0));
// assertEquals(stringList.get(0), toStr(jredis.get(keys.get(0))), "string and get results");
//
// assertTrue(jredis.setnx(keys.get(1), stringList.get(1)), "set key");
// assertNotNull(jredis.get(keys.get(1)));
// assertFalse(jredis.setnx(keys.get(1), stringList.get(2)), "key was already set");
// }
// catch (RedisException e) { fail(test + " ERROR => " + e.getLocalizedMessage(), e); }
// }
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#set(java.lang.String, java.lang.Number)}.
*/
// @Test
// public void testGetSetStringNumber() {
// test = Command.SET.code + " | " + Command.GETSET.code + " Number ";
// Log.log("TEST: %s command", test);
// try {
// jredis.flushdb();
//
// jredis.set(keys.get(0), longList.get(0));
// assertTrue(longList.get(0).equals(toLong(jredis.get(keys.get(0)))), "long and get results");
//
// assertTrue(jredis.setnx(keys.get(1), longList.get(1)), "set key");
// assertNotNull(jredis.get(keys.get(1)));
// assertFalse(jredis.setnx(keys.get(1), longList.get(2)), "key was already set");
// }
// catch (RedisException e) { fail(test + " ERROR => " + e.getLocalizedMessage(), e); }
// }
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#set(java.lang.String, java.io.Serializable)}.
*/
// @Test
// public void testGetSetStringT() {
// test = Command.SET.code + " | " + Command.GETSET.code + " Java Object ";
// Log.log("TEST: %s command", test);
// try {
// jredis.flushdb();
//
// jredis.set(keys.get(0), objectList.get(0));
// assertTrue(objectList.get(0).equals(decode(jredis.get(keys.get(0)))), "object and get results");
//
// assertTrue(jredis.setnx(keys.get(1), objectList.get(1)), "set key");
// assertNotNull(jredis.get(keys.get(1)));
// assertFalse(jredis.setnx(keys.get(1), objectList.get(2)), "key was already set");
// }
// catch (RedisException e) { fail(test + " ERROR => " + e.getLocalizedMessage(), e); }
// }
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#incr(java.lang.String)}.
*/
@Test
public void testIncrAndDecr() {
cmd = Command.INCR.code + " | " + Command.DECR.code;
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
long cntr = 0;
String cntr_key = keys.get(0);
for(int i = 1; i<MEDIUM_CNT; i++){
cntr = provider.incr(cntr_key);
assertEquals(i, cntr);
}
for(long i=cntr-1; i>=0; i--){
cntr = provider.decr(cntr_key);
assertEquals(i, cntr);
}
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#incrby(java.lang.String, int)}.
*/
@Test
public void testIncrbyAndDecrby() {
cmd = Command.INCRBY.code + " |" + Command.DECRBY.code;
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
long cntr = 0;
String cntr_key = keys.get(0);
for(long i = 1; i<MEDIUM_CNT; i++){
cntr = provider.incrby(cntr_key, 10);
assertEquals(i*10, cntr);
}
provider.set(cntr_key, 0);
assertTrue(0 == toLong(provider.get(cntr_key)));
for(long i = 1; i<MEDIUM_CNT; i++){
cntr = provider.decrby(cntr_key, 10);
assertEquals(i*-10, cntr);
}
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#del(java.lang.String)}.
*/
@Test
public void testDel() {
cmd = Command.DEL.code;
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
String key = this.keys.get(0);
provider.set (key, dataList.get(0));
assertTrue (provider.exists(key));
long delCnt;
delCnt = provider.del(key);
assertFalse (provider.exists(key));
assertEquals(delCnt, 1, "one key was deleted");
// delete many keys
provider.flushdb();
for(int i=0; i<SMALL_CNT; i++) provider.set(stringList.get(i), dataList.get(i));
String[] keysToDel = new String[SMALL_CNT];
for(int i=0; i<SMALL_CNT; i++) keysToDel[i] = stringList.get(i);
delCnt = provider.del(keysToDel);
for(int i=0; i<SMALL_CNT; i++) assertFalse (provider.exists(stringList.get(i)), "key should have been deleted");
assertEquals(delCnt, SMALL_CNT, "SMALL_CNT keys were deleted");
// delete many keys but also spec one non existent keys - delete result should be less than key cnt
provider.flushdb();
for(int i=0; i<SMALL_CNT-1; i++) provider.set(stringList.get(i), dataList.get(i));
keysToDel = new String[SMALL_CNT];
for(int i=0; i<SMALL_CNT; i++) keysToDel[i] = stringList.get(i);
delCnt = provider.del(keysToDel);
for(int i=0; i<SMALL_CNT; i++) assertFalse (provider.exists(stringList.get(i)), "key should have been deleted");
assertEquals(delCnt, SMALL_CNT-1, "SMALL_CNT-1 keys were actually deleted");
// edge cases
// all should through exceptions
boolean didRaiseEx;
didRaiseEx = false;
try {
String[] keys = null;
provider.del(keys);
}
catch (IllegalArgumentException e) {didRaiseEx = true;}
catch (Throwable whatsthis) { fail ("unexpected exception raised", whatsthis);}
if(!didRaiseEx){ fail ("Expected exception not raised."); }
didRaiseEx = false;
try {
String[] keys = new String[0];
provider.del(keys);
}
catch (IllegalArgumentException e) {didRaiseEx = true;}
catch (Throwable whatsthis) { fail ("unexpected exception raised", whatsthis);}
if(!didRaiseEx){ fail ("Expected exception not raised."); }
didRaiseEx = false;
try {
String[] keys = new String[3];
keys[0] = stringList.get(0);
keys[1] = null;
keys[2] = stringList.get(2);
provider.del(keys);
}
catch (IllegalArgumentException e) {didRaiseEx = true;}
catch (Throwable whatsthis) { fail ("unexpected exception raised", whatsthis);}
if(!didRaiseEx){ fail ("Expected exception not raised."); }
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#mget(java.lang.String, java.lang.String[])}.
*/
@Test
public void testMget() {
cmd = Command.MGET.code ;
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
for(int i=0; i<SMALL_CNT; i++){
provider.set (keys.get(i), dataList.get(i));
}
List<byte[]> values = null;
values = provider.mget(keys.get(0));
assertEquals(values.size(), 1, "one value expected");
for(int i=0; i<1; i++)
assertEquals(values.get(i), dataList.get(i));
values = provider.mget(keys.get(0), keys.get(1));
assertEquals(values.size(), 2, "2 values expected");
for(int i=0; i<2; i++)
assertEquals(values.get(i), dataList.get(i));
values = provider.mget(keys.get(0), keys.get(1), keys.get(2));
assertEquals(values.size(), 3, "3 values expected");
for(int i=0; i<3; i++)
assertEquals(values.get(i), dataList.get(i));
values = provider.mget("foo", "bar", "paz");
assertEquals(values.size(), 3, "3 values expected");
for(int i=0; i<3; i++)
assertEquals(values.get(i), null, "nonexistent key value in list should be null");
// edge cases
// all should through exceptions
boolean didRaiseEx;
didRaiseEx = false;
try {
String[] keys = null;
provider.mget(keys);
}
catch (IllegalArgumentException e) {didRaiseEx = true;}
catch (Throwable whatsthis) { fail ("unexpected exception raised", whatsthis);}
if(!didRaiseEx){ fail ("Expected exception not raised."); }
didRaiseEx = false;
try {
String[] keys = new String[0];
provider.mget(keys);
}
catch (IllegalArgumentException e) {didRaiseEx = true;}
catch (Throwable whatsthis) { fail ("unexpected exception raised", whatsthis);}
if(!didRaiseEx){ fail ("Expected exception not raised."); }
didRaiseEx = false;
try {
String[] keys = new String[3];
keys[0] = stringList.get(0);
keys[1] = null;
keys[2] = stringList.get(2);
provider.mget(keys);
}
catch (IllegalArgumentException e) {didRaiseEx = true;}
catch (Throwable whatsthis) { fail ("unexpected exception raised", whatsthis);}
if(!didRaiseEx){ fail ("Expected exception not raised."); }
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
/**************** LIST COMMANDS ******************************/
@Test
public void testListPushWithSparseList() {
cmd = Command.RPUSH.code + " byte[] | " + Command.LLEN + " | " + Command.LRANGE;
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
String listkey = this.keys.get(0);
for(int i=0; i<SMALL_CNT; i++)
provider.rpush(listkey, sparseList.get(i));
assertEquals(provider.llen(listkey), SMALL_CNT, "LLEN after RPUSH is wrong");
List<byte[]> range = provider.lrange(listkey, 0, SMALL_CNT);
assertTrue(range.size()==SMALL_CNT, "range size after RPUSH is wrong");
for(int i=0; i<SMALL_CNT; i++){
assertEquals (sparseList.get(i), range.get(i), "range and reference list differ at i: " + i);
}
provider.flushdb();
for(int i=0; i<SMALL_CNT; i++)
provider.lpush(listkey, sparseList.get(i));
assertEquals(provider.llen(listkey), SMALL_CNT, "LLEN after LPUSH is wrong");
range = provider.lrange(listkey, 0, SMALL_CNT);
assertTrue(range.size()==SMALL_CNT, "range size after LPUSH is wrong");
for(int i=0; i<SMALL_CNT; i++){
int r = SMALL_CNT - i - 1;
assertEquals (sparseList.get(i), range.get(r), "range and reference list differ at i: " + i);
}
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
@Test
public void testRpushStringByteArray() {
cmd = Command.RPUSH.code + " byte[] | " + Command.LLEN + " | " + Command.LRANGE;
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
boolean expected = false;
try {
byte[] nil = null;
provider.rpush("foo", nil);
}
catch(IllegalArgumentException e) { expected = true; }
assertTrue(expected, "expecting exception for null value to RPUSH");
String listkey = this.keys.get(0);
for(int i=0; i<SMALL_CNT; i++){
provider.rpush(listkey, dataList.get(i));
}
// use LLEN: size should be small count
assertTrue(provider.llen(listkey)==SMALL_CNT, "LLEN after RPUSH is wrong");
// use LRANGE 0 cnt: equal size and data should be same in order
List<byte[]> range = provider.lrange(listkey, 0, SMALL_CNT);
assertTrue(range.size()==SMALL_CNT, "range size after RPUSH is wrong");
for(int i=0; i<SMALL_CNT; i++){
assertEquals (dataList.get(i), range.get(i), "range and reference list differ at i: " + i);
}
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#lpush(java.lang.String, byte[])}.
*/
@Test
public void testLpushStringByteArray() {
cmd = Command.LPUSH.code + " byte[] | " + Command.LLEN + " | " + Command.LRANGE;
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
boolean expected = false;
try {
byte[] nil = null;
provider.rpush("foo", nil);
}
catch(IllegalArgumentException e) { expected = true; }
assertTrue(expected, "expecting exception for null value to RPUSH");
String listkey = this.keys.get(0);
for(int i=0; i<SMALL_CNT; i++){
provider.lpush(listkey, dataList.get(i));
}
// use LLEN: size should be small count
assertTrue(provider.llen(listkey)==SMALL_CNT, "LLEN after LPUSH is wrong");
// use LRANGE 0 cnt: equal size and data should be same in order
List<byte[]> range = provider.lrange(listkey, 0, SMALL_CNT);
assertTrue(range.size()==SMALL_CNT, "range size after LPUSH is wrong");
for(int i=0; i<SMALL_CNT; i++){
int r = SMALL_CNT - i - 1;
assertEquals (dataList.get(i), range.get(r), "range and reference list differ at i: " + i);
}
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
@Test
public void testLpoppushStringString() {
cmd = Command.RPOPLPUSH.code;
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
String listkey = this.keys.get(0);
for(int i=0; i<SMALL_CNT; i++){
provider.lpush(listkey, stringList.get(i));
}
// use LLEN: size should be small count
assertTrue(provider.llen(listkey)==SMALL_CNT, "LLEN after LPUSH is wrong");
String popped = null;
for(int i=0; i<SMALL_CNT; i++){
popped = toStr(provider.rpoplpush(listkey, listkey));
assertEquals(popped, stringList.get(i), "RPOPLPUSH didn't work as expected");
}
// use LLEN: size should still be small count
assertTrue(provider.llen(listkey)==SMALL_CNT, "LLEN after RPOPLPUSH sequence is wrong");
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#rpush(java.lang.String, java.lang.String)}.
*/
@Test
public void testRpushStringString() {
cmd = Command.RPUSH.code + " String | " + Command.LLEN + " | " + Command.LRANGE;
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
String listkey = this.keys.get(0);
for(int i=0; i<SMALL_CNT; i++){
provider.rpush(listkey, stringList.get(i));
}
// use LLEN: size should be small count
assertTrue(provider.llen(listkey)==SMALL_CNT, "LLEN after RPUSH is wrong");
// use LRANGE 0 cnt: equal size and data should be same in order
List<byte[]> range = provider.lrange(listkey, 0, SMALL_CNT);
assertTrue(range.size()==SMALL_CNT, "range size after RPUSH is wrong");
for(int i=0; i<SMALL_CNT; i++){
assertEquals (stringList.get(i), toStr(range.get(i)), "range and reference list differ at i: " + i);
}
List<String> strRange = toStr(range);
for(int i=0; i<SMALL_CNT; i++){
assertEquals (stringList.get(i), strRange.get(i), "range and reference list differ at i: " + i);
}
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#lpush(java.lang.String, java.lang.String)}.
*/
@Test
public void testLpushStringString() {
cmd = Command.LPUSH.code + " String | " + Command.LLEN + " | " + Command.LRANGE;
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
String listkey = this.keys.get(0);
for(int i=0; i<SMALL_CNT; i++){
provider.lpush(listkey, stringList.get(i));
}
// use LLEN: size should be small count
assertTrue(provider.llen(listkey)==SMALL_CNT, "LLEN after RPUSH is wrong");
// use LRANGE 0 cnt: equal size and data should be same in order
List<byte[]> range = provider.lrange(listkey, 0, SMALL_CNT);
assertTrue(range.size()==SMALL_CNT, "range size after RPUSH is wrong");
for(int i=0; i<SMALL_CNT; i++){
int r = SMALL_CNT - i - 1;
assertEquals (stringList.get(i), toStr(range.get(r)), "range and reference list differ at i: " + i);
}
List<String> strRange = toStr(range);
for(int i=0; i<SMALL_CNT; i++){
int r = SMALL_CNT - i - 1;
assertEquals (stringList.get(i), strRange.get(r), "range and reference list differ at i: " + i);
}
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#rpush(java.lang.String, java.lang.Number)}.
*/
@Test
public void testRpushStringNumber() {
cmd = Command.RPUSH.code + " Number | " + Command.LLEN + " | " + Command.LRANGE;
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
String listkey = this.keys.get(0);
for(int i=0; i<SMALL_CNT; i++){
provider.rpush(listkey, this.longList.get(i));
}
// use LLEN: size should be small count
assertTrue(provider.llen(listkey)==SMALL_CNT, "LLEN after RPUSH is wrong");
// use LRANGE 0 cnt: equal size and data should be same in order
List<byte[]> range = provider.lrange(listkey, 0, SMALL_CNT);
assertTrue(range.size()==SMALL_CNT, "range size after RPUSH is wrong");
for(int i=0; i<SMALL_CNT; i++){
assertTrue (longList.get(i).equals(toLong(range.get(i))), "range and reference list differ at i: " + i);
}
List<Long> longRange = toLong(range);
for(int i=0; i<SMALL_CNT; i++){
assertEquals (longList.get(i), longRange.get(i), "range and reference list differ at i: " + i);
}
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#lpush(java.lang.String, java.lang.Number)}.
*/
@Test
public void testLpushStringNumber() {
cmd = Command.LPUSH.code + " Number | " + Command.LLEN + " | " + Command.LRANGE;
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
String listkey = this.keys.get(0);
for(int i=0; i<SMALL_CNT; i++){
provider.lpush(listkey, this.longList.get(i));
}
// use LLEN: size should be small count
assertTrue(provider.llen(listkey)==SMALL_CNT, "LLEN after RPUSH is wrong");
// use LRANGE 0 cnt: equal size and data should be same in order
List<byte[]> range = provider.lrange(listkey, 0, SMALL_CNT);
assertTrue(range.size()==SMALL_CNT, "range size after RPUSH is wrong");
for(int i=0; i<SMALL_CNT; i++){
int r = SMALL_CNT - i - 1;
assertTrue (longList.get(i).equals(toLong(range.get(r))), "range and reference list differ at i: " + i);
}
List<Long> longRange = toLong(range);
for(int i=0; i<SMALL_CNT; i++){
int r = SMALL_CNT - i - 1;
assertEquals (longList.get(i), longRange.get(r), "range and reference list differ at i: " + i);
}
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#rpush(java.lang.String, java.io.Serializable)}.
*/
@Test
public void testRpushStringT() {
cmd = Command.RPUSH.code + " Java Object | " + Command.LLEN + " | " + Command.LRANGE;
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
String listkey = this.keys.get(0);
for(int i=0; i<SMALL_CNT; i++){
provider.rpush(listkey, this.objectList.get(i));
}
// use LLEN: size should be small count
assertTrue(provider.llen(listkey)==SMALL_CNT, "LLEN after RPUSH is wrong");
// use LRANGE 0 cnt: equal size and data should be same in order
List<byte[]> range = provider.lrange(listkey, 0, SMALL_CNT);
assertTrue(range.size()==SMALL_CNT, "range size after RPUSH is wrong");
for(int i=0; i<SMALL_CNT; i++){
assertTrue (objectList.get(i).equals(decode(range.get(i))), "range and reference list differ at i: " + i);
}
List<TestBean> objRange = decode(range);
for(int i=0; i<SMALL_CNT; i++){
assertEquals (objectList.get(i), objRange.get(i), "range and reference list differ at i: " + i);
}
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#lpush(java.lang.String, java.io.Serializable)}.
*/
@Test
public void testLpushStringT() {
cmd = Command.LPUSH.code + " Java Object | " + Command.LLEN + " | " + Command.LRANGE;
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
String listkey = this.keys.get(0);
for(int i=0; i<SMALL_CNT; i++){
provider.lpush(listkey, this.objectList.get(i));
}
// use LLEN: size should be small count
assertTrue(provider.llen(listkey)==SMALL_CNT, "LLEN after RPUSH is wrong");
// use LRANGE 0 cnt: equal size and data should be same in order
List<byte[]> range = provider.lrange(listkey, 0, SMALL_CNT);
assertTrue(range.size()==SMALL_CNT, "range size after RPUSH is wrong");
for(int i=0; i<SMALL_CNT; i++){
int r = SMALL_CNT - i - 1;
assertTrue (objectList.get(i).equals(decode(range.get(r))), "range and reference list differ at i: " + i);
}
List<TestBean> objRange = decode(range);
for(int i=0; i<SMALL_CNT; i++){
int r = SMALL_CNT - i - 1;
assertEquals (objectList.get(i), objRange.get(r), "range and reference list differ at i: " + i);
}
}
catch (RedisException e) {
fail(cmd + " ERROR => " + e.getLocalizedMessage(), e);
}
}
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#ltrim(java.lang.String, long, long)}.
*/
@Test
public void testLtrim() {
cmd = Command.LTRIM.code + " | " + Command.LLEN.code + " | " + Command.LRANGE.code ;
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
// prep a small list
String listkey = keys.get(0);
for(int i=0; i<SMALL_CNT; i++)
provider.rpush(listkey, dataList.get(i)); // use rpush (append) so ref list sequence order is preserved
// sanity check
long listcnt = provider.llen(listkey);
assertEquals (listcnt, SMALL_CNT, "list length should be SMALL_CNT");
provider.ltrim(listkey, 0,listcnt-1); // trim nothing
assertEquals(provider.llen(listkey), listcnt, "trim from end to end - no delta expected");
provider.ltrim(listkey, 1, listcnt-1); // remove the head
assertEquals(provider.llen(listkey), listcnt-1, "trim head - len should be --1 expected");
listcnt = provider.llen(listkey);
assertEquals(listcnt, SMALL_CNT - 1, "list length should be SMALL_CNT - 1");
for(int i=0; i<SMALL_CNT-1; i++)
assertEquals(provider.lindex(listkey, i), dataList.get(i+1), "list items should match ref data shifted by 1 after removing head");
provider.ltrim(listkey, -2, -1);
assertEquals(provider.llen(listkey), 2, "list length should be 2");
provider.ltrim(listkey, 0, 0);
assertEquals(provider.llen(listkey), 1, "list length should be 1");
byte[] lastItem = provider.lpop(listkey);
assertNotNull(lastItem, "last item should not have been null");
assertEquals(provider.llen(listkey), 0, "expecting empty list after trims and pop");
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#lindex(java.lang.String, long)}.
*/
@Test
public void testLindex() {
cmd = Command.LINDEX.code;
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
// prep a small list
String listkey = keys.get(0);
for(int i=0; i<SMALL_CNT; i++)
provider.rpush(listkey, dataList.get(i)); // use rpush (append) so ref list sequence order is preserved
for(int i=0; i<SMALL_CNT; i++)
assertEquals(provider.lindex(listkey, i), dataList.get(i), "list items should match ref data");
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#lpop(java.lang.String)}.
*/
@Test
public void testLpop() {
cmd = Command.LPOP.code ;
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
// prep a small list
String listkey = keys.get(0);
for(int i=0; i<SMALL_CNT; i++)
provider.rpush(listkey, dataList.get(i)); // use rpush (append) so ref list sequence order is preserved
// sanity check
long listcnt = provider.llen(listkey);
assertEquals (listcnt, SMALL_CNT, "list length should be SMALL_CNT");
for(int i=0; i<SMALL_CNT; i++)
assertEquals(provider.lpop(listkey), dataList.get(i),
"nth popped head should be the same as nth dataitem, where n is " + i);
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#rpop(java.lang.String)}.
*/
@Test
public void testRpop() {
cmd = Command.RPOP.code ;
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
// prep a small list
String listkey = keys.get(0);
for(int i=0; i<SMALL_CNT; i++)
provider.lpush(listkey, dataList.get(i)); // use rpush (append) so ref list sequence order is preserved
// sanity check
long listcnt = provider.llen(listkey);
assertEquals (listcnt, SMALL_CNT, "list length should be SMALL_CNT");
for(int i=0; i<SMALL_CNT; i++)
assertEquals(provider.rpop(listkey), dataList.get(i),
"nth popped tail should be the same as nth dataitem, where n is " + i);
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#lrange(java.lang.String, int, int)}.
*/
@Test
public void testLrange() {
cmd = Command.LRANGE.code ;
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
// prep a MEDIUM list
String listkey = keys.get(0);
for(int i=0; i<MEDIUM_CNT; i++)
provider.rpush(listkey, dataList.get(i)); // use rpush (append) so ref list sequence order is preserved
// sanity check
long listcnt = provider.llen(listkey);
assertEquals (listcnt, MEDIUM_CNT, "list length should be MEDIUM_CNT");
List<byte[]> items = provider.lrange(listkey, 0, SMALL_CNT-1);
assertEquals (items.size(), SMALL_CNT, "list range 0->SMALL_CNT length should be SMALL_CNT");
for(int i=0; i<SMALL_CNT; i++)
assertEquals(items.get(i), dataList.get(i),
"nth items of range 0->CNT should be the same as nth dataitem, where n is " + i);
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#substr(java.lang.String, int, int)}.
*/
@Test
public void testSubstr() {
cmd = Command.SUBSTR.code ;
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
String key = keys.get(0);
byte[] value = dataList.get(0);
provider.set(key, value);
byte[] substr = null;
substr = provider.substr(key, 0, value.length);
assertEquals(substr, value, "full range substr should be equal to value");
for(int i=0; i<value.length; i++){
assertTrue(provider.substr(key, i, i).length == 1, "checking size: using substr to iterate over value bytes @ idx " + i);
assertEquals(provider.substr(key, i, i)[0], value[i], "checking value: using substr to iterate over value bytes @ idx " + i);
}
substr = provider.substr(key, 0, -1);
assertEquals(substr, value, "full range substr should be equal to value");
substr = provider.substr(key, -1, 0);
assertEquals(substr, new byte[0], "substr with -1 from idx should be zero-length array");
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#lrem(java.lang.String, byte[], int)}.
*/
@Test
public void testLremStringByteArrayInt() {
cmd = Command.LREM.code + " byte[] | " + Command.LLEN;
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
String listkey = this.keys.get(0);
// we'll make a list of unique items first
for(int i=0; i<MEDIUM_CNT; i++)
provider.rpush(listkey, dataList.get(i));
assertTrue(provider.llen(listkey)==MEDIUM_CNT, "LLEN after RPUSH is wrong");
// everysingle one of these should work and remove just 1 element
assertEquals(1, provider.lrem(listkey, dataList.get(0), 0));
assertEquals(1, provider.lrem(listkey, dataList.get(1), -1));
assertEquals(1, provider.lrem(listkey, dataList.get(2), 1));
assertEquals(1, provider.lrem(listkey, dataList.get(3), 2));
assertEquals(1, provider.lrem(listkey, dataList.get(4), -2));
// everysingle one of these should work and remove NOTHING
assertEquals(0, provider.lrem(listkey, dataList.get(0), 0));
assertEquals(0, provider.lrem(listkey, dataList.get(1), -1));
assertEquals(0, provider.lrem(listkey, dataList.get(2), 1));
assertEquals(0, provider.lrem(listkey, dataList.get(3), 2));
assertEquals(0, provider.lrem(listkey, dataList.get(4), -2));
// now we'll test to see how it handles empty lists
provider.flushdb();
for(int i=0; i<SMALL_CNT; i++)
provider.rpush(listkey, dataList.get(i));
assertTrue(provider.llen(listkey)==SMALL_CNT, "LLEN after RPUSH is wrong");
for(int i=0; i<SMALL_CNT; i++)
provider.lrem(listkey, dataList.get(i), 100);
assertEquals(0, provider.llen(listkey), "LLEN should be zero");
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#lrem(java.lang.String, java.lang.String, int)}.
*/
@Test
public void testLremStringStringInt() {
cmd = Command.LREM.code + " String | " + Command.LLEN;
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
String listkey = this.keys.get(0);
// we'll make a list of unique items first
for(int i=0; i<MEDIUM_CNT; i++)
provider.rpush(listkey, stringList.get(i));
assertTrue(provider.llen(listkey)==MEDIUM_CNT, "LLEN after RPUSH is wrong");
// everysingle one of these should work and remove just 1 element
assertEquals(1, provider.lrem(listkey, stringList.get(0), 0));
assertEquals(1, provider.lrem(listkey, stringList.get(1), -1));
assertEquals(1, provider.lrem(listkey, stringList.get(2), 1));
assertEquals(1, provider.lrem(listkey, stringList.get(3), 2));
assertEquals(1, provider.lrem(listkey, stringList.get(4), -2));
// everysingle one of these should work and remove NOTHING
assertEquals(0, provider.lrem(listkey, stringList.get(0), 0));
assertEquals(0, provider.lrem(listkey, stringList.get(1), -1));
assertEquals(0, provider.lrem(listkey, stringList.get(2), 1));
assertEquals(0, provider.lrem(listkey, stringList.get(3), 2));
assertEquals(0, provider.lrem(listkey, stringList.get(4), -2));
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#lrem(java.lang.String, java.lang.Number, int)}.
*/
@Test
public void testLremStringNumberInt() {
cmd = Command.LREM.code + " Number | " + Command.LLEN;
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
String listkey = this.keys.get(0);
// we'll make a list of unique items first
for(int i=0; i<MEDIUM_CNT; i++)
provider.rpush(listkey, longList.get(i));
assertTrue(provider.llen(listkey)==MEDIUM_CNT, "LLEN after RPUSH is wrong");
// everysingle one of these should work and remove just 1 element
assertEquals(1, provider.lrem(listkey, longList.get(0), 0));
assertEquals(1, provider.lrem(listkey, longList.get(1), -1));
assertEquals(1, provider.lrem(listkey, longList.get(2), 1));
assertEquals(1, provider.lrem(listkey, longList.get(3), 2));
assertEquals(1, provider.lrem(listkey, longList.get(4), -2));
// everysingle one of these should work and remove NOTHING
assertEquals(0, provider.lrem(listkey, longList.get(0), 0));
assertEquals(0, provider.lrem(listkey, longList.get(1), -1));
assertEquals(0, provider.lrem(listkey, longList.get(2), 1));
assertEquals(0, provider.lrem(listkey, longList.get(3), 2));
assertEquals(0, provider.lrem(listkey, longList.get(4), -2));
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#lrem(java.lang.String, java.io.Serializable, int)}.
*/
@Test
public void testLremStringTInt() {
cmd = Command.LREM.code + " Java Object | " + Command.LLEN;
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
String listkey = this.keys.get(0);
// we'll make a list of unique items first
for(int i=0; i<MEDIUM_CNT; i++)
provider.rpush(listkey, objectList.get(i));
assertTrue(provider.llen(listkey)==MEDIUM_CNT, "LLEN after RPUSH is wrong");
// everysingle one of these should work and remove just 1 element
assertEquals(1, provider.lrem(listkey, objectList.get(0), 0));
assertEquals(1, provider.lrem(listkey, objectList.get(1), -1));
assertEquals(1, provider.lrem(listkey, objectList.get(2), 1));
assertEquals(1, provider.lrem(listkey, objectList.get(3), 2));
assertEquals(1, provider.lrem(listkey, objectList.get(4), -2));
// everysingle one of these should work and remove NOTHING
assertEquals(0, provider.lrem(listkey, objectList.get(0), 0));
assertEquals(0, provider.lrem(listkey, objectList.get(1), -1));
assertEquals(0, provider.lrem(listkey, objectList.get(2), 1));
assertEquals(0, provider.lrem(listkey, objectList.get(3), 2));
assertEquals(0, provider.lrem(listkey, objectList.get(4), -2));
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#lset(java.lang.String, int, byte[])}.
*/
@Test
public void testLsetStringIntByteArray() {
cmd = Command.LSET.code + " byte[] | " + Command.LLEN;
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
String listkey = this.keys.get(0);
// we'll make a list of unique items first
for(int i=0; i<SMALL_CNT; i++)
provider.rpush(listkey, dataList.get(i));
assertTrue(provider.llen(listkey)==SMALL_CNT, "LLEN after RPUSH is wrong");
// now we'll change their values
for(int i=0; i<SMALL_CNT; i++)
provider.lset(listkey, i, dataList.get(SMALL_CNT+i));
List<byte[]> range = null;
range = provider.lrange(listkey, 0, LARGE_CNT);
assertEquals (SMALL_CNT, range.size(), "range length is wrong");
for(int i=0; i<SMALL_CNT; i++)
assertEquals (dataList.get(SMALL_CNT+i), range.get(i), "after LSET the expected and range item differ at idx: " + i);
// now we'll change their values using the negative index mode
int lim = SMALL_CNT*-1;
for(int i=-1; i>lim; i--)
provider.lset(listkey, i, dataList.get(i*-1));
range = provider.lrange(listkey, 0, LARGE_CNT);
assertEquals (SMALL_CNT, range.size(), "range length is wrong");
for(int i=0; i<SMALL_CNT; i++)
assertEquals (dataList.get(SMALL_CNT-i), range.get(i), "after LSET the expected and range item differ at idx: " + i);
// test edge conditions
// out of range
boolean expectedError = false;
try {
Log.log("Expecting an out of range ERROR for LSET here ..");
provider.lset(listkey, SMALL_CNT, dataList.get(0));
}
catch (RedisException e) { expectedError = true; }
assertTrue(expectedError, "out of range LSET index should have raised an exception but did not");
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#lset(java.lang.String, int, java.lang.String)}.
*/
@Test
public void testLsetStringIntString() {
cmd = Command.LSET.code + " String | " + Command.LLEN;
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
String listkey = this.keys.get(0);
// we'll make a list of unique items first
for(int i=0; i<SMALL_CNT; i++)
provider.rpush(listkey, stringList.get(i));
assertTrue(provider.llen(listkey)==SMALL_CNT, "LLEN after RPUSH is wrong");
// now we'll change their values
for(int i=0; i<SMALL_CNT; i++)
provider.lset(listkey, i, stringList.get(SMALL_CNT+i));
List<String> range = null;
range = toStr (provider.lrange(listkey, 0, LARGE_CNT));
assertEquals (SMALL_CNT, range.size(), "range length is wrong");
for(int i=0; i<SMALL_CNT; i++)
assertTrue (stringList.get(SMALL_CNT+i).equals(range.get(i)), "after LSET the expected and range item differ at idx: " + i);
// now we'll change their values using the negative index mode
int lim = SMALL_CNT*-1;
for(int i=-1; i>lim; i--)
provider.lset(listkey, i, stringList.get(i*-1));
range = toStr (provider.lrange(listkey, 0, LARGE_CNT));
assertEquals (SMALL_CNT, range.size(), "range length is wrong");
for(int i=0; i<SMALL_CNT; i++)
assertTrue (stringList.get(SMALL_CNT-i).equals(range.get(i)), "after LSET the expected and range item differ at idx: " + i);
// test edge conditions
// out of range is same as byte[] as value type makes no difference
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#lset(java.lang.String, int, java.lang.Number)}.
*/
@Test
public void testLsetStringIntNumber() {
cmd = Command.LSET.code + " Number | " + Command.LLEN;
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
String listkey = this.keys.get(0);
// we'll make a list of unique items first
for(int i=0; i<SMALL_CNT; i++)
provider.rpush(listkey, longList.get(i));
assertTrue(provider.llen(listkey)==SMALL_CNT, "LLEN after RPUSH is wrong");
// now we'll change their values
for(int i=0; i<SMALL_CNT; i++)
provider.lset(listkey, i, longList.get(SMALL_CNT+i));
List<Long> range = null;
range = toLong (provider.lrange(listkey, 0, LARGE_CNT));
assertEquals (SMALL_CNT, range.size(), "range length is wrong");
for(int i=0; i<SMALL_CNT; i++)
assertTrue (longList.get(SMALL_CNT+i).equals(range.get(i)), "after LSET the expected and range item differ at idx: " + i);
// now we'll change their values using the negative index mode
int lim = SMALL_CNT*-1;
for(int i=-1; i>lim; i--)
provider.lset(listkey, i, longList.get(i*-1));
range = toLong (provider.lrange(listkey, 0, LARGE_CNT));
assertEquals (SMALL_CNT, range.size(), "range length is wrong");
for(int i=0; i<SMALL_CNT; i++)
assertTrue (longList.get(SMALL_CNT-i).equals(range.get(i)), "after LSET the expected and range item differ at idx: " + i);
// test edge conditions
// out of range is same as byte[] as value type makes no difference
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#lset(java.lang.String, int, java.io.Serializable)}.
*/
@Test
public void testLsetStringIntT() {
cmd = Command.LSET.code + " Java Object | " + Command.LLEN;
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
String listkey = this.keys.get(0);
// we'll make a list of unique items first
for(int i=0; i<SMALL_CNT; i++)
provider.rpush(listkey, objectList.get(i));
assertTrue(provider.llen(listkey)==SMALL_CNT, "LLEN after RPUSH is wrong");
// now we'll change their values
for(int i=0; i<SMALL_CNT; i++)
provider.lset(listkey, i, objectList.get(SMALL_CNT+i));
List<TestBean> range = null;
range = decode (provider.lrange(listkey, 0, LARGE_CNT));
assertEquals (SMALL_CNT, range.size(), "range length is wrong");
for(int i=0; i<SMALL_CNT; i++)
assertTrue (objectList.get(SMALL_CNT+i).equals(range.get(i)), "after LSET the expected and range item differ at idx: " + i);
// now we'll change their values using the negative index mode
int lim = SMALL_CNT*-1;
for(int i=-1; i>lim; i--)
provider.lset(listkey, i, objectList.get(i*-1));
range = decode (provider.lrange(listkey, 0, LARGE_CNT));
assertEquals (SMALL_CNT, range.size(), "range length is wrong");
for(int i=0; i<SMALL_CNT; i++)
assertTrue (objectList.get(SMALL_CNT-i).equals(range.get(i)), "after LSET the expected and range item differ at idx: " + i);
// test edge conditions
// out of range is same as byte[] as value type makes no difference
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
/**************** QUERY COMMANDS ******************************/
/**
* This command is still half-baked on the Redis side, so we just test to see if
* it blows up or not. (cooking: if you sort on a set/list of size N and your
* constrains (GET) limit the actual results to nothing, Redis (0.091) returns a
* list of size N full of nulls. That's not tasty ..)
*
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#sort(java.lang.String)}.
*/
@Test
public void testSort() {
cmd = Command.SORT.code;
Log.log("TEST: %s command", cmd);
final String setkey = "set-key";
final String listkey = "list-key";
try {
provider.flushdb();
for(int i=0; i<MEDIUM_CNT; i++){
provider.sadd(setkey, stringList.get(i));
provider.lpush(listkey, stringList.get(i));
}
List<String> sorted = null;
Log.log("TEST: SORTED LIST [t.1]");
sorted = toStr(provider.sort(listkey).ALPHA().LIMIT(0, MEDIUM_CNT).DESC().exec());
assertEquals(sorted.size(), MEDIUM_CNT, "expecting sort results of size MEDIUM_CNT");
for(String s : sorted)
System.out.format("[t.1]: %s\n", s);
String destKey = String.format("%s_store", listkey);
List<byte[]> ssres = provider.sort(listkey).ALPHA().LIMIT(0, MEDIUM_CNT).DESC().STORE(destKey).exec();
assertNotNull(ssres, "result of srot with STORE should be non-null");
assertEquals(ssres.size(), 1, "result of sort with STORE should be a list of single entry (the stored list's size)");
long sortedListSize = Query.Support.unpackValue(ssres);
assertEquals(sortedListSize, MEDIUM_CNT);
RedisType type = provider.type(destKey);
assertEquals(type, RedisType.list, "dest key of SORT .. STORE should be a LIST");
long sslistSize = provider.llen(destKey);
assertEquals(sslistSize, sortedListSize, "result of SORT ... STORE and LLEN of destkey list should be same");
Log.log("TEST: SORTED LIST [t.2]");
sorted = toStr(provider.sort(listkey).ALPHA().LIMIT(10, 9).DESC().exec());
assertEquals(sorted.size(), 9, "expecting sort results of size 9");
for(String s : sorted)
System.out.format("[t.2]: %s\n", s);
Log.log("TEST: SORTED LIST [t.3]");
sorted = toStr(provider.sort(listkey).ALPHA().LIMIT(MEDIUM_CNT-1, 1).DESC().exec());
assertEquals(sorted.size(), 1, "expecting sort results of size 1");
for(String s : sorted)
System.out.format("[t.3]: %s\n", s);
Log.log("TEST: SORTED SET ");
// sorted = toStr(jredis.sort(setkey).ALPHA().LIMIT(0, 100).BY("*BB*").exec());
sorted = toStr(provider.sort(setkey).ALPHA().LIMIT(0, 555).DESC().exec());
for(String s : sorted)
System.out.format("%s\n", s);
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
// force errors
// count can't be zero
Runnable invalidLimitSpec = new Runnable() {
public void run() {
try { provider.sort(listkey).ALPHA().LIMIT(0, 0).DESC().exec(); }
catch (Throwable t) { throw new RuntimeException ("", t); }
}
};
assertDidRaiseRuntimeError(invalidLimitSpec, RuntimeException.class);
// LIMIT from must be positive, {0...n}
Runnable invalidLimitSpec2 = new Runnable() {
public void run() {
try { provider.sort(listkey).ALPHA().LIMIT(-1, 1).DESC().exec(); }
catch (Throwable t) { throw new RuntimeException ("", t); }
}
};
assertDidRaiseRuntimeError(invalidLimitSpec2, RuntimeException.class);
}
/**************** SORTED SET COMMANDS ******************************/
@Test
public void testZaddStringByteArray() {
cmd = Command.ZADD.code + " byte[]";
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
String setkey = keys.get(0);
for(int i=0;i<SMALL_CNT; i++)
assertTrue(provider.zadd(setkey, random.nextDouble(), dataList.get(i)), "zadd of random element should be true");
for(int i=0;i<SMALL_CNT; i++)
assertFalse(provider.zadd(setkey, random.nextDouble(), dataList.get(i)), "sadd of existing element should be false");
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
@Test
public void testZremStringByteArray() {
cmd = Command.ZADD.code + " byte[] | " + Command.ZREM.code + " byte[]";
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
String setkey = keys.get(0);
for(int i=0;i<SMALL_CNT; i++)
assertTrue(provider.zadd(setkey, random.nextDouble(), dataList.get(i)), "zadd of random element should be true");
for(int i=0;i<SMALL_CNT; i++)
assertTrue(provider.zrem(setkey, dataList.get(i)), "zrem of existing element should be true");
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
@Test
public void testZscoreStringByteArray() {
cmd = Command.ZSCORE.code + " byte[]";
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
String setkey = keys.get(0);
for(int i=0;i<SMALL_CNT; i++)
assertTrue(provider.zadd(setkey, doubleList.get(i), dataList.get(i)), "zadd of random element should be true");
for(int i=0;i<SMALL_CNT; i++)
assertEquals (provider.zscore(setkey, dataList.get(i)).doubleValue(), doubleList.get(i), "zscore of element should be " + doubleList.get(i));
assertNull(provider.zscore(setkey, "no such set member"), "zscore of none existent member of sorted set should be null");
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
@Test
public void testZrankStringByteArray() {
cmd = Command.ZRANK.code + " byte[]";
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
String setkey = keys.get(0);
for(int i=0;i<=SMALL_CNT; i++)
assertTrue(provider.zadd(setkey, i, dataList.get(i)), "zadd of random element should be true");
for(int i=0;i<=SMALL_CNT; i++)
assertEquals (provider.zrank(setkey, dataList.get(i)), i, "zrank of element");
// edge cases
assertEquals (provider.zrank(setkey, dataList.get(SMALL_CNT+1)), -1, "zrank against non-existent member should be -1");
assertEquals (provider.zrank("no-such-set", dataList.get(0)), -1, "zrank against non-existent key should be -1");
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
@Test
public void testZrevrankStringByteArray() {
cmd = Command.ZREVRANK.code + " byte[]";
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
String setkey = keys.get(0);
for(int i=0;i<=SMALL_CNT; i++)
assertTrue(provider.zadd(setkey, i, dataList.get(i)), "zadd of random element should be true");
for(int i=0;i<=SMALL_CNT; i++)
assertEquals (provider.zrevrank(setkey, dataList.get(i)), SMALL_CNT - i, "zrevrank of element");
// edge cases
assertEquals (provider.zrevrank(setkey, dataList.get(SMALL_CNT+1)), -1, "zrevrank against non-existent member should be -1");
assertEquals (provider.zrevrank("no-such-set", dataList.get(0)), -1, "zrevrank against non-existent key should be -1");
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
@Test
public void testZrangeWithscoresStringByteArray() {
cmd = Command.ZRANGE$OPTS.code + " byte[]";
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
String setkey = keys.get(0);
for(int i=0;i<MEDIUM_CNT; i++)
assertTrue(provider.zadd(setkey, i, dataList.get(i)), "zadd of random element should be true");
List<byte[]> zvalues = provider.zrange(setkey, 0, SMALL_CNT);
List<ZSetEntry> zsubset = provider.zrangeSubset(setkey, 0, SMALL_CNT);
for(int i=0;i<SMALL_CNT; i++){
assertEquals(zsubset.get(i).getValue(), dataList.get(i), "value of element from zrange_withscore");
assertEquals(zsubset.get(i).getValue(), zvalues.get(i), "value of element from zrange_withscore compared with zscore with same range query");
assertEquals (zsubset.get(i).getScore(), (double)i, "score of element from zrange_withscore");
assertTrue(zsubset.get(i).getScore() <= zsubset.get(i+1).getScore(), "range member score should be smaller or equal to previous range member. idx: " + i);
if(i>0) assertTrue(zsubset.get(i).getScore() >= zsubset.get(i-1).getScore(), "range member score should be bigger or equal to previous range member. idx: " + i);
}
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
@Test
public void testZrevrangeWithscoresStringByteArray() {
cmd = Command.ZREVRANGE$OPTS.code + " byte[]";
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
String setkey = keys.get(0);
for(int i=0;i<MEDIUM_CNT; i++)
assertTrue(provider.zadd(setkey, i, dataList.get(i)), "zadd of random element should be true");
List<byte[]> zvalues = provider.zrevrange(setkey, 0, SMALL_CNT);
List<ZSetEntry> zsubset = provider.zrevrangeSubset(setkey, 0, SMALL_CNT);
for(int i=0;i<SMALL_CNT; i++){
assertEquals(zsubset.get(i).getValue(), dataList.get(MEDIUM_CNT-i-1), "value of element from zrange_withscore");
assertEquals(zsubset.get(i).getValue(), zvalues.get(i), "value of element from zrange_withscore compared with zscore with same range query");
assertEquals (zsubset.get(i).getScore(), (double)MEDIUM_CNT-i-1, "score of element from zrange_withscore");
assertTrue(zsubset.get(i).getScore() >= zsubset.get(i+1).getScore(), "range member score should be smaller or equal to previous range member. idx: " + i);
if(i>0) assertTrue(zsubset.get(i).getScore() <= zsubset.get(i-1).getScore(), "range member score should be bigger or equal to previous range member. idx: " + i);
}
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
@Test
public void testZrangebyscoreStringByteArray() {
cmd = Command.ZRANGEBYSCORE.code + " byte[]";
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
String setkey = keys.get(0);
for(int i=0;i<MEDIUM_CNT; i++)
assertTrue(provider.zadd(setkey, i, dataList.get(i)), "zadd of random element should be true");
List<byte[]> range = provider.zrangebyscore(setkey, 0, SMALL_CNT);
assertTrue(range.size() > 0, "should have non empty results for range by score here");
for(int i=0;i<SMALL_CNT-1; i++){
assertEquals(range.get(i), dataList.get(i), "expected value in the range by score missing");
}
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
@Test
public void testZrangebyscoreWithScoresStringByteArray() {
cmd = Command.ZRANGEBYSCORE$OPTS.code + " byte[]";
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
String setkey = keys.get(0);
for(int i=0;i<MEDIUM_CNT; i++)
assertTrue(provider.zadd(setkey, i, dataList.get(i)), "zadd of random element should be true");
List<ZSetEntry> range = provider.zrangebyscoreSubset(setkey, 0, SMALL_CNT);
assertTrue(range.size() > 0, "should have non empty results for range by score here");
for(int i=0;i<SMALL_CNT-1; i++){
assertEquals(range.get(i).getValue(), dataList.get(i), "expected value in the range by score missing");
assertEquals(range.get(i).getScore(), (double)i, "score of element from zrangebyscore_withscore");
}
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
@Test
public void testZremrangebyscoreStringByteArray() {
cmd = Command.ZREMRANGEBYSCORE.code + " byte[]";
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
String setkey = keys.get(0);
for(int i=0;i<MEDIUM_CNT; i++)
assertTrue(provider.zadd(setkey, i, dataList.get(i)), "zadd of random element should be true");
long count = provider.zcount(setkey, 0, SMALL_CNT);
assertTrue(count > 0, "should have non-zero number of rem cnt for zcount");
assertEquals(count, SMALL_CNT+1, "should have specific number of rem cnt for zcount");
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
@Test
public void testZcountStringByteArray() {
cmd = Command.ZCOUNT.code + " byte[]";
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
String setkey = keys.get(0);
for(int i=0;i<MEDIUM_CNT; i++)
assertTrue(provider.zadd(setkey, i, dataList.get(i)), "zadd of random element should be true");
long remCnt = provider.zremrangebyscore(setkey, 0, SMALL_CNT);
assertTrue(remCnt > 0, "should have non-zero number of rem cnt for zremrangebyscore");
assertEquals(remCnt, SMALL_CNT+1, "should have specific number of rem cnt for zremrangebyscore");
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
@Test
public void testZremrangebyrankStringByteArray() {
cmd = Command.ZREMRANGEBYRANK.code + " byte[]";
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
String setkey = keys.get(0);
for(int i=0;i<MEDIUM_CNT; i++)
assertTrue(provider.zadd(setkey, i, dataList.get(i)), "zadd of random element should be true");
long remCnt = provider.zremrangebyrank(setkey, 0, SMALL_CNT);
assertTrue(remCnt > 0, "should have non-zero number of rem cnt for zremrangebyrank");
assertEquals(remCnt, SMALL_CNT+1, "should have specific number of rem cnt for zremrangebyrank");
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
catch (RuntimeException rte) { fail(cmd + " RUNTIME-ERROR => " + rte.getLocalizedMessage(), rte); }
}
@Test
public void testZincrbyStringByteArray() {
cmd = Command.ZSCORE.code + " byte[] | " + Command.ZINCRBY.code + " byte[]";
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
String setkey = keys.get(0);
for(int i=0;i<SMALL_CNT; i++)
assertTrue(provider.zadd(setkey, doubleList.get(i), dataList.get(i)), "zadd of random element should be true");
for(int i=0;i<SMALL_CNT; i++)
assertEquals (provider.zscore(setkey, dataList.get(i)).doubleValue(), doubleList.get(i), "zscore of element should be " + doubleList.get(i));
double increment = 0.05;
for(int i=0;i<SMALL_CNT; i++)
assertEquals (provider.zincrby(setkey, increment ,dataList.get(i)).doubleValue(), doubleList.get(i) + increment, "zincr of element should be " + doubleList.get(i) + increment);
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
@Test
public void testZrangeStringByteArray() {
cmd = Command.ZRANGE.code + " byte[]";
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
String setkey = keys.get(0);
for(int i=0;i<MEDIUM_CNT; i++)
assertTrue(provider.zadd(setkey, doubleList.get(i), dataList.get(i)), "zadd of random element should be true");
List<byte[]> range = provider.zrange(setkey, 0, SMALL_CNT);
for(int i=1;i<SMALL_CNT-1; i++){
assertTrue(provider.zscore(setkey, range.get(i)).doubleValue() <= provider.zscore(setkey, range.get(i+1)).doubleValue(), "range member score should be smaller or equal to previous range member");
assertTrue(provider.zscore(setkey, range.get(i)).doubleValue() >= provider.zscore(setkey, range.get(i-1)).doubleValue(), "range member score should be bigger or equal to previous range member");
}
for(int i=0;i<SMALL_CNT; i++)
assertEquals (provider.zscore(setkey, dataList.get(i)), doubleList.get(i), "zscore of element should be " + doubleList.get(i));
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
/**************** SET COMMANDS ******************************/
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#sadd(java.lang.String, byte[])}.
*/
@Test
public void testSaddStringByteArray() {
cmd = Command.SADD.code + " byte[]";
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
String setkey = keys.get(0);
for(int i=0;i<SMALL_CNT; i++)
assertTrue(provider.sadd(setkey, dataList.get(i)), "sadd of random element should be true");
for(int i=0;i<SMALL_CNT; i++)
assertFalse(provider.sadd(setkey, dataList.get(i)), "sadd of existing element should be false");
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#sadd(java.lang.String, java.lang.String)}.
*/
@Test
public void testSaddStringString() {
cmd = Command.SADD.code + " String";
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
String setkey = keys.get(0);
for(int i=0;i<SMALL_CNT; i++)
assertTrue(provider.sadd(setkey, stringList.get(i)), "sadd of random element should be true");
for(int i=0;i<SMALL_CNT; i++)
assertFalse(provider.sadd(setkey, stringList.get(i)), "sadd of existing element should be false");
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#sadd(java.lang.String, java.lang.Number)}.
*/
@Test
public void testSaddStringNumber() {
cmd = Command.SADD.code + " Number";
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
String setkey = keys.get(0);
for(int i=0;i<SMALL_CNT; i++)
assertTrue(provider.sadd(setkey, longList.get(i)), "sadd of random element should be true");
for(int i=0;i<SMALL_CNT; i++)
assertFalse(provider.sadd(setkey, longList.get(i)), "sadd of existing element should be false");
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#sadd(java.lang.String, java.io.Serializable)}.
*/
@Test
public void testSaddStringT() {
cmd = Command.SADD.code + " Java Object";
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
String setkey = keys.get(0);
for(int i=0;i<SMALL_CNT; i++)
assertTrue(provider.sadd(setkey, objectList.get(i)), "sadd of random element should be true");
for(int i=0;i<SMALL_CNT; i++)
assertFalse(provider.sadd(setkey, objectList.get(i)), "sadd of existing element should be false");
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
@Test
public void testSrandmember() {
cmd = Command.SRANDMEMBER.code + " String ";
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
// add a small set
String setkey = keys.get(0);
for(int i=0;i<SMALL_CNT; i++)
assertTrue(provider.sadd(setkey, stringList.get(i)), "sadd of random element should be true");
// get members
List<String> members = null;
members = toStr(provider.smembers(setkey));
assertTrue(members.size() == SMALL_CNT);
// get random member
String randomMemeber = toStr(provider.srandmember(setkey));
boolean found = false;
for(String m : members){
if(m.equals(randomMemeber)) {
found = true;
break;
}
}
assertTrue(found, "random set element should have been in the members list");
// test edget conditions
byte[] membytes = null;
// empty set
provider.sadd("empty", "delete-me");
provider.srem("empty", "delete-me");
membytes = provider.srandmember("empty");
assertEquals(membytes, null, "empty set random member should be null");
assertEquals(toStr(membytes), null, "empty set random member should be null");
// non-existent key
membytes = provider.srandmember("no-such-key");
assertEquals(membytes, null, "non-existent key/set random member should be null");
assertEquals(toStr(membytes), null, "non-existent key/set random member should be null");
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#smembers(java.lang.String)}.
*/
@Test
public void testSmembers() {
cmd = Command.SMEMBERS.code + " byte[] ";
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
String setkey = keys.get(0);
for(int i=0;i<SMALL_CNT; i++)
assertTrue(provider.sadd(setkey, dataList.get(i)), "sadd of random element should be true");
List<byte[]> members = null;
members = provider.smembers(setkey);
assertTrue(members.size() == SMALL_CNT);
// byte[] don't play nice with equals -- values are random so if size matches, its ok
// for(int i=0;i<SMALL_CNT; i++)
// assertTrue(members.contains(dataList.get(i)), "set members should include item at idx: " + i);
// test edget conditions
// empty set
provider.sadd(keys.get(2), dataList.get(0));
provider.srem(keys.get(2), dataList.get(0));
assertEquals(provider.scard(keys.get(2)), 0, "set cardinality for an empty set should be 0");
members = provider.smembers(keys.get(2));
assertEquals(members, Collections.EMPTY_LIST,"smembers should return an empty list");
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
cmd = Command.SMEMBERS.code + " String ";
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
String setkey = keys.get(0);
for(int i=0;i<SMALL_CNT; i++)
assertTrue(provider.sadd(setkey, stringList.get(i)), "sadd of random element should be true");
List<String> members = null;
members = toStr(provider.smembers(setkey));
assertTrue(members.size() == SMALL_CNT);
for(int i=0;i<SMALL_CNT; i++)
assertTrue(members.contains(stringList.get(i)), "set members should include item at idx: " + i);
// test edget conditions
// empty set
provider.sadd(keys.get(2), stringList.get(0));
provider.srem(keys.get(2), stringList.get(0));
assertTrue(provider.scard(keys.get(2)) == 0, "set should be empty now");
members = toStr(provider.smembers(keys.get(2)));
//assertNull(members, "smembers should return null for set that was fully emptied"); // api change.
assertEquals(members.size(), 0, "smembers should have returned an empty list"); // api change - now it is null
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
cmd = Command.SMEMBERS.code + " Number ";
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
String setkey = keys.get(0);
for(int i=0;i<SMALL_CNT; i++)
assertTrue(provider.sadd(setkey, longList.get(i)), "sadd of random element should be true");
List<Long> members = null;
members = toLong (provider.smembers(setkey));
assertTrue(members.size() == SMALL_CNT);
for(int i=0;i<SMALL_CNT; i++)
assertTrue(members.contains(longList.get(i)), "set members should include item at idx: " + i);
// test edget conditions
// empty set
provider.sadd(keys.get(2), longList.get(0));
provider.srem(keys.get(2), longList.get(0));
assertTrue(provider.scard(keys.get(2)) == 0, "set should be empty now");
members = toLong (provider.smembers(keys.get(2)));
//assertNull(members, "smembers should return null"); // api change (also toLong changed to handle the null results).
assertEquals(members.size(), 0, "smembers should have returned an empty list");
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
cmd = Command.SMEMBERS.code + " Java Object ";
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
String setkey = keys.get(0);
for(int i=0;i<SMALL_CNT; i++)
assertTrue(provider.sadd(setkey, objectList.get(i)), "sadd of random element should be true");
List<TestBean> members = null;
members = decode (provider.smembers(setkey));
assertTrue(members.size() == SMALL_CNT);
for(int i=0;i<SMALL_CNT; i++)
assertTrue(members.contains(objectList.get(i)), "set members should include item at idx: " + i);
// test edget conditions
// empty set
provider.sadd(keys.get(2), objectList.get(0));
provider.srem(keys.get(2), objectList.get(0));
assertTrue(provider.scard(keys.get(2)) == 0, "set should be empty now");
members = decode (provider.smembers(keys.get(2)));
//assertNull(members, "smembers should return null"); // API change
assertEquals(members.size(), 0, "smembers should have returned an empty list");
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#sismember(java.lang.String, byte[])}.
*/
@Test
public void testSmoveStringByteArray() {
cmd = Command.SMOVE.code + " byte[]";
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
String srckey = keys.get(0);
String destkey = keys.get(1);
for(int i=0;i<SMALL_CNT; i++)
assertTrue(provider.sadd(srckey, dataList.get(i)), "sadd of random element should be true");
for(int i=0;i<SMALL_CNT; i++) {
assertTrue(provider.sismember(srckey, dataList.get(i)), "should be a member of the src before move");
/* smove */
assertTrue(provider.smove (srckey, destkey, dataList.get(i)), "move should be ok");
assertTrue(provider.sismember(destkey, dataList.get(i)), "should be a member of the dest after move");
assertFalse(provider.sismember(srckey, dataList.get(i)), "should NOT be a member of the src after move");
}
// lets try the error conditions by using wrong type for src or dest
boolean expectedError;
String stringKey = "foo";
provider.set(stringKey, "smove test");
String listKey = "bar";
provider.lpush(listKey, "smove test");
// wrong dest
expectedError = false;
try {
Log.log("Expecting an operation against key holding the wrong kind of value ERROR..");
assertTrue(provider.smove (destkey, stringKey, dataList.get(0)), "dest is wrong type");
}
catch (RedisException e) { expectedError = true; }
assertTrue(expectedError, "should have raised an exception but did not");
// wrong src
expectedError = false;
try {
Log.log("Expecting an operation against key holding the wrong kind of value ERROR..");
assertTrue(provider.smove (stringKey, srckey, dataList.get(0)), "src is wrong type");
}
catch (RedisException e) { expectedError = true; }
assertTrue(expectedError, "should have raised an exception but did not");
// wrong src and dest
expectedError = false;
try {
Log.log("Expecting an operation against key holding the wrong kind of value ERROR..");
assertTrue(provider.smove (listKey, stringKey, dataList.get(0)), "src and dest are wrong type");
}
catch (RedisException e) { expectedError = true; }
assertTrue(expectedError, "should have raised an exception but did not");
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#sismember(java.lang.String, byte[])}.
*/
@Test
public void testSismemberStringByteArray() {
cmd = Command.SISMEMBER.code + " byte[]";
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
String setkey = keys.get(0);
for(int i=0;i<SMALL_CNT; i++)
assertTrue(provider.sadd(setkey, dataList.get(i)), "sadd of random element should be true");
for(int i=0;i<SMALL_CNT; i++)
assertTrue(provider.sismember(setkey, dataList.get(i)), "should be a member of the set");
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#sismember(java.lang.String, java.lang.String)}.
*/
@Test
public void testSismemberStringString() {
cmd = Command.SISMEMBER.code + " String";
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
String setkey = keys.get(0);
for(int i=0;i<SMALL_CNT; i++)
assertTrue(provider.sadd(setkey, stringList.get(i)), "sadd of random element should be true");
for(int i=0;i<SMALL_CNT; i++)
assertTrue(provider.sismember(setkey, stringList.get(i)), "should be a member of the set");
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#sismember(java.lang.String, java.lang.Number)}.
*/
@Test
public void testSismemberStringNumber() {
cmd = Command.SISMEMBER.code + " Number";
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
String setkey = keys.get(0);
for(int i=0;i<SMALL_CNT; i++)
assertTrue(provider.sadd(setkey, longList.get(i)), "sadd of random element should be true");
for(int i=0;i<SMALL_CNT; i++)
assertTrue(provider.sismember(setkey, longList.get(i)), "should be a member of the set");
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#sismember(java.lang.String, java.io.Serializable)}.
*/
@Test
public void testSismemberStringT() {
cmd = Command.SISMEMBER.code + " Java Object";
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
String setkey = keys.get(0);
for(int i=0;i<SMALL_CNT; i++)
assertTrue(provider.sadd(setkey, objectList.get(i)), "sadd of random element should be true");
for(int i=0;i<SMALL_CNT; i++)
assertTrue(provider.sismember(setkey, objectList.get(i)), "should be a member of the set");
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#scard(java.lang.String)}.
*/
@Test
public void testScard() {
cmd = Command.SCARD.code + " Java Object";
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
String setkey = keys.get(0);
for(int i=0;i<SMALL_CNT; i++)
assertTrue(provider.sadd(setkey, dataList.get(i)), "sadd of random element should be true");
assertEquals (provider.scard (setkey), SMALL_CNT, "scard should be SMALL_CNT");
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#scard(java.lang.String)}.
*/
@Test
public void testZcard() {
cmd = Command.ZADD.code + " Java Object | " + Command.ZCARD.code;
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
String setkey = keys.get(0);
for(int i=0;i<SMALL_CNT; i++)
assertTrue(provider.zadd(setkey, i, dataList.get(i)), "zadd of random element should be true");
assertEquals (provider.zcard (setkey), SMALL_CNT, "zcard should be SMALL_CNT");
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#sinter(java.lang.String, java.lang.String[])}.
*/
@Test
public void testSinter() {
cmd = Command.SINTER.code;
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
String setkey1 = keys.get(0);
String setkey2 = keys.get(1);
String setunique = keys.get(2);
for(int i=0;i<SMALL_CNT; i++) {
assertTrue(provider.sadd(setkey1, dataList.get(i)), "sadd of random element should be true");
assertTrue(provider.sadd(setkey2, dataList.get(i+2)), "sadd of random element should be true");
assertTrue(provider.sadd(setunique, dataList.get(10+i+SMALL_CNT)), "sadd of random element should be true");
}
assertEquals (0, provider.sinter(setkey1, setkey2, setunique).size(), "should be no common elements in all three");
assertTrue (provider.sinter(setkey1, setkey2).size() > 0, "should be common elements in set 1 and 2");
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#sinterstore(java.lang.String, java.lang.String[])}.
*/
@Test
public void testSinterstore() {
cmd = Command.SINTERSTORE.code;
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
String setkey1 = keys.get(0);
String setkey2 = keys.get(1);
String setunique = keys.get(2);
String interset = keys.get(3);
for(int i=0;i<SMALL_CNT; i++) {
assertTrue(provider.sadd(setkey1, dataList.get(i)), "sadd of random element should be true");
assertTrue(provider.sadd(setkey2, dataList.get(i+2)), "sadd of random element should be true");
assertTrue(provider.sadd(setunique, dataList.get(10+i+SMALL_CNT)), "sadd of random element should be true");
}
provider.sinterstore (interset, setkey1, setkey2, setunique);
assertEquals (0, provider.scard(interset), "interset set should be empty");
provider.sinterstore (interset, setkey1, setkey2);
assertTrue (provider.scard(interset) > 0, "interset set should be non-empty");
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#sunion(java.lang.String, java.lang.String[])}.
*/
@Test
public void testSunion() {
cmd = Command.SUNION.code;
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
String setkey1 = keys.get(0);
String setkey2 = keys.get(1);
String setunique = keys.get(2);
for(int i=0;i<SMALL_CNT; i++) {
assertTrue(provider.sadd(setkey1, dataList.get(i)), "sadd of random element should be true");
assertTrue(provider.sadd(setkey2, dataList.get(i)), "sadd of random element should be true");
assertTrue(provider.sadd(setunique, stringList.get(i)), "sadd of random element should be true");
}
assertEquals (SMALL_CNT, provider.sunion (setkey1, setkey2).size(), "union of equiv sets should have same card as the two");
assertEquals (SMALL_CNT*2, provider.sunion (setkey1, setkey2, setunique).size(), "union of all 3 sets should have SMALL_CNT * 2 members");
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#sunionstore(java.lang.String, java.lang.String[])}.
*/
@Test
public void testSunionstore() {
cmd = Command.SUNIONSTORE.code;
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
String setkey1 = keys.get(0);
String setkey2 = keys.get(1);
String setunique = keys.get(2);
String union = keys.get(3);
for(int i=0;i<SMALL_CNT; i++) {
assertTrue(provider.sadd(setkey1, dataList.get(i)), "sadd of random element should be true");
assertTrue(provider.sadd(setkey2, dataList.get(i)), "sadd of random element should be true");
assertTrue(provider.sadd(setunique, stringList.get(i)), "sadd of random element should be true");
}
provider.sunionstore (union, setkey1, setkey2);
assertEquals (SMALL_CNT, provider.scard(union), "union of equiv sets should have same card as the two");
provider.sunionstore (union, setkey1, setkey2, setunique);
assertEquals (SMALL_CNT*2, provider.scard(union), "union of all 3 sets should have SMALL_CNT * 2 members");
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#sdiff(java.lang.String, java.lang.String[])}.
*/
@Test
public void testSdiff() {
cmd = Command.SDIFF.code;
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
String setkey1 = keys.get(0);
String setkey2 = keys.get(1);
String setkey3 = keys.get(2);
String setexpectedkey = keys.get(3);
//
// - per the redis doc --
// note that basically, SDIFF k, k1, ..., kn is a diff between k and union (k1, .., kn)
//
provider.sadd(setkey1, "x");
provider.sadd(setkey1, "a");
provider.sadd(setkey1, "b");
provider.sadd(setkey1, "c");
provider.sadd(setkey2, "c");
provider.sadd(setkey3, "a");
provider.sadd(setkey3, "d");
provider.sadd(setexpectedkey, "x");
provider.sadd(setexpectedkey, "b");
List<String> sdiffResults = DefaultCodec.toStr(provider.sdiff(setkey1, setkey2, setkey3));
assertEquals(provider.scard(setexpectedkey), sdiffResults.size(), "sdiff result and expected set should have same cardinality");
for(String s : sdiffResults)
assertTrue(provider.sismember(setexpectedkey, s), s + " should be a member of the expected result set");
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#sdiff(java.lang.String, java.lang.String[])}.
*/
@Test
public void testSdiffstore() {
cmd = Command.SDIFFSTORE.code;
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
String setkey1 = keys.get(0);
String setkey2 = keys.get(1);
String setkey3 = keys.get(2);
String setdiffreskey = keys.get(3);
//
// - per the redis doc --
// note that basically, SDIFF k, k1, ..., kn is a diff between k and union (k1, .., kn)
//
provider.sadd(setkey1, "x");
provider.sadd(setkey1, "a");
provider.sadd(setkey1, "b");
provider.sadd(setkey1, "c");
provider.sadd(setkey2, "c");
provider.sadd(setkey3, "a");
provider.sadd(setkey3, "d");
provider.sdiffstore (setdiffreskey, setkey1, setkey2, setkey3);
assertEquals(provider.scard(setdiffreskey), provider.sdiff(setkey1, setkey2, setkey3).size(), "sdiff result and sdiffstore dest set should have same cardinality");
assertTrue(provider.sismember(setdiffreskey, "x"), "x should be a member of the expected result set");
assertTrue(provider.sismember(setdiffreskey, "b"), "b should be a member of the expected result set");
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#srem(java.lang.String, byte[])}.
*/
@Test
public void testSremStringByteArray() {
cmd = Command.SISMEMBER.code + " byte[]";
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
String setkey = keys.get(0);
for(int i=0;i<SMALL_CNT; i++)
assertTrue(provider.sadd(setkey, dataList.get(i)), "sadd of random element should be true");
for(int i=0;i<SMALL_CNT; i++)
assertTrue(provider.srem(setkey, dataList.get(i)), "should be a removable member of the set");
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#srem(java.lang.String, java.lang.String)}.
*/
@Test
public void testSremStringString() {
cmd = Command.SISMEMBER.code + " String";
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
String setkey = keys.get(0);
for(int i=0;i<SMALL_CNT; i++)
assertTrue(provider.sadd(setkey, stringList.get(i)), "sadd of random element should be true");
for(int i=0;i<SMALL_CNT; i++)
assertTrue(provider.srem(setkey, stringList.get(i)), "should be a removable member of the set");
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#srem(java.lang.String, java.lang.Number)}.
*/
@Test
public void testSremStringNumber() {
cmd = Command.SISMEMBER.code + " Number";
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
String setkey = keys.get(0);
for(int i=0;i<SMALL_CNT; i++)
assertTrue(provider.sadd(setkey, longList.get(i)), "sadd of random element should be true");
for(int i=0;i<SMALL_CNT; i++)
assertTrue(provider.srem(setkey, longList.get(i)), "should be a removable member of the set");
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#srem(java.lang.String, java.io.Serializable)}.
*/
@Test
public void testSremStringT() {
cmd = Command.SISMEMBER.code + " Java Object";
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
String setkey = keys.get(0);
for(int i=0;i<SMALL_CNT; i++)
assertTrue(provider.sadd(setkey, objectList.get(i)), "sadd of random element should be true");
for(int i=0;i<SMALL_CNT; i++)
assertTrue(provider.srem(setkey, objectList.get(i)), "should be a removable member of the set");
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
/************************ DB COMMANDS ***********************/
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#dbsize()}.
*/
@Test
public void testDbsize() {
cmd = Command.DBSIZE.code ;
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
provider.flushdb();
assertTrue (provider.dbsize() == 0);
for (int i=0; i<SMALL_CNT; i++)
provider.set(keys.get(i), dataList.get(i));
assertTrue (provider.dbsize() == SMALL_CNT, "dbsize should be SMALL_CNT");
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#randomkey()}.
*/
@Test
public void testRandomkey() {
cmd = Command.RANDOMKEY.code ;
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
assertTrue(provider.dbsize() == 0);
// String iamempty = provider.randomkey();
byte[] iamempty = provider.randomkey();
assertNull(iamempty, "randomkey of an empty db should be null, but instead it was: " + iamempty);
for (int i=0; i<MEDIUM_CNT; i++)
provider.set(keys.get(i), dataList.get(i));
assertTrue (provider.dbsize() == MEDIUM_CNT, "dbsize should be MEDIUM_CNT");
for (int i=0; i<SMALL_CNT; i++) {
assertTrue(keys.contains(new String(provider.randomkey())), "randomkey should be an item in our keys list");
}
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
// /**
// * Test method for {@link org.jredis.ri.alphazero.JRedisSupport#move(java.lang.String, int)}.
// */
// @Test
// public void testMove() {
// test = Command.MOVE.code ;
// Log.log("TEST: %s command", test);
// try {
// jredis.flushdb();
// assertTrue (jredis.dbsize() == 0, "db1 should be empty");
//
// jredis.select(db2).flushdb();
// assertTrue (jredis.dbsize() == 0, "db2 should be empty");
//
// jredis.set(keys.get(0), dataList.get(0));
// assertTrue (jredis.dbsize() == 1, "db2 should have 1 key at this point");
//
// jredis.move(keys.get(0), db1);
// assertTrue (jredis.dbsize() == 0, "db2 should be empty again");
// jredis.select(db1);
// assertTrue (jredis.dbsize() == 1, "db1 should have 1 key at this point");
//
// }
// catch (RedisException e) { fail(test + " ERROR => " + e.getLocalizedMessage(), e); }
// }
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#type(java.lang.String)}.
*/
@Test
public void testType() {
cmd = Command.TYPE.code ;
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
provider.set(keys.get(0), dataList.get(0));
provider.sadd(keys.get(1), dataList.get(1));
provider.rpush(keys.get(2), dataList.get(2));
assertTrue(provider.type(keys.get(0))==RedisType.string, "type should be string");
assertTrue(provider.type(keys.get(1))==RedisType.set, "type should be set");
assertTrue(provider.type(keys.get(2))==RedisType.list, "type should be list");
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#debug()}.
*/
@Test
public void testDebug() {
cmd = Command.DEBUG.code ;
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
provider.set("foo", "bar");
ObjectInfo info = provider.debug("foo");
assertNotNull(info);
Log.log("DEBUG of key => %s", info);
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#info()}.
*/
@Test
public void testInfo() {
cmd = Command.INFO.code ;
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
Map<String, String> infoMap = provider.info();
for (RedisInfo info : RedisInfo.values()){
if(infoMap.get(info.name()) == null){
Log.problem("Note that expected INFO entry %s is apparently deprecated - IGNORING", info);
} else {
Log.log("%s => %s", info.name(), infoMap.get(info.name()));
}
}
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#keys()}.
*/
@Test
public void testKeys() {
cmd = Command.KEYS.code + " (*)";
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
for (int i=0; i<SMALL_CNT; i++)
provider.set(keys.get(i), dataList.get(i));
List<byte[]> redisBinkeys = provider.keys();
List<String> rediskeys = new ArrayList<String>(redisBinkeys.size());
for(byte[] bk : redisBinkeys)
rediskeys.add(new String(bk));
assertEquals(SMALL_CNT, rediskeys.size(), "size of key list should be SMALL_CNT");
for(int i=0; i<SMALL_CNT; i++)
assertTrue(rediskeys.contains(keys.get(i)), "should contain " + keys.get(i));
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
/**
* Test method for {@link org.jredis.ri.alphazero.JRedisSupport#keys(java.lang.String)}.
*/
@Test
public void testKeysString() {
cmd = Command.KEYS.code + " (using patterns)";
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
for (int i=0; i<SMALL_CNT; i++)
provider.set(patternList.get(i), dataList.get(i));
List<byte[]> redisBinkeys = provider.keys("*"+patternA+"*");
List<String> rediskeys = new ArrayList<String>(redisBinkeys.size());
for(byte[] bk : redisBinkeys)
rediskeys.add(new String(bk));
assertEquals(SMALL_CNT, rediskeys.size(), "size of key list should be SMALL_CNT");
for(int i=0; i<SMALL_CNT; i++)
assertTrue(rediskeys.contains(patternList.get(i)), "should contain " + patternList.get(i));
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
@Test
public void testEcho() {
cmd = Command.ECHO.code;
Log.log("TEST: %s command", cmd);
try {
provider.flushdb();
assertEquals(dataList.get(0), provider.echo(dataList.get(0)), "data and echo results");
byte[] zerolenData = new byte[0];
assertEquals(zerolenData, provider.echo(zerolenData), "zero len byte[] and echo results");
boolean expected = false;
try {
provider.echo((byte[])null);
}
catch(IllegalArgumentException e) { expected = true; }
assertTrue(expected, "expecting exception for null value to ECHO");
}
catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
}
// /**
// * Test method for {@link org.jredis.ri.alphazero.JRedisSupport#shutdown()}.
// */
// @Test
// public void testShutdown() {
// fail("Not yet implemented");
// }
//
// ========================================================================
// Test MULTI/EXEC/DISCARD *BASICS*
// ========================================================================
/**
* Test the basics of multi/exec/discard
* TODO: requires supports() in JRedis.
*/
// @Test
// public void testMultiDiscardBasics() {
// cmd = Command.MULTI + " | " + Command.DISCARD + " | basics";
// Log.log("TEST: %s command", cmd);
//
// try {
// provider.flushdb();
// }
// catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
//
// try {
// provider.multi();
// provider.discard();
// }
// catch (RedisException e) { fail(cmd + " ERROR => " + e.getLocalizedMessage(), e); }
//
// boolean didRaiseEx;
// didRaiseEx = false;
// try {
// provider.discard();
// }
// catch (IllegalArgumentException e) {didRaiseEx = true;}
// catch (Throwable whatsthis) { fail ("unexpected exception raised", whatsthis);}
// if(!didRaiseEx){ fail ("Expected exception not raised."); }
// }
// ========================================================================
// Test Properties
// ========================================================================
/** the JRedis implementation being tested */
// private JRedis provider = null;
// ------------------------------------------------------------------------
// JRedis Provider initialize methods
// ------------------------------------------------------------------------
// /**
// * Sets the {@link JRedis} implementation provider for the test suite
// */
// @BeforeTest
// public void setJRedisProvider () {
// try {
// JRedis jredis = newJRedisProviderInstance();
//
// setJRedisProviderInstance(jredis);
// prepTestDBs();
//
// Log.log("JRedisClientNGTest.setJRedisProvider - done");
// }
// catch (ClientRuntimeException e) {
// Log.error(e.getLocalizedMessage());
// }
// }
//
// /**
// * Extension point: Tests for specific implementations of {@link JRedis}
// * implement this method to create the provider instance.
// * @return {@link JRedis} implementation instance
// */
// protected abstract JRedis newJRedisProviderInstance () ;
//
// /**
// * Must be called by a BeforeTest method to set the jredis parameter.
// * @param jredisProvider that is being tested.
// */
// protected final void setJRedisProviderInstance (JRedis jredisProvider) {
// this.jredis = jredisProvider;
// Log.log( "TEST: " +
// "\n\t-----------------------------------------------\n" +
// "\tProvider Class: %s" +
// "\n\t-----------------------------------------------\n",
// jredisProvider.getClass().getCanonicalName());
// }
// /**
// * @return the {@link JRedis} instance used for the provider tests
// */
// protected final JRedis getJRedisProviderInstance() {
// return jredis;
// }
}