标签：assertTrue jredis String redis e1 ----------------------------------------------
/*
* Copyright 2009 Joubin Mohammad 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 java.io.Serializable;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.Set;
import org.jredis.JRedis;
import org.jredis.RedisException;
import org.jredis.RedisInfo;
import org.jredis.RedisType;
import org.jredis.ri.alphazero.JRedisClient;
import org.jredis.ri.alphazero.support.Encode;
import org.jredis.ri.alphazero.support.Log;
import junit.framework.TestCase;
publicclassJRedisClientTestextendsTestCase{
// ------------------------------------------------------------------------
// TEST SETUP Consts
// ------------------------------------------------------------------------
// we'll use some unlikely numbers just in case someone runs this and
// their data gets hosed! ..
// TODO: note this in the docs!
/** One of the databases we'll use -- this is #10 */
staticint DB1 =10;
/** One of the databases we'll use -- this is #13 */
staticint DB2 =13;
staticint SMALL_DATA = 128;
staticint MEDIUM_DATA =1024*2;
staticint LARGE_DATA = 1024*512;
// ------------------------------------------------------------------------
// TEST KEYS AND DATA
// ------------------------------------------------------------------------
privateJRedis redis;
privateString password;
finalRandom random =newRandom(System.currentTimeMillis());
// we'll uses these for values
finalList<byte[]> dataList =newArrayList<byte[]>();
finalList<TestBean> objectList =newArrayList<TestBean>();
finalList<String> stringList =newArrayList<String>();
finalList<String> patternList =newArrayList<String>();
finalList<Integer> intList =newArrayList<Integer>();
finalList<Long> longList=newArrayList<Long>();
finalSet<String> uniqueSet =newHashSet<String>();
finalSet<String> commonSet =newHashSet<String>();
finalSet<String> set1 =newHashSet<String>();
finalSet<String> set2 =newHashSet<String>();
finalint smallcnt =10;
finalint mediumcnt =1000;
finalint largecnt =100000;
finalString patternA ="_AAA_";
int cnt;
finalbyte[] smallData = getRandomBytes(SMALL_DATA);
finalbyte[] mediumData = getRandomBytes(MEDIUM_DATA);
finalbyte[] largeData = getRandomBytes(LARGE_DATA);
finalList<String> keys =newArrayList<String>();
String key =null;
byte bytevalue;
String stringvalue;
int intValue;
long longValue;
TestBean objectvalue;
// ------------------------------------------------------------------------
// JUNIT
// ------------------------------------------------------------------------
protectedvoid setUp()throwsException{
super.setUp();
Log.log("TEST: generating random test data ...");
/** setup data */
cnt = mediumcnt;
for(int i=0; i<cnt; i++){
keys.add(getRandomString (48));
patternList.add(getRandomString(random.nextInt(10)+2)+ patternA + getRandomString(random.nextInt(10)+2));
uniqueSet.add(getRandomString(48));
commonSet.add(getRandomString(48));
set1.add("set_1"+ getRandomString(20));
set2.add("set_2"+ getRandomString(20));
dataList.add(getRandomBytes (128));
stringList.add(getRandomString (128));
objectList.add(newTestBean("testbean."+ i));
intList.add(random.nextInt());
longList.add(random.nextLong());
}
for(String m : commonSet){
set1.add(m);
set2.add(m);
}
password ="jredis";
/** create client, connect and authorize with Redis + a ping */
Log.log("TEST: creating and authorizing with localhost server (using password %s) ...", password);
try{
redis =newJRedisClient().auth(password).ping();
}
catch(RedisException e){
Log.error("Test setup create - connect - authorize: "+ e.getLocalizedMessage());
throw e;
}
/** flush our two dbs */
Log.log("TEST: Flushing the test dbs (using %d and %d) ...", DB1, DB2);
try{
redis.select(DB1).flushdb();
redis.select(DB2).flushdb();
}
catch(RedisException e){
Log.error("Test setup create - flushing DBs: "+ e.getLocalizedMessage());
throw e;
}
}
protectedvoid tearDown()throwsException{
super.tearDown();
/** just need to quit so connection is closed - a test on its own*/
try{
redis.quit();
}
catch(Exception e){
Log.error("Test tearDown failure: "+ e.getLocalizedMessage());
throw e;
}
}
// ------------------------------------------------------------------------
// *** TESTS ***
// EXPIRE
// ------------------------------------------------------------------------
publicvoid testInit(){
Log.log("TEST: testing new and doX() for various permutations ...");
Log.log("TEST: ing new and basic initial doX() for various permutations ...");
try{
JRedis r =newJRedisClient().ping();
r.quit();
}
catch(RedisException e){
Log.error("Test setup create - connect - ping: "+ e.getLocalizedMessage());
fail("init failed: "+ e.getLocalizedMessage());
}
Log.log("TEST: PING");
try{
JRedis r =newJRedisClient();
r.smembers("no-such-set");
r.quit();
}
catch(RedisException e){
Log.error("Test setup create - connect - smembers: "+ e.getLocalizedMessage());
fail("init failed: "+ e.getLocalizedMessage());
}
Log.log("TEST: new() -> SMEMBERS on non-exist set ->quit()");
boolean expectedError =false;
try{
String not_a_set ="not-a-set";
JRedis r =newJRedisClient();
r.set(not_a_set,"a value");
r.smembers(not_a_set);
}
catch(RedisException e){ expectedError =true;}
finally{
if(!expectedError){
Log.error("Test ");
fail("Did not raise expected ERR on operating on key of wrong type ");
}
}
Log.log("TEST: new() -> set(key) -> SMEMBERS (key) ->quit()");
try{
redis =newJRedisClient();
redis.incr("__jredisclienttestkey__"); // sorry, but can't do a select if this test is to be meaningful
}
catch(RedisException e){
Log.error("Test setup create - connect - authorize: "+ e.getLocalizedMessage());
fail("init failed: "+ e.getLocalizedMessage());
}
}
// ------------------------------------------------------------------------
// *** TESTS *** Commands operating on DBs
// EXPIRE EXISTS SAVE SAVEBG LASTSAVE
// ------------------------------------------------------------------------
publicvoid testDBCommands (){
Log.log("TEST: test expire... this will Thread.sleep for a few secs ...");
try{ redis.select(DB1).flushdb();}
catch(RedisException e1){
e1.printStackTrace();
fail("error SELECTing database => "+ e1.getLocalizedMessage());
}
try{
redis.select (DB1).flushdb();
assertTrue(redis.dbsize()==0);
key ="expire-me";
redis.set(key,System.currentTimeMillis());
assertTrue (redis.exists(key));
redis.expire(key,1);
assertTrue (redis.exists(key));
Thread.sleep(500);
assertTrue (redis.exists(key));
Thread.sleep(2000);
assertFalse (redis.exists(key));
long when = redis.lastsave();
redis.save();
long when2 = redis.lastsave();
assertTrue(when != when2);
}
catch(RedisException e1){
e1.printStackTrace();
fail("error => "+ e1.getLocalizedMessage());
}
catch(InterruptedException e){
fail ("thread was interrupted and test did not conclude"+ e.getLocalizedMessage());
}
}
// ------------------------------------------------------------------------
// *** TESTS *** Commands operating on Lists
// RPUSH LPUSH LLEN LRANGE TRIM LINDEX LSET LREM LPOP RPOP
// ------------------------------------------------------------------------
publicvoid testListCommands (){
Log.log("TEST: test Commands Operating On Sets...");
try{ redis.select(DB1).flushdb();}
catch(RedisException e1){
e1.printStackTrace();
fail("error SELECTing database => "+ e1.getLocalizedMessage());
}
String key1 ="list1";
String key2 ="list2";
try{
for(String item : stringList){
redis.lpush (key1, item);
redis.rpush (key2, item);
}
List<String> range1 =Encode.toStr(redis.lrange(key1,0,Integer.MAX_VALUE));
List<String> range2 =Encode.toStr(redis.lrange(key2,0,Integer.MAX_VALUE));
assertTrue(range1.size()== stringList.size());
assertTrue(range2.size()== stringList.size());
for(String s : stringList){
assertTrue(range1.contains(s));
assertTrue(range2.contains(s));
}
for(int i=0; i<stringList.size(); i++){
assertTrue (stringList.get(i).equals(range1.get(stringList.size()-i-1)));
assertTrue (stringList.get(i).equals(range2.get(i)));
}
key ="num-list";
for(int i=0; i<10; i++){
redis.lpush (key, i);
}
assertTrue ("LLEN", redis.llen(key)==10);
assertTrue ("LREM", redis.lrem (key,2,0)==1);
assertTrue ("LLEN", redis.llen(key)==9);
redis.ltrim(key,2,4);
assertTrue("Testing LTRIM", redis.llen(key)==3);
redis.lpush(key,"aaaa");
redis.lpush(key,"bbbb");
redis.lpush(key,"cccc");
redis.lset(key,0,"number zero");
assertTrue("Testint LIndex",Encode.toStr(redis.lindex(key,0)).equals("number zero"));
redis.lset(key,1,"number nine");
assertTrue("Testint LIndex",Encode.toStr(redis.lindex(key,1)).equals("number nine"));
redis.flushdb();
for(String item : stringList)
redis.lpush (key1, item);// LPUSH is list.add, RPUSH is list.push
for(@SuppressWarnings("unused")String foo : stringList)
redis.lpop(key1);
assertTrue("Testing LPOP", redis.llen(key1)==0);
redis.flushdb();
for(int i=0; i<100; i++)
redis.rpush(key1, i);
for(int i=0; i<100; i++)
assertTrue("Testing RPOP and encode as well",Encode.toInt(redis.rpop(key1))==99-i);
redis.flushdb();
for(int i=0; i<100; i++)
redis.lpush(key1, i);
for(int i=0; i<100; i++)
assertTrue("Testing LPOP and encode as well",Encode.toInt(redis.lpop(key1))==99-i);
}
catch(RedisException e1){
e1.printStackTrace();
fail("error => "+ e1.getLocalizedMessage());
}
}
// ------------------------------------------------------------------------
// *** TESTS *** Commands operating on Sets
// SADD SREM SCARD SISMEMBER SINTER SINTERSTORE SMEMBERS
// ------------------------------------------------------------------------
publicvoid testSetCommands (){
Log.log("TEST: test Commands Operating On Sets...");
try{ redis.select(DB1).flushdb();}
catch(RedisException e1){
e1.printStackTrace();
fail("error SELECTing database => "+ e1.getLocalizedMessage());
}
try{
String key1 ="set1";
String key2 ="set2";
String keyunique ="unique";
for(String member : set1){
assertTrue(redis.sadd(key1, member));
}
assertTrue(redis.scard(key1)== set1.size());
for(String member : set1){
assertTrue(redis.sismember(key1, member));
}
List<String> redisSet1Members =Encode.toStr(redis.smembers(key1));
assertTrue(redisSet1Members.size()== set1.size());
for(String member : set2){
assertTrue(redis.sadd(key2, member));
}
assertTrue(redis.scard(key2)== set2.size());
for(String member : set2){
assertTrue(redis.sismember(key2, member));
}
List<String> redisSet2Members =Encode.toStr(redis.smembers(key2));
assertTrue(redisSet2Members.size()== set2.size());
for(String member : uniqueSet){
assertTrue(redis.sadd(keyunique, member));
}
assertTrue(redis.sinter(keyunique, key1).size()==0);
assertTrue(redis.sinter(keyunique, key2).size()==0);
assertTrue(redis.sinter(keyunique, key1, key2).size()==0);
assertFalse(redis.sinter(keyunique, key1, key2).size()== commonSet.size());
assertTrue(redis.sinter(key1, key2).size()== commonSet.size());
String storeKey ="common-set-stored";
redis.sinterstore(storeKey, key1, key2);
for(String m : commonSet){
assertTrue (redis.sismember(storeKey, m));
assertTrue (redis.srem(key1, m));
}
assertTrue(redis.sinter(key1, key2).size()==0);
redis.flushdb();
}
catch(RedisException e1){
e1.printStackTrace();
fail("error => "+ e1.getLocalizedMessage());
}
}
// ------------------------------------------------------------------------
// *** TESTS *** Using JAVA OBJECTS -- not exhaustive -- just samply some
// key redis actions SET GET SADD RPUSH, etc.
// ------------------------------------------------------------------------
publicvoid testJavaObjects (){
Log.log("TEST: test Commands Operating On String Values and Key Space...");
try{ redis.select(DB1).flushdb();}
catch(RedisException e1){
e1.printStackTrace();
fail("error SELECTing database => "+ e1.getLocalizedMessage());
}
try{
/* as STRING values */
TestBean redisBean =null;
for(int i=0; i<objectList.size(); i++){
redis.set(keys.get(i), objectList.get(i));
redisBean =Encode.decode(redis.get(keys.get(i)));
assertEquals(objectList.get(i), redisBean);
}
/* as SET values */
redis.flushdb();
String objectSet ="test-beans";
redisBean =null;
for(int i=0; i<smallcnt; i++){
redis.sadd(objectSet, objectList.get(i));
}
// TODO: redo using semantic interface
// List<TestBean> redisBeanList = Encode.decode(redis.smembers(objectSet));
// for (int i=0; i<smallcnt; i++){
// assertTrue(redisBeanList.contains(objectList.get(i)));
// }
/* as LIST values */
redis.flushdb();
String listkey ="test-beans";
redisBean =null;
for(int i=0; i<smallcnt; i++){
redis.rpush(listkey, objectList.get(i));
}
// TODO: redo using semantic interface
// List<TestBean> redisRange = Encode.decode(redis.lrange(listkey, 0, smallcnt));
// for (int i=0; i<smallcnt; i++){
// assertTrue(redisRange.contains(objectList.get(i)));
// }
}
catch(RedisException e1){
e1.printStackTrace();
fail("error => "+ e1.getLocalizedMessage());
}
}
// ------------------------------------------------------------------------
// *** TESTS *** "STRING" VALUES
// GET, SET, SETNX, MGET, EXISTS, DEL, TYPE
// INCR, INCRBY, DECR, DECRBY
// *** TESTS *** KEY SPACE
// KEYS, RANDOMKEY, RENAME, RENAMENX, DBSIZE [checked]
// ------------------------------------------------------------------------
publicvoid testCommandsOperatingOnStringValues () {
Log.log("TEST: test Commands Operating On String Values and Key Space...");
try{ redis.select(DB1);}
catch(RedisException e1){
e1.printStackTrace();
fail("error SELECTing database => "+ e1.getLocalizedMessage());
}
/* SET GET SETNX MGET DEL EXISTS TYPE */
try{
byte[] value;
byte[] redisvalue;
for(int i=0; i<cnt; i++){
key = keys.get(i);
value = dataList.get(i);
redis.set(key, value);
assertTrue(redis.exists(key));
redisvalue = redis.get(key);
assertTrue(value.length == redisvalue.length);
for(int j=0; j<value.length; j++)
assertTrue(value[j]==redisvalue[j]);
}
assertNotNull(redis.get(key));
assertFalse(redis.setnx(key,"the key is already set!"));
assertTrue(redis.del(key));
assertFalse(redis.del(key));
assertTrue(redis.setnx(key,"the key is ready to be set again!"));
List<byte[]> mgetBytes = redis.mget(keys.get(random.nextInt(keys.size())), keys.get(random.nextInt(keys.size())), keys.get(random.nextInt(keys.size())));
for(int i=0; i<mgetBytes.size(); i++)
assertNotNull(mgetBytes.get(i));
mgetBytes = redis.mget("not_there", keys.get(random.nextInt(keys.size())), keys.get(random.nextInt(keys.size())), keys.get(random.nextInt(keys.size())));
assertNull(mgetBytes.get(0));
for(int i=1; i<mgetBytes.size(); i++)
assertNotNull(mgetBytes.get(i));
mgetBytes = redis.mget("not_there","not_there","not_there","not_there", keys.get(random.nextInt(keys.size())));
assertNotNull(mgetBytes.get(mgetBytes.size()-1));
for(int i=0; i<mgetBytes.size()-1; i++)
assertNull(mgetBytes.get(i));
redis.flushdb();
redis.set ("string_key","bar");
redis.sadd ("set_key","member");
redis.rpush ("list_key","item");
assertTrue(redis.type("string_key")==RedisType.string);
assertTrue(redis.type("set_key")==RedisType.set);
assertTrue(redis.type("list_key")==RedisType.list);
redis.flushdb();
}
catch(RedisException e1){
e1.printStackTrace();
fail("error => "+ e1.getLocalizedMessage());
}
/* INCR INCRBY DECR DECRBY */
try{
redis.flushdb();
// int cntr = 0;
// String cntr_key = keys.get(0);
// for(int i = 1; i<mediumcnt; i++){
// cntr = redis.incr(cntr_key);
// assertEquals(i, cntr);
// }
// for(int i=cntr-1; i>=0; i--){
// cntr = redis.decr(cntr_key);
// assertEquals(i, cntr);
// }
// assertEquals(0, cntr);
// for(int i = 1; i<mediumcnt; i++){
// cntr = redis.incrby(cntr_key, 10);
// assertEquals(i*10, cntr);
// }
// redis.set(cntr_key, 0);
// assertTrue(0 == Encode.toInt(redis.get(cntr_key)));
// for(int i = 1; i<mediumcnt; i++){
// cntr = redis.decrby(cntr_key, 10);
// assertEquals(i*-10, cntr);
// }
long cntr =0;
String cntr_key = keys.get(0);
for(int i =1; i<mediumcnt; i++){
cntr = redis.incr(cntr_key);
assertEquals(i, cntr);
}
for(long i=cntr-1; i>=0; i--){
cntr = redis.decr(cntr_key);
assertEquals(i, cntr);
}
assertEquals(0, cntr);
for(long i =1; i<mediumcnt; i++){
cntr = redis.incrby(cntr_key,10);
assertEquals(i*10, cntr);
}
redis.set(cntr_key,0);
assertTrue(0==Encode.toInt(redis.get(cntr_key)));
for(long i =1; i<mediumcnt; i++){
cntr = redis.decrby(cntr_key,10);
assertEquals(i*-10, cntr);
}
redis.flushdb();
long value = redis.incrby(cntr_key,Integer.MAX_VALUE -1);
for(long i =0; i <200; i++)
value = redis.incr(cntr_key);
Log.log("using the new long signature -- %d is long", value);
Log.log(" that's max int -- %d ",Integer.MAX_VALUE);
for(long i =0; i <200; i++)
value = redis.incrby (cntr_key,Integer.MAX_VALUE);
Log.log("using the new long signature -- %d is long", value);
Log.log(" that's max int -- %d ",Integer.MAX_VALUE);
}
catch(RedisException e1){
e1.printStackTrace();
fail("error => "+ e1.getLocalizedMessage());
}
/* KEYS RANDOMKEY KEY(PATTERN) RENAME RENAMENX DBSIZE MOVE*/
String key =null;
try{
Log.log("TEST: test Commands Operating On Key Space in database %d ...", DB1);
redis.flushdb();
byte[] value;
List<String> redisKeys =null;
for(int i=0; i<keys.size(); i++){
key = keys.get(i);
value = dataList.get(i);
redis.set(key, value);
}
redisKeys = redis.keys();
for(int i=0; i<keys.size(); i++) assertTrue(redisKeys.contains(keys.get(i)));
String newkey =null;
byte[] redisvalue =null;
for(int i=0; i<cnt; i++)
{
key = keys.get(i);
value = dataList.get(i);
redisvalue = redis.get(key);
assertTrue(value.length == redisvalue.length);
for(int j=0; j<value.length; j++)
assertTrue(value[j]==redisvalue[j]);
newkey = getRandomString (random.nextInt(24)+2);
redis.rename(key, newkey);
redisvalue = redis.get(newkey);
assertTrue(value.length == redisvalue.length);
for(int j=0; j<value.length; j++)
assertTrue(value[j]==redisvalue[j]);
}
assertTrue(redis.renamenx(newkey, key));
boolean expectedException =false;
try{
redis.renamenx(key, key);
}
catch(RedisException expected){ expectedException =true;}
finally{
assertTrue(expectedException);
}
redis.flushdb();
assertTrue (redis.dbsize()==0);
for(int i=0; i<patternList.size(); i++){
key = patternList.get(i);
value = dataList.get(i);
redis.set(key, value);
}
assertTrue (redis.dbsize()== patternList.size());
redisKeys = redis.keys("*"+patternA+"*");
for(int i=0; i<keys.size(); i++)
assertTrue("missing: "+ patternList.get(i), redisKeys.contains(patternList.get(i)));
redis.flushdb();
assertTrue (redis.dbsize()==0);
/* MOVE */
try{
redis.select(DB1).flushdb();
assertTrue(redis.dbsize()==0);
redis.select(DB2).flushdb();
assertTrue(redis.dbsize()==0);
// DB2 now ..
for(int i=0; i<keys.size(); i++){
key = keys.get(i);
value = dataList.get(i);
redis.set(key, value);
}
assertTrue(redis.dbsize()== keys.size());
for(int i=0; i<keys.size(); i++){
key = keys.get(i);
redis.move (key, DB1);
}
// DB2 should be empty again
assertTrue(redis.dbsize()==0);
redis.select(DB1);
assertTrue(redis.dbsize()== keys.size());
for(int i=0; i<keys.size(); i++){
key = keys.get(i);
assertTrue (redis.exists (key));
}
// move them back
for(int i=0; i<keys.size(); i++){
key = keys.get(i);
redis.move (key, DB2);
}
assertTrue(redis.dbsize()==0);
redis.flushall();
for(int i=0; i<Math.max(DB2, DB1); i++){
assertTrue(redis.select(i).dbsize()==0);
}
// finally
Map<String,String> infoMap = redis.info();
for(RedisInfo info :RedisInfo.values()){
assertNotNull(infoMap.get(info.name()));
Log.log("%s => %s", info.name(), infoMap.get(info.name()));
}
}
catch(RedisException e1){
e1.printStackTrace();
fail("error SELECTing database => "+ e1.getLocalizedMessage());
}
}
catch(RedisException e){
e.printStackTrace();
fail("error testing KEYS => "+ e.getLocalizedMessage());
}
}
// ------------------------------------------------------------------------
// Helper methods
// ------------------------------------------------------------------------
protectedString getRandomString (int size){
StringBuilder builder =new StringBuilder(size);
for(int i =0; i<size; i++){
char c =(char)(random.nextInt(126-33)+33);
builder.append(c);
}
return builder.toString();
}
protectedbyte[] getRandomBytes(int size){
int len = size;
byte[] bigstuff =newbyte[len];
random.nextBytes(bigstuff);
return bigstuff;
}
publicvoid compareLists (List<String> strL1,List<String> strL2){
for(int i=0; i<strL1.size(); i++){
assertTrue(strL2.contains(strL1.get(i)));
}
}
// ------------------------------------------------------------------------
// INNER TYPES USED FOR TESTING
// ------------------------------------------------------------------------
publicstaticclassTestBeanimplementsSerializable{
/** */
privatestaticfinallong serialVersionUID =4457509786469904810L;
protectedfinallong getCreated_on(){return created_on;}
protectedfinalvoid setCreated_on(long created_on){this.created_on = created_on;}
protectedfinalString getName(){return name;}
protectedfinalvoid setName(String name){this.name = name;}
protectedfinalbyte[] getData(){return data;}
protectedfinalvoid setData(byte[] data){this.data = data;}
privatelong created_on;
privateString name;
privatebyte[] data;
publicTestBean(){created_on =System.currentTimeMillis();}
publicTestBean(String string){this(); name = string;}
@OverridepublicString toString(){return"["+ getClass().getSimpleName()+" | name: "+ getName()+" created on: "+ getCreated_on()+"]";}
@Overridepublicboolean equals (Object o){
boolean res =false;
try{
TestBean isItMe =(TestBean) o;
res = isItMe.getName().equals(name)&& isItMe.getCreated_on()==this.created_on;
}
catch(ClassCastException e){
returnfalse;
}
return res;
}
}
}
标签：assertTrue,
jredis,
String,
redis,
e1,
----------------------------------------------
From： https://blog.51cto.com/u_2650279/6154707