diff --git a/src/main/java/org/springframework/data/redis/connection/DefaultStringRedisConnection.java b/src/main/java/org/springframework/data/redis/connection/DefaultStringRedisConnection.java
index 6bba91e98..28392d72d 100644
--- a/src/main/java/org/springframework/data/redis/connection/DefaultStringRedisConnection.java
+++ b/src/main/java/org/springframework/data/redis/connection/DefaultStringRedisConnection.java
@@ -54,7 +54,9 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	private SetConverter<byte[], String> byteSetToStringSet = new SetConverter<byte[],String>(bytesToString);
 	@SuppressWarnings("rawtypes")
 	private Queue<Converter> pipelineConverters = new LinkedList<Converter>();
-	private boolean deserializePipelineResults = true;
+	@SuppressWarnings("rawtypes")
+	private Queue<Converter> txConverters = new LinkedList<Converter>();
+	private boolean deserializePipelineAndTxResults = true;
 	private IdentityConverter identityConverter = new IdentityConverter();
 
 	private class DeserializingConverter implements Converter<byte[],String> {
@@ -75,6 +77,19 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 		}
 	}
 
+	@SuppressWarnings("rawtypes")
+	private class TransactionResultConverter implements Converter<List<Object>, List<Object>> {
+		private Queue<Converter> txConverters;
+
+		public TransactionResultConverter(Queue<Converter> txConverters) {
+			this.txConverters = txConverters;
+		}
+
+		public List<Object> convert(List<Object> execResults) {
+			return convertResults(execResults, txConverters);
+		}
+	}
+
 	/**
 	 * Constructs a new <code>DefaultStringRedisConnection</code> instance.
 	 * Uses {@link StringRedisSerializer} as underlying serializer.
@@ -102,8 +117,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 
 	public Long append(byte[] key, byte[] value) {
 		Long result = delegate.append(key,value);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -118,24 +133,24 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 
 	public List<byte[]> bLPop(int timeout, byte[]... keys) {
 		List<byte[]> results = delegate.bLPop(timeout, keys);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return results;
 	}
 
 	public List<byte[]> bRPop(int timeout, byte[]... keys) {
 		List<byte[]> results = delegate.bRPop(timeout, keys);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return results;
 	}
 
 	public byte[] bRPopLPush(int timeout, byte[] srcKey, byte[] dstKey) {
 		byte[] result = delegate.bRPopLPush(timeout, srcKey, dstKey);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -146,77 +161,86 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 
 	public Long dbSize() {
 		Long result = delegate.dbSize();
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public Long decr(byte[] key) {
 		Long result = delegate.decr(key);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public Long decrBy(byte[] key, long value) {
 		Long result = delegate.decrBy(key, value);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public Long del(byte[]... keys) {
 		Long result = delegate.del(keys);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public void discard() {
-		delegate.discard();
+		try {
+			delegate.discard();
+		} finally {
+			txConverters.clear();
+		}
 	}
 
 	public byte[] echo(byte[] message) {
 		byte[] result = delegate.echo(message);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
+	@SuppressWarnings("rawtypes")
 	public List<Object> exec() {
-		List<Object> results = delegate.exec();
-		if(isPipelined()) {
-			// Ensure exec converter gets added
-			pipelineConverters.add(identityConverter);
+		try {
+			List<Object> results = delegate.exec();
+			if(isPipelined()) {
+				pipelineConverters.add(new TransactionResultConverter(new LinkedList<Converter>(txConverters)));
+				return results;
+			}
+			return convertResults(results, txConverters);
+		} finally {
+			txConverters.clear();
 		}
-		return results;
 	}
 
 	public Boolean exists(byte[] key) {
 		Boolean result =  delegate.exists(key);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public Boolean expire(byte[] key, long seconds) {
 		Boolean result = delegate.expire(key, seconds);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public Boolean expireAt(byte[] key, long unixTime) {
 		Boolean result = delegate.expireAt(key, unixTime);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -231,48 +255,48 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 
 	public byte[] get(byte[] key) {
 		byte[] result = delegate.get(key);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public Boolean getBit(byte[] key, long offset) {
 		Boolean result = delegate.getBit(key, offset);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public List<String> getConfig(String pattern) {
 		List<String> results = delegate.getConfig(pattern);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return results;
 	}
 
 	public Object getNativeConnection() {
 		Object result = delegate.getNativeConnection();
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public byte[] getRange(byte[] key, long start, long end) {
 		byte[] result = delegate.getRange(key, start, end);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public byte[] getSet(byte[] key, byte[] value) {
 		byte[] result = delegate.getSet(key, value);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -283,72 +307,72 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 
 	public Boolean hDel(byte[] key, byte[] field) {
 		Boolean result = delegate.hDel(key, field);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public Boolean hExists(byte[] key, byte[] field) {
 		Boolean result = delegate.hExists(key, field);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public byte[] hGet(byte[] key, byte[] field) {
 		byte[] result = delegate.hGet(key, field);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public Map<byte[], byte[]> hGetAll(byte[] key) {
 		Map<byte[],byte[]> results = delegate.hGetAll(key);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return results;
 	}
 
 	public Long hIncrBy(byte[] key, byte[] field, long delta) {
 		Long result = delegate.hIncrBy(key, field, delta);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public Double hIncrBy(byte[] key, byte[] field, double delta) {
 		Double result = delegate.hIncrBy(key, field, delta);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public Set<byte[]> hKeys(byte[] key) {
 		Set<byte[]> results = delegate.hKeys(key);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return results;
 	}
 
 	public Long hLen(byte[] key) {
 		Long result = delegate.hLen(key);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public List<byte[]> hMGet(byte[] key, byte[]... fields) {
 		List<byte[]> results = delegate.hMGet(key, fields);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return results;
 	}
@@ -359,64 +383,64 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 
 	public Boolean hSet(byte[] key, byte[] field, byte[] value) {
 		Boolean result = delegate.hSet(key, field, value);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public Boolean hSetNX(byte[] key, byte[] field, byte[] value) {
 		Boolean result = delegate.hSetNX(key, field, value);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public List<byte[]> hVals(byte[] key) {
 		List<byte[]> results = delegate.hVals(key);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return results;
 	}
 
 	public Long incr(byte[] key) {
 		Long result = delegate.incr(key);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public Long incrBy(byte[] key, long value) {
 		Long result = delegate.incrBy(key, value);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public Double incrBy(byte[] key, double value) {
 		Double result = delegate.incrBy(key, value);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public Properties info() {
 		Properties result = delegate.info();
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public Properties info(String section) {
 		Properties result = delegate.info(section);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -435,80 +459,80 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 
 	public Set<byte[]> keys(byte[] pattern) {
 		Set<byte[]> results = delegate.keys(pattern);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return results;
 	}
 
 	public Long lastSave() {
 		Long result = delegate.lastSave();
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public byte[] lIndex(byte[] key, long index) {
 		byte[] result = delegate.lIndex(key, index);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public Long lInsert(byte[] key, Position where, byte[] pivot, byte[] value) {
 		Long result = delegate.lInsert(key, where, pivot, value);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public Long lLen(byte[] key) {
 		Long result = delegate.lLen(key);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public byte[] lPop(byte[] key) {
 		byte[] result = delegate.lPop(key);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public Long lPush(byte[] key, byte[] value) {
 		Long result = delegate.lPush(key, value);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public Long lPushX(byte[] key, byte[] value) {
 		Long result = delegate.lPushX(key, value);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public List<byte[]> lRange(byte[] key, long start, long end) {
 		List<byte[]> results = delegate.lRange(key, start, end);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return results;
 	}
 
 	public Long lRem(byte[] key, long count, byte[] value) {
 		Long result = delegate.lRem(key, count, value);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -523,8 +547,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 
 	public List<byte[]> mGet(byte[]... keys) {
 		List<byte[]> results = delegate.mGet(keys);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return results;
 	}
@@ -535,8 +559,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 
 	public Boolean mSetNX(Map<byte[], byte[]> tuple) {
 		Boolean result = delegate.mSetNX(tuple);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -547,24 +571,24 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 
 	public Boolean persist(byte[] key) {
 		Boolean result = delegate.persist(key);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public Boolean move(byte[] key, int dbIndex) {
 		Boolean result = delegate.move(key, dbIndex);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public String ping() {
 		String result = delegate.ping();
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -575,16 +599,16 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 
 	public Long publish(byte[] channel, byte[] message) {
 		Long result = delegate.publish(channel, message);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public byte[] randomKey() {
 		byte[] result = delegate.randomKey();
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -595,8 +619,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 
 	public Boolean renameNX(byte[] oldName, byte[] newName) {
 		Boolean result = delegate.renameNX(oldName, newName);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -607,40 +631,40 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 
 	public byte[] rPop(byte[] key) {
 		byte[] result = delegate.rPop(key);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public byte[] rPopLPush(byte[] srcKey, byte[] dstKey) {
 		byte[] result = delegate.rPopLPush(srcKey, dstKey);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public Long rPush(byte[] key, byte[] value) {
 		Long result = delegate.rPush(key, value);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public Long rPushX(byte[] key, byte[] value) {
 		Long result = delegate.rPushX(key, value);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public Boolean sAdd(byte[] key, byte[] value) {
 		Boolean result = delegate.sAdd(key, value);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -651,24 +675,24 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 
 	public Long sCard(byte[] key) {
 		Long result = delegate.sCard(key);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public Set<byte[]> sDiff(byte[]... keys) {
 		Set<byte[]> results = delegate.sDiff(keys);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return results;
 	}
 
 	public Long sDiffStore(byte[] destKey, byte[]... keys) {
 		Long result = delegate.sDiffStore(destKey, keys);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -695,8 +719,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 
 	public Boolean setNX(byte[] key, byte[] value) {
 		Boolean result = delegate.setNX(key, value);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -711,120 +735,120 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 
 	public Set<byte[]> sInter(byte[]... keys) {
 		Set<byte[]> results = delegate.sInter(keys);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return results;
 	}
 
 	public Long sInterStore(byte[] destKey, byte[]... keys) {
 		Long result = delegate.sInterStore(destKey, keys);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public Boolean sIsMember(byte[] key, byte[] value) {
 		Boolean result = delegate.sIsMember(key, value);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public Set<byte[]> sMembers(byte[] key) {
 		Set<byte[]> results = delegate.sMembers(key);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return results;
 	}
 
 	public Boolean sMove(byte[] srcKey, byte[] destKey, byte[] value) {
 		Boolean result = delegate.sMove(srcKey, destKey, value);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public Long sort(byte[] key, SortParameters params, byte[] storeKey) {
 		Long result = delegate.sort(key, params, storeKey);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public List<byte[]> sort(byte[] key, SortParameters params) {
 		List<byte[]> results = delegate.sort(key, params);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return results;
 	}
 
 	public byte[] sPop(byte[] key) {
 		byte[] result = delegate.sPop(key);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public byte[] sRandMember(byte[] key) {
 		byte[] result = delegate.sRandMember(key);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public List<byte[]> sRandMember(byte[] key, long count) {
 		List<byte[]> results = delegate.sRandMember(key, count);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return results;
 	}
 
 	public Boolean sRem(byte[] key, byte[] value) {
 		Boolean result = delegate.sRem(key, value);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public Long strLen(byte[] key) {
 		Long result = delegate.strLen(key);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public Long bitCount(byte[] key) {
 		Long result = delegate.bitCount(key);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public Long bitCount(byte[] key, long begin, long end) {
 		Long result = delegate.bitCount(key, begin, end);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public Long bitOp(BitOperation op, byte[] destination, byte[]... keys) {
 		Long result = delegate.bitOp(op, destination, keys);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -835,32 +859,32 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 
 	public Set<byte[]> sUnion(byte[]... keys) {
 		Set<byte[]> results = delegate.sUnion(keys);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return results;
 	}
 
 	public Long sUnionStore(byte[] destKey, byte[]... keys) {
 		Long result = delegate.sUnionStore(destKey, keys);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public Long ttl(byte[] key) {
 		Long result = delegate.ttl(key);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public DataType type(byte[] key) {
 		DataType result = delegate.type(key);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -875,240 +899,240 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 
 	public Boolean zAdd(byte[] key, double score, byte[] value) {
 		Boolean result = delegate.zAdd(key, score, value);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public Long zCard(byte[] key) {
 		Long result = delegate.zCard(key);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public Long zCount(byte[] key, double min, double max) {
 		Long result = delegate.zCount(key, min, max);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public Double zIncrBy(byte[] key, double increment, byte[] value) {
 		Double result = delegate.zIncrBy(key, increment, value);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public Long zInterStore(byte[] destKey, Aggregate aggregate, int[] weights, byte[]... sets) {
 		Long result = delegate.zInterStore(destKey, aggregate, weights, sets);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public Long zInterStore(byte[] destKey, byte[]... sets) {
 		Long result = delegate.zInterStore(destKey, sets);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public Set<byte[]> zRange(byte[] key, long start, long end) {
 		Set<byte[]> results = delegate.zRange(key, start, end);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return results;
 	}
 
 	public Set<byte[]> zRangeByScore(byte[] key, double min, double max, long offset, long count) {
 		Set<byte[]> results = delegate.zRangeByScore(key, min, max, offset, count);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return results;
 	}
 
 	public Set<byte[]> zRangeByScore(byte[] key, double min, double max) {
 		Set<byte[]> results = delegate.zRangeByScore(key, min, max);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return results;
 	}
 
 	public Set<Tuple> zRangeByScoreWithScores(byte[] key, double min, double max, long offset, long count) {
 		Set<Tuple> results = delegate.zRangeByScoreWithScores(key, min, max, offset, count);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return results;
 	}
 
 	public Set<Tuple> zRangeByScoreWithScores(byte[] key, double min, double max) {
 		Set<Tuple> results = delegate.zRangeByScoreWithScores(key, min, max);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return results;
 	}
 
 	public Set<Tuple> zRangeWithScores(byte[] key, long start, long end) {
 		Set<Tuple> results = delegate.zRangeWithScores(key, start, end);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return results;
 	}
 
 	public Set<byte[]> zRevRangeByScore(byte[] key, double min, double max, long offset, long count) {
 		Set<byte[]> results = delegate.zRevRangeByScore(key, min, max, offset, count);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return results;
 	}
 
 	public Set<byte[]> zRevRangeByScore(byte[] key, double min, double max) {
 		Set<byte[]> results = delegate.zRevRangeByScore(key, min, max);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return results;
 	}
 
 	public Set<Tuple> zRevRangeByScoreWithScores(byte[] key, double min, double max, long offset, long count) {
 		Set<Tuple> results = delegate.zRevRangeByScoreWithScores(key, min, max, offset, count);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return results;
 	}
 
 	public Set<Tuple> zRevRangeByScoreWithScores(byte[] key, double min, double max) {
 		Set<Tuple> results = delegate.zRevRangeByScoreWithScores(key, min, max);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return results;
 	}
 
 	public Long zRank(byte[] key, byte[] value) {
 		Long result = delegate.zRank(key, value);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public Boolean zRem(byte[] key, byte[] value) {
 		Boolean result = delegate.zRem(key, value);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public Long zRemRange(byte[] key, long start, long end) {
 		Long result = delegate.zRemRange(key, start, end);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public Long zRemRangeByScore(byte[] key, double min, double max) {
 		Long result = delegate.zRemRangeByScore(key, min, max);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public Set<byte[]> zRevRange(byte[] key, long start, long end) {
 		Set<byte[]> results = delegate.zRevRange(key, start, end);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return results;
 	}
 
 	public Set<Tuple> zRevRangeWithScores(byte[] key, long start, long end) {
 		Set<Tuple> results = delegate.zRevRangeWithScores(key, start, end);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return results;
 	}
 
 	public Long zRevRank(byte[] key, byte[] value) {
 		Long result = delegate.zRevRank(key, value);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public Double zScore(byte[] key, byte[] value) {
 		Double result = delegate.zScore(key, value);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public Long zUnionStore(byte[] destKey, Aggregate aggregate, int[] weights, byte[]... sets) {
 		Long result = delegate.zUnionStore(destKey, aggregate, weights, sets);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public Long zUnionStore(byte[] destKey, byte[]... sets) {
 		Long result = delegate.zUnionStore(destKey, sets);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public Boolean pExpire(byte[] key, long millis) {
 		Boolean result = delegate.pExpire(key, millis);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public Boolean pExpireAt(byte[] key, long unixTimeInMillis) {
 		Boolean result = delegate.pExpireAt(key, unixTimeInMillis);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public Long pTtl(byte[] key) {
 		Long result = delegate.pTtl(key);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public byte[] dump(byte[] key) {
 		byte[] result = delegate.dump(key);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -1127,32 +1151,32 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 
 	public String scriptLoad(byte[] script) {
 		String result = delegate.scriptLoad(script);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public List<Boolean> scriptExists(String... scriptSha1) {
 		List<Boolean> results = delegate.scriptExists(scriptSha1);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return results;
 	}
 
 	public <T> T eval(byte[] script, ReturnType returnType, int numKeys, byte[]... keysAndArgs) {
 		T result = delegate.eval(script, returnType, numKeys, keysAndArgs);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public <T> T evalSha(String scriptSha1, ReturnType returnType, int numKeys, byte[]... keysAndArgs) {
 		T result = delegate.evalSha(scriptSha1, returnType, numKeys, keysAndArgs);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -1188,8 +1212,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public Long append(String key, String value) {
 		Long result = delegate.append(serialize(key), serialize(value));
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -1197,8 +1221,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public List<String> bLPop(int timeout, String... keys) {
 		List<byte[]> results = delegate.bLPop(timeout, serializeMulti(keys));
-		if(isPipelined()) {
-			pipeline(byteListToStringList);
+		if(isFutureConversion()) {
+			addResultConverter(byteListToStringList);
 		}
 		return byteListToStringList.convert(results);
 	}
@@ -1206,8 +1230,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public List<String> bRPop(int timeout, String... keys) {
 		List<byte[]> results = delegate.bRPop(timeout, serializeMulti(keys));
-		if(isPipelined()) {
-			pipeline(byteListToStringList);
+		if(isFutureConversion()) {
+			addResultConverter(byteListToStringList);
 		}
 		return byteListToStringList.convert(results);
 	}
@@ -1215,8 +1239,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public String bRPopLPush(int timeout, String srcKey, String dstKey) {
 		byte[] result = delegate.bRPopLPush(timeout, serialize(srcKey), serialize(dstKey));
-		if(isPipelined()) {
-			pipeline(bytesToString);
+		if(isFutureConversion()) {
+			addResultConverter(bytesToString);
 		}
 		return bytesToString.convert(result);
 	}
@@ -1224,8 +1248,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public Long decr(String key) {
 		Long result = delegate.decr(serialize(key));
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -1233,8 +1257,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public Long decrBy(String key, long value) {
 		Long result = delegate.decrBy(serialize(key), value);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -1242,8 +1266,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public Long del(String... keys) {
 		Long result = delegate.del(serializeMulti(keys));
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -1251,8 +1275,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public String echo(String message) {
 		byte[] result = delegate.echo(serialize(message));
-		if(isPipelined()) {
-			pipeline(bytesToString);
+		if(isFutureConversion()) {
+			addResultConverter(bytesToString);
 		}
 		return bytesToString.convert(result);
 	}
@@ -1260,8 +1284,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public Boolean exists(String key) {
 		Boolean result = delegate.exists(serialize(key));
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -1269,8 +1293,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public Boolean expire(String key, long seconds) {
 		Boolean result = delegate.expire(serialize(key), seconds);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -1278,8 +1302,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public Boolean expireAt(String key, long unixTime) {
 		Boolean result = delegate.expireAt(serialize(key), unixTime);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -1287,8 +1311,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public String get(String key) {
 		byte[] result = delegate.get(serialize(key));
-		if(isPipelined()) {
-			pipeline(bytesToString);
+		if(isFutureConversion()) {
+			addResultConverter(bytesToString);
 		}
 		return bytesToString.convert(result);
 	}
@@ -1296,8 +1320,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public Boolean getBit(String key, long offset) {
 		Boolean result = delegate.getBit(serialize(key), offset);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -1305,8 +1329,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public String getRange(String key, long start, long end) {
 		byte[] result = delegate.getRange(serialize(key), start, end);
-		if(isPipelined()) {
-			pipeline(bytesToString);
+		if(isFutureConversion()) {
+			addResultConverter(bytesToString);
 		}
 		return bytesToString.convert(result);
 	}
@@ -1314,8 +1338,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public String getSet(String key, String value) {
 		byte[] result = delegate.getSet(serialize(key), serialize(value));
-		if(isPipelined()) {
-			pipeline(bytesToString);
+		if(isFutureConversion()) {
+			addResultConverter(bytesToString);
 		}
 		return bytesToString.convert(result);
 	}
@@ -1323,8 +1347,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public Boolean hDel(String key, String field) {
 		Boolean result = delegate.hDel(serialize(key), serialize(field));
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -1332,8 +1356,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public Boolean hExists(String key, String field) {
 		Boolean result = delegate.hExists(serialize(key), serialize(field));
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -1341,8 +1365,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public String hGet(String key, String field) {
 		byte[] result = delegate.hGet(serialize(key), serialize(field));
-		if(isPipelined()) {
-			pipeline(bytesToString);
+		if(isFutureConversion()) {
+			addResultConverter(bytesToString);
 		}
 		return bytesToString.convert(result);
 	}
@@ -1350,8 +1374,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public Map<String, String> hGetAll(String key) {
 		Map<byte[],byte[]> results = delegate.hGetAll(serialize(key));
-		if(isPipelined()) {
-			pipeline(byteMapToStringMap);
+		if(isFutureConversion()) {
+			addResultConverter(byteMapToStringMap);
 		}
 		return byteMapToStringMap.convert(results);
 	}
@@ -1359,24 +1383,24 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public Long hIncrBy(String key, String field, long delta) {
 		Long result = delegate.hIncrBy(serialize(key), serialize(field), delta);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public Double hIncrBy(String key, String field, double delta) {
 		Double result = delegate.hIncrBy(serialize(key), serialize(field), delta);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 	
 	public Set<String> hKeys(String key) {
 		Set<byte[]> results = delegate.hKeys(serialize(key));
-		if(isPipelined()) {
-			pipeline(byteSetToStringSet);
+		if(isFutureConversion()) {
+			addResultConverter(byteSetToStringSet);
 		}
 		return byteSetToStringSet.convert(results);
 	}
@@ -1384,8 +1408,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public Long hLen(String key) {
 		Long result = delegate.hLen(serialize(key));
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -1393,8 +1417,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public List<String> hMGet(String key, String... fields) {
 		List<byte[]> results = delegate.hMGet(serialize(key), serializeMulti(fields));
-		if(isPipelined()) {
-			pipeline(byteListToStringList);
+		if(isFutureConversion()) {
+			addResultConverter(byteListToStringList);
 		}
 		return byteListToStringList.convert(results);
 	}
@@ -1406,8 +1430,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public Boolean hSet(String key, String field, String value) {
 		Boolean result = delegate.hSet(serialize(key), serialize(field), serialize(value));
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -1415,8 +1439,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public Boolean hSetNX(String key, String field, String value) {
 		Boolean result = delegate.hSetNX(serialize(key), serialize(field), serialize(value));
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -1424,8 +1448,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public List<String> hVals(String key) {
 		List<byte[]> results = delegate.hVals(serialize(key));
-		if(isPipelined()) {
-			pipeline(byteListToStringList);
+		if(isFutureConversion()) {
+			addResultConverter(byteListToStringList);
 		}
 		return byteListToStringList.convert(results);
 	}
@@ -1433,8 +1457,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public Long incr(String key) {
 		Long result = delegate.incr(serialize(key));
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -1442,24 +1466,24 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public Long incrBy(String key, long value) {
 		Long result = delegate.incrBy(serialize(key), value);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public Double incrBy(String key, double value) {
 		Double result = delegate.incrBy(serialize(key), value);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public Collection<String> keys(String pattern) {
 		Set<byte[]> results = delegate.keys(serialize(pattern));
-		if(isPipelined()) {
-			pipeline(byteSetToStringSet);
+		if(isFutureConversion()) {
+			addResultConverter(byteSetToStringSet);
 		}
 		return byteSetToStringSet.convert(results);
 	}
@@ -1467,8 +1491,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public String lIndex(String key, long index) {
 		byte[] result = delegate.lIndex(serialize(key), index);
-		if(isPipelined()) {
-			pipeline(bytesToString);
+		if(isFutureConversion()) {
+			addResultConverter(bytesToString);
 		}
 		return bytesToString.convert(result);
 	}
@@ -1476,8 +1500,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public Long lInsert(String key, Position where, String pivot, String value) {
 		Long result = delegate.lInsert(serialize(key), where, serialize(pivot), serialize(value));
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -1485,8 +1509,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public Long lLen(String key) {
 		Long result = delegate.lLen(serialize(key));
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -1494,8 +1518,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public String lPop(String key) {
 		byte[] result = delegate.lPop(serialize(key));
-		if(isPipelined()) {
-			pipeline(bytesToString);
+		if(isFutureConversion()) {
+			addResultConverter(bytesToString);
 		}
 		return bytesToString.convert(result);
 	}
@@ -1503,8 +1527,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public Long lPush(String key, String value) {
 		Long result = delegate.lPush(serialize(key), serialize(value));
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -1512,8 +1536,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public Long lPushX(String key, String value) {
 		Long result = delegate.lPushX(serialize(key), serialize(value));
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -1521,8 +1545,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public List<String> lRange(String key, long start, long end) {
 		List<byte[]> results = delegate.lRange(serialize(key), start, end);
-		if(isPipelined()) {
-			pipeline(byteListToStringList);
+		if(isFutureConversion()) {
+			addResultConverter(byteListToStringList);
 		}
 		return byteListToStringList.convert(results);
 	}
@@ -1530,8 +1554,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public Long lRem(String key, long count, String value) {
 		Long result = delegate.lRem(serialize(key), count, serialize(value));
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -1549,8 +1573,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public List<String> mGet(String... keys) {
 		List<byte[]> results = delegate.mGet(serializeMulti(keys));
-		if(isPipelined()) {
-			pipeline(byteListToStringList);
+		if(isFutureConversion()) {
+			addResultConverter(byteListToStringList);
 		}
 		return byteListToStringList.convert(results);
 	}
@@ -1558,8 +1582,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public Boolean mSetNXString(Map<String, String> tuple) {
 		Boolean result = delegate.mSetNX(serialize(tuple));
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -1572,8 +1596,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public Boolean persist(String key) {
 		Boolean result = delegate.persist(serialize(key));
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -1581,8 +1605,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public Boolean move(String key, int dbIndex) {
 		Boolean result = delegate.move(serialize(key), dbIndex);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -1595,8 +1619,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public Long publish(String channel, String message) {
 		Long result = delegate.publish(serialize(channel), serialize(message));
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -1609,8 +1633,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public Boolean renameNX(String oldName, String newName) {
 		Boolean result = delegate.renameNX(serialize(oldName), serialize(newName));
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -1618,8 +1642,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public String rPop(String key) {
 		byte[] result = delegate.rPop(serialize(key));
-		if(isPipelined()) {
-			pipeline(bytesToString);
+		if(isFutureConversion()) {
+			addResultConverter(bytesToString);
 		}
 		return bytesToString.convert(result);
 	}
@@ -1627,8 +1651,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public String rPopLPush(String srcKey, String dstKey) {
 		byte[] result = delegate.rPopLPush(serialize(srcKey), serialize(dstKey));
-		if(isPipelined()) {
-			pipeline(bytesToString);
+		if(isFutureConversion()) {
+			addResultConverter(bytesToString);
 		}
 		return bytesToString.convert(result);
 	}
@@ -1636,8 +1660,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public Long rPush(String key, String value) {
 		Long result = delegate.rPush(serialize(key), serialize(value));
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -1645,8 +1669,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public Long rPushX(String key, String value) {
 		Long result = delegate.rPushX(serialize(key), serialize(value));
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -1654,8 +1678,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public Boolean sAdd(String key, String value) {
 		Boolean result = delegate.sAdd(serialize(key), serialize(value));
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -1663,8 +1687,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public Long sCard(String key) {
 		Long result = delegate.sCard(serialize(key));
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -1672,8 +1696,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public Set<String> sDiff(String... keys) {
 		Set<byte[]> results = delegate.sDiff(serializeMulti(keys));
-		if(isPipelined()) {
-			pipeline(byteSetToStringSet);
+		if(isFutureConversion()) {
+			addResultConverter(byteSetToStringSet);
 		}
 		return byteSetToStringSet.convert(results);
 	}
@@ -1681,8 +1705,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public Long sDiffStore(String destKey, String... keys) {
 		Long result = delegate.sDiffStore(serialize(destKey), serializeMulti(keys));
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -1705,8 +1729,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public Boolean setNX(String key, String value) {
 		Boolean result = delegate.setNX(serialize(key), serialize(value));
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -1719,8 +1743,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public Set<String> sInter(String... keys) {
 		Set<byte[]> results = delegate.sInter(serializeMulti(keys));
-		if(isPipelined()) {
-			pipeline(byteSetToStringSet);
+		if(isFutureConversion()) {
+			addResultConverter(byteSetToStringSet);
 		}
 		return byteSetToStringSet.convert(results);
 	}
@@ -1728,8 +1752,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public Long sInterStore(String destKey, String... keys) {
 		Long result = delegate.sInterStore(serialize(destKey), serializeMulti(keys));
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -1737,8 +1761,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public Boolean sIsMember(String key, String value) {
 		Boolean result = delegate.sIsMember(serialize(key), serialize(value));
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -1746,8 +1770,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public Set<String> sMembers(String key) {
 		Set<byte[]> results = delegate.sMembers(serialize(key));
-		if(isPipelined()) {
-			pipeline(byteSetToStringSet);
+		if(isFutureConversion()) {
+			addResultConverter(byteSetToStringSet);
 		}
 		return byteSetToStringSet.convert(results);
 	}
@@ -1755,8 +1779,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public Boolean sMove(String srcKey, String destKey, String value) {
 		Boolean result = delegate.sMove(serialize(srcKey), serialize(destKey), serialize(value));
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -1764,8 +1788,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public Long sort(String key, SortParameters params, String storeKey) {
 		Long result = delegate.sort(serialize(key), params, serialize(storeKey));
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -1773,8 +1797,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public List<String> sort(String key, SortParameters params) {
 		List<byte[]> results = delegate.sort(serialize(key), params);
-		if(isPipelined()) {
-			pipeline(byteListToStringList);
+		if(isFutureConversion()) {
+			addResultConverter(byteListToStringList);
 		}
 		return byteListToStringList.convert(results);
 	}
@@ -1782,8 +1806,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public String sPop(String key) {
 		byte[] result = delegate.sPop(serialize(key));
-		if(isPipelined()) {
-			pipeline(bytesToString);
+		if(isFutureConversion()) {
+			addResultConverter(bytesToString);
 		}
 		return bytesToString.convert(result);
 	}
@@ -1791,56 +1815,56 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public String sRandMember(String key) {
 		byte[] result = delegate.sRandMember(serialize(key));
-		if(isPipelined()) {
-			pipeline(bytesToString);
+		if(isFutureConversion()) {
+			addResultConverter(bytesToString);
 		}
 		return bytesToString.convert(result);
 	}
 
 	public List<String> sRandMember(String key, long count) {
 		List<byte[]> results = delegate.sRandMember(serialize(key), count);
-		if(isPipelined()) {
-			pipeline(byteListToStringList);
+		if(isFutureConversion()) {
+			addResultConverter(byteListToStringList);
 		}
 		return byteListToStringList.convert(results);
 	}
 	
 	public Boolean sRem(String key, String value) {
 		Boolean result = delegate.sRem(serialize(key), serialize(value));
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 	
 	public Long strLen(String key) {
 		Long result = delegate.strLen(serialize(key));
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 	
 	public Long bitCount(String key) {
 		Long result = delegate.bitCount(serialize(key));
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public Long bitCount(String key, long begin, long end) {
 		Long result = delegate.bitCount(serialize(key), begin, end);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	public Long bitOp(BitOperation op, String destination, String... keys) {
 		Long result = delegate.bitOp(op, serialize(destination), serializeMulti(keys));
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -1852,8 +1876,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public Set<String> sUnion(String... keys) {
 		Set<byte[]> results = delegate.sUnion(serializeMulti(keys));
-		if(isPipelined()) {
-			pipeline(byteSetToStringSet);
+		if(isFutureConversion()) {
+			addResultConverter(byteSetToStringSet);
 		}
 		return byteSetToStringSet.convert(results);
 	}
@@ -1861,8 +1885,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public Long sUnionStore(String destKey, String... keys) {
 		Long result = delegate.sUnionStore(serialize(destKey), serializeMulti(keys));
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -1870,8 +1894,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public Long ttl(String key) {
 		Long result = delegate.ttl(serialize(key));
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -1879,8 +1903,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public DataType type(String key) {
 		DataType result = delegate.type(serialize(key));
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -1888,8 +1912,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public Boolean zAdd(String key, double score, String value) {
 		Boolean result = delegate.zAdd(serialize(key), score, serialize(value));
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -1897,8 +1921,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public Long zCard(String key) {
 		Long result = delegate.zCard(serialize(key));
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -1906,8 +1930,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public Long zCount(String key, double min, double max) {
 		Long result = delegate.zCount(serialize(key), min, max);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -1915,8 +1939,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public Double zIncrBy(String key, double increment, String value) {
 		Double result = delegate.zIncrBy(serialize(key), increment, serialize(value));
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -1924,8 +1948,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public Long zInterStore(String destKey, Aggregate aggregate, int[] weights, String... sets) {
 		Long result = delegate.zInterStore(serialize(destKey), aggregate, weights, serializeMulti(sets));
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -1933,8 +1957,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public Long zInterStore(String destKey, String... sets) {
 		Long result = delegate.zInterStore(serialize(destKey), serializeMulti(sets));
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -1942,8 +1966,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public Set<String> zRange(String key, long start, long end) {
 		Set<byte[]> results = delegate.zRange(serialize(key), start, end);
-		if(isPipelined()) {
-			pipeline(byteSetToStringSet);
+		if(isFutureConversion()) {
+			addResultConverter(byteSetToStringSet);
 		}
 		return byteSetToStringSet.convert(results);
 	}
@@ -1951,8 +1975,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public Set<String> zRangeByScore(String key, double min, double max, long offset, long count) {
 		Set<byte[]> results = delegate.zRangeByScore(serialize(key), min, max, offset, count);
-		if(isPipelined()) {
-			pipeline(byteSetToStringSet);
+		if(isFutureConversion()) {
+			addResultConverter(byteSetToStringSet);
 		}
 		return byteSetToStringSet.convert(results);
 	}
@@ -1960,8 +1984,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public Set<String> zRangeByScore(String key, double min, double max) {
 		Set<byte[]> results = delegate.zRangeByScore(serialize(key), min, max);
-		if(isPipelined()) {
-			pipeline(byteSetToStringSet);
+		if(isFutureConversion()) {
+			addResultConverter(byteSetToStringSet);
 		}
 		return byteSetToStringSet.convert(results);
 	}
@@ -1969,8 +1993,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public Set<StringTuple> zRangeByScoreWithScores(String key, double min, double max, long offset, long count) {
 		Set<Tuple> results = delegate.zRangeByScoreWithScores(serialize(key), min, max, offset, count);
-		if(isPipelined()) {
-			pipeline(tupleToStringTuple);
+		if(isFutureConversion()) {
+			addResultConverter(tupleToStringTuple);
 		}
 		return tupleToStringTuple.convert(results);
 	}
@@ -1978,8 +2002,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public Set<StringTuple> zRangeByScoreWithScores(String key, double min, double max) {
 		Set<Tuple> results = delegate.zRangeByScoreWithScores(serialize(key), min, max);
-		if(isPipelined()) {
-			pipeline(tupleToStringTuple);
+		if(isFutureConversion()) {
+			addResultConverter(tupleToStringTuple);
 		}
 		return tupleToStringTuple.convert(results);
 	}
@@ -1987,8 +2011,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public Set<StringTuple> zRangeWithScores(String key, long start, long end) {
 		Set<Tuple> results = delegate.zRangeWithScores(serialize(key), start, end);
-		if(isPipelined()) {
-			pipeline(tupleToStringTuple);
+		if(isFutureConversion()) {
+			addResultConverter(tupleToStringTuple);
 		}
 		return tupleToStringTuple.convert(results);
 	}
@@ -1996,8 +2020,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public Long zRank(String key, String value) {
 		Long result = delegate.zRank(serialize(key), serialize(value));
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -2005,8 +2029,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public Boolean zRem(String key, String value) {
 		Boolean result = delegate.zRem(serialize(key), serialize(value));
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -2014,8 +2038,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public Long zRemRange(String key, long start, long end) {
 		Long result = delegate.zRemRange(serialize(key), start, end);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -2023,8 +2047,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public Long zRemRangeByScore(String key, double min, double max) {
 		Long result = delegate.zRemRangeByScore(serialize(key), min, max);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -2032,8 +2056,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public Set<String> zRevRange(String key, long start, long end) {
 		Set<byte[]> results = delegate.zRevRange(serialize(key), start, end);
-		if(isPipelined()) {
-			pipeline(byteSetToStringSet);
+		if(isFutureConversion()) {
+			addResultConverter(byteSetToStringSet);
 		}
 		return byteSetToStringSet.convert(results);
 	}
@@ -2041,32 +2065,32 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public Set<StringTuple> zRevRangeWithScores(String key, long start, long end) {
 		Set<Tuple> results = delegate.zRevRangeWithScores(serialize(key), start, end);
-		if(isPipelined()) {
-			pipeline(tupleToStringTuple);
+		if(isFutureConversion()) {
+			addResultConverter(tupleToStringTuple);
 		}
 		return tupleToStringTuple.convert(results);
 	}
 	
 	public Set<String> zRevRangeByScore(String key, double min, double max) {
 		Set<byte[]> results = delegate.zRevRangeByScore(serialize(key), min, max);
-		if(isPipelined()) {
-			pipeline(byteSetToStringSet);
+		if(isFutureConversion()) {
+			addResultConverter(byteSetToStringSet);
 		}
 		return byteSetToStringSet.convert(results);
 	}
 
 	public Set<StringTuple> zRevRangeByScoreWithScores(String key, double min, double max) {
 		Set<Tuple> results = delegate.zRevRangeByScoreWithScores(serialize(key), min, max);
-		if(isPipelined()) {
-			pipeline(tupleToStringTuple);
+		if(isFutureConversion()) {
+			addResultConverter(tupleToStringTuple);
 		}
 		return tupleToStringTuple.convert(results);
 	}
 
 	public Set<String> zRevRangeByScore(String key, double min, double max, long offset, long count) {
 		Set<byte[]> results = delegate.zRevRangeByScore(serialize(key), min, max, offset, count);
-		if(isPipelined()) {
-			pipeline(byteSetToStringSet);
+		if(isFutureConversion()) {
+			addResultConverter(byteSetToStringSet);
 		}
 		return byteSetToStringSet.convert(results);
 	}
@@ -2074,16 +2098,16 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	public Set<StringTuple> zRevRangeByScoreWithScores(String key, double min, double max,
 			long offset, long count) {
 		Set<Tuple> results = delegate.zRevRangeByScoreWithScores(serialize(key), min, max, offset, count);
-		if(isPipelined()) {
-			pipeline(tupleToStringTuple);
+		if(isFutureConversion()) {
+			addResultConverter(tupleToStringTuple);
 		}
 		return tupleToStringTuple.convert(results);
 	}
 
 	public Long zRevRank(String key, String value) {
 		Long result = delegate.zRevRank(serialize(key), serialize(value));
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -2091,8 +2115,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public Double zScore(String key, String value) {
 		Double result = delegate.zScore(serialize(key), serialize(value));
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -2100,8 +2124,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public Long zUnionStore(String destKey, Aggregate aggregate, int[] weights, String... sets) {
 		Long result = delegate.zUnionStore(serialize(destKey), aggregate, weights, serializeMulti(sets));
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -2109,36 +2133,20 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	
 	public Long zUnionStore(String destKey, String... sets) {
 		Long result = delegate.zUnionStore(serialize(destKey), serializeMulti(sets));
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
-	
-	@SuppressWarnings("unchecked")
 	public List<Object> closePipeline() {
 		try {
-			List<Object> results = delegate.closePipeline();
-			if(!deserializePipelineResults) {
-				return results;
-			}
-			if(results.size() != pipelineConverters.size()) {
-				// Some of the pipelined commands were done directly on the delegate, don't attempt to convert
-				log.warn("Delegate returned an unexpected number of results on closePipeline. Abandoning type conversion.");
-				return results;
-			}
-			List<Object> convertedResults = new ArrayList<Object>();
-			for(Object result: results) {
-				convertedResults.add(pipelineConverters.remove().convert(result));
-			}
-			return convertedResults;
-		}finally {
+			return convertResults(delegate.closePipeline(), pipelineConverters);
+		} finally {
 			pipelineConverters.clear();
 		}
 	}
 
-	
 	public boolean isPipelined() {
 		return delegate.isPipelined();
 	}
@@ -2148,15 +2156,14 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 		delegate.openPipeline();
 	}
 
-
 	public Object execute(String command) {
 		return execute(command, (byte[][]) null);
 	}
 
 	public Object execute(String command, byte[]... args) {
 		Object result = delegate.execute(command, args);
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -2179,8 +2186,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 
 	public String scriptLoad(String script) {
 		String result = delegate.scriptLoad(serialize(script));
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -2192,8 +2199,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	 */
 	public <T> T eval(String script, ReturnType returnType, int numKeys, String... keysAndArgs) {
 		T result = delegate.eval(serialize(script), returnType, numKeys, serializeMulti(keysAndArgs));
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
@@ -2205,26 +2212,49 @@ public class DefaultStringRedisConnection implements StringRedisConnection {
 	 */
 	public <T> T evalSha(String scriptSha1, ReturnType returnType, int numKeys, String... keysAndArgs) {
 		T result = delegate.evalSha(scriptSha1, returnType, numKeys, serializeMulti(keysAndArgs));
-		if(isPipelined()) {
-			pipeline(identityConverter);
+		if(isFutureConversion()) {
+			addResultConverter(identityConverter);
 		}
 		return result;
 	}
 
 	/**
-	 * Specifies if pipelined results should be deserialized to Strings.
-	 * If false, results of {@link #closePipeline()} will be of the
+	 * Specifies if pipelined and tx results should be deserialized to Strings.
+	 * If false, results of {@link #closePipeline()} and {@link #exec()} will be of the
 	 * type returned by the underlying connection
 	 *
-	 * @param deserializePipelineResults Whether or not to deserialize pipeline results
+	 * @param deserializePipelineAndTxResults Whether or not to deserialize pipeline and tx results
 	 */
-	public void setDeserializePipelineResults(boolean deserializePipelineResults) {
-		this.deserializePipelineResults = deserializePipelineResults;
+	public void setDeserializePipelineAndTxResults(boolean deserializePipelineAndTxResults) {
+		this.deserializePipelineAndTxResults = deserializePipelineAndTxResults;
 	}
 
-	private void pipeline(Converter<?,?> converter) {
-		if(!isQueueing()) {
+	private void addResultConverter(Converter<?,?> converter) {
+		if(isQueueing()) {
+			txConverters.add(converter);
+		} else {
 			pipelineConverters.add(converter);
 		}
 	}
+
+	private boolean isFutureConversion() {
+    	return isPipelined() || isQueueing();
+    }
+
+	@SuppressWarnings({ "unchecked", "rawtypes" })
+	private List<Object> convertResults(List<Object> results, Queue<Converter> converters) {
+		if(!deserializePipelineAndTxResults || results == null) {
+			return results;
+		}
+		if(results.size() != converters.size()) {
+			// Some of the commands were done directly on the delegate, don't attempt to convert
+			log.warn("Delegate returned an unexpected number of results. Abandoning type conversion.");
+			return results;
+		}
+		List<Object> convertedResults = new ArrayList<Object>();
+		for(Object result: results) {
+			convertedResults.add(converters.remove().convert(result));
+		}
+		return convertedResults;
+	}
 }
\ No newline at end of file
diff --git a/src/main/java/org/springframework/data/redis/connection/jedis/JedisConnection.java b/src/main/java/org/springframework/data/redis/connection/jedis/JedisConnection.java
index 712a355e5..aae2fdb6f 100644
--- a/src/main/java/org/springframework/data/redis/connection/jedis/JedisConnection.java
+++ b/src/main/java/org/springframework/data/redis/connection/jedis/JedisConnection.java
@@ -19,9 +19,11 @@ import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 import java.util.ArrayList;
 import java.util.Collections;
+import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
 import java.util.Properties;
+import java.util.Queue;
 import java.util.Set;
 
 import org.springframework.core.convert.converter.Converter;
@@ -36,6 +38,7 @@ import org.springframework.data.redis.connection.RedisSubscribedConnectionExcept
 import org.springframework.data.redis.connection.ReturnType;
 import org.springframework.data.redis.connection.SortParameters;
 import org.springframework.data.redis.connection.Subscription;
+import org.springframework.data.redis.connection.convert.TransactionResultConverter;
 import org.springframework.util.Assert;
 import org.springframework.util.ObjectUtils;
 import org.springframework.util.ReflectionUtils;
@@ -62,6 +65,7 @@ import redis.clients.util.Pool;
  * {@code RedisConnection} implementation on top of <a href="http://github.com/xetorthio/jedis">Jedis</a> library.
  * 
  * @author Costin Leau
+ * @author Jennifer Hickey
  */
 public class JedisConnection implements RedisConnection {
 
@@ -88,8 +92,9 @@ public class JedisConnection implements RedisConnection {
 	private volatile JedisSubscription subscription;
 	private volatile Pipeline pipeline;
 	private final int dbIndex;
-	private boolean convertPipelineResults=true;
+	private boolean convertPipelineAndTxResults=true;
 	private List<FutureResult<Response<?>>> pipelinedResults = new ArrayList<FutureResult<Response<?>>>();
+	private Queue<FutureResult<Response<?>>> txResults = new LinkedList<FutureResult<Response<?>>>();
 
 	private class JedisResult extends FutureResult<Response<?>> {
 		public <T> JedisResult(Response<T> resultHolder, Converter<T,?> converter) {
@@ -102,7 +107,7 @@ public class JedisConnection implements RedisConnection {
 
 		@SuppressWarnings("unchecked")
 		public Object get() {
-			if(convertPipelineResults && converter != null) {
+			if(convertPipelineAndTxResults && converter != null) {
 				return converter.convert(resultHolder.get());
 			}
 			return resultHolder.get();
@@ -188,6 +193,9 @@ public class JedisConnection implements RedisConnection {
 				if(isPipelined()) {
 					pipeline(new JedisResult(result));
 				}
+				if(isQueueing()) {
+					transaction(new JedisResult(result));
+				}
 				return null;
 			}
 			return client.getOne();
@@ -297,7 +305,7 @@ public class JedisConnection implements RedisConnection {
 		for(FutureResult<Response<?>> result: pipelinedResults) {
 			try {
 				Object data = result.get();
-				if(!convertPipelineResults || !(result.isStatus())) {
+				if(!convertPipelineAndTxResults || !(result.isStatus())) {
 					results.add(data);
 				}
 			}catch(JedisDataException e) {
@@ -315,11 +323,17 @@ public class JedisConnection implements RedisConnection {
 	}
 
 	private void pipeline(FutureResult<Response<?>> result) {
-		if(!isQueueing()) {
+		if(isQueueing()) {
+			transaction(result);
+		} else {
 			pipelinedResults.add(result);
 		}
 	}
 
+	private void transaction(FutureResult<Response<?>> result) {
+		txResults.add(result);
+	}
+
 	public List<byte[]> sort(byte[] key, SortParameters params) {
 
 		SortingParams sortParams = JedisConverters.toSortingParams(params);
@@ -339,10 +353,10 @@ public class JedisConnection implements RedisConnection {
 			}
 			if (isQueueing()) {
 				if (sortParams != null) {
-					transaction.sort(key, sortParams);
+					transaction(new JedisResult(transaction.sort(key, sortParams)));
 				}
 				else {
-					transaction.sort(key);
+					transaction(new JedisResult(transaction.sort(key)));
 				}
 
 				return null;
@@ -371,10 +385,10 @@ public class JedisConnection implements RedisConnection {
 			}
 			if (isQueueing()) {
 				if (sortParams != null) {
-					transaction.sort(key, sortParams, storeKey);
+					transaction(new JedisResult(transaction.sort(key, sortParams, storeKey)));
 				}
 				else {
-					transaction.sort(key, storeKey);
+					transaction(new JedisResult(transaction.sort(key, storeKey)));
 				}
 
 				return null;
@@ -393,7 +407,7 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.dbSize();
+				transaction(new JedisResult(transaction.dbSize()));
 				return null;
 			}
 			return jedis.dbSize();
@@ -411,7 +425,7 @@ public class JedisConnection implements RedisConnection {
 				return;
 			}
 			if (isQueueing()) {
-				transaction.flushDB();
+				transaction(new JedisResult(transaction.flushDB()));
 				return;
 			}
 			jedis.flushDB();
@@ -428,7 +442,7 @@ public class JedisConnection implements RedisConnection {
 				return;
 			}
 			if (isQueueing()) {
-				transaction.flushAll();
+				transaction(new JedisResult(transaction.flushAll()));
 				return;
 			}
 			jedis.flushAll();
@@ -656,7 +670,7 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.del(keys);
+				transaction(new JedisResult(transaction.del(keys)));
 				return null;
 			}
 			return jedis.del(keys);
@@ -675,6 +689,8 @@ public class JedisConnection implements RedisConnection {
 			transaction.discard();
 		} catch (Exception ex) {
 			throw convertJedisAccessException(ex);
+		} finally {
+			txResults.clear();
 		}
 	}
 
@@ -682,16 +698,19 @@ public class JedisConnection implements RedisConnection {
 	public List<Object> exec() {
 		try {
 			if (isPipelined()) {
-				pipeline(new JedisResult(pipeline.exec()));
+				pipeline(new JedisResult(pipeline.exec(),
+						new TransactionResultConverter<Response<?>>(new LinkedList<FutureResult<Response<?>>>(txResults))));
 				return null;
 			}
-			return transaction.exec();
+			List<Object> results = transaction.exec();
+			return convertPipelineAndTxResults ? new TransactionResultConverter<Response<?>>(txResults).convert(results) : results;
 		} catch (Exception ex) {
 			throw convertJedisAccessException(ex);
+		} finally {
+			txResults.clear();
 		}
 	}
 
-
 	public Boolean exists(byte[] key) {
 		try {
 			if (isPipelined()) {
@@ -699,7 +718,7 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.exists(key);
+				transaction(new JedisResult(transaction.exists(key)));
 				return null;
 			}
 			return jedis.exists(key);
@@ -716,7 +735,7 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.expire(key, (int) seconds);
+				transaction(new JedisResult(transaction.expire(key, (int) seconds), JedisConverters.longToBoolean()));
 				return null;
 			}
 			return JedisConverters.toBoolean(jedis.expire(key, (int) seconds));
@@ -733,7 +752,7 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.expireAt(key, unixTime);
+				transaction(new JedisResult(transaction.expireAt(key, unixTime), JedisConverters.longToBoolean()));
 				return null;
 			}
 			return JedisConverters.toBoolean(jedis.expireAt(key, unixTime));
@@ -750,7 +769,7 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.keys(pattern);
+				transaction(new JedisResult(transaction.keys(pattern)));
 				return null;
 			}
 			return (jedis.keys(pattern));
@@ -783,7 +802,7 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.persist(key);
+				transaction(new JedisResult(transaction.persist(key), JedisConverters.longToBoolean()));
 				return null;
 			}
 			return JedisConverters.toBoolean(jedis.persist(key));
@@ -800,7 +819,7 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.move(key, dbIndex);
+				transaction(new JedisResult(transaction.move(key, dbIndex), JedisConverters.longToBoolean()));
 				return null;
 			}
 			return JedisConverters.toBoolean(jedis.move(key, dbIndex));
@@ -832,7 +851,7 @@ public class JedisConnection implements RedisConnection {
 				return;
 			}
 			if (isQueueing()) {
-				transaction.rename(oldName, newName);
+				transaction(new JedisStatusResult(transaction.rename(oldName, newName)));
 				return;
 			}
 			jedis.rename(oldName, newName);
@@ -849,7 +868,7 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.renamenx(oldName, newName);
+				transaction(new JedisResult(transaction.renamenx(oldName, newName), JedisConverters.longToBoolean()));
 				return null;
 			}
 			return JedisConverters.toBoolean(jedis.renamenx(oldName, newName));
@@ -881,7 +900,7 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.ttl(key);
+				transaction(new JedisResult(transaction.ttl(key)));
 				return null;
 			}
 			return jedis.ttl(key);
@@ -917,7 +936,7 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.type(key);
+				transaction(new JedisResult(transaction.type(key), JedisConverters.stringToDataType()));
 				return null;
 			}
 			return JedisConverters.toDataType(jedis.type(key));
@@ -966,7 +985,7 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.get(key);
+				transaction(new JedisResult(transaction.get(key)));
 				return null;
 			}
 
@@ -984,7 +1003,7 @@ public class JedisConnection implements RedisConnection {
 				return;
 			}
 			if (isQueueing()) {
-				transaction.set(key, value);
+				transaction(new JedisStatusResult(transaction.set(key, value)));
 				return;
 			}
 			jedis.set(key, value);
@@ -1002,7 +1021,7 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.getSet(key, value);
+				transaction(new JedisResult(transaction.getSet(key, value), JedisConverters.stringToBytes()));
 				return null;
 			}
 			return jedis.getSet(key, value);
@@ -1019,7 +1038,7 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.append(key, value);
+				transaction(new JedisResult(transaction.append(key, value)));
 				return null;
 			}
 			return jedis.append(key, value);
@@ -1036,7 +1055,7 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.mget(keys);
+				transaction(new JedisResult(transaction.mget(keys)));
 				return null;
 			}
 			return jedis.mget(keys);
@@ -1053,7 +1072,7 @@ public class JedisConnection implements RedisConnection {
 				return;
 			}
 			if (isQueueing()) {
-				transaction.mset(JedisConverters.toByteArrays(tuples));
+				transaction(new JedisStatusResult(transaction.mset(JedisConverters.toByteArrays(tuples))));
 				return;
 			}
 			jedis.mset(JedisConverters.toByteArrays(tuples));
@@ -1070,7 +1089,8 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.msetnx(JedisConverters.toByteArrays(tuples));
+				transaction(new JedisResult(transaction.msetnx(JedisConverters.toByteArrays(tuples)),
+						JedisConverters.longToBoolean()));
 				return null;
 			}
 			return JedisConverters.toBoolean(jedis.msetnx(JedisConverters.toByteArrays(tuples)));
@@ -1087,7 +1107,7 @@ public class JedisConnection implements RedisConnection {
 				return;
 			}
 			if (isQueueing()) {
-				transaction.setex(key, (int) time, value);
+				transaction(new JedisStatusResult(transaction.setex(key, (int) time, value)));
 				return;
 			}
 			jedis.setex(key, (int) time, value);
@@ -1100,11 +1120,13 @@ public class JedisConnection implements RedisConnection {
 	public Boolean setNX(byte[] key, byte[] value) {
 		try {
 			if (isPipelined()) {
-				pipeline(new JedisResult(pipeline.setnx(key, value), JedisConverters.longToBoolean()));
+				pipeline(new JedisResult(pipeline.setnx(key, value),
+						JedisConverters.longToBoolean()));
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.setnx(key, value);
+				transaction(new JedisResult(transaction.setnx(key, value),
+						JedisConverters.longToBoolean()));
 				return null;
 			}
 			return JedisConverters.toBoolean(jedis.setnx(key, value));
@@ -1117,11 +1139,13 @@ public class JedisConnection implements RedisConnection {
 	public byte[] getRange(byte[] key, long start, long end) {
 		try {
 			if (isPipelined()) {
-				pipeline(new JedisResult(pipeline.substr(key, (int) start, (int) end), JedisConverters.stringToBytes()));
+				pipeline(new JedisResult(pipeline.substr(key, (int) start, (int) end),
+						JedisConverters.stringToBytes()));
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.substr(key, (int) start, (int) end);
+				transaction(new JedisResult(transaction.substr(key, (int) start, (int) end),
+						JedisConverters.stringToBytes()));
 				return null;
 			}
 			return jedis.substr(key, (int) start, (int) end);
@@ -1138,7 +1162,7 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.decr(key);
+				transaction(new JedisResult(transaction.decr(key)));
 				return null;
 			}
 			return jedis.decr(key);
@@ -1155,7 +1179,7 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.decrBy(key, value);
+				transaction(new JedisResult(transaction.decrBy(key, value)));
 				return null;
 			}
 			return jedis.decrBy(key, value);
@@ -1172,7 +1196,7 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.incr(key);
+				transaction(new JedisResult(transaction.incr(key)));
 				return null;
 			}
 			return jedis.incr(key);
@@ -1189,7 +1213,7 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.incrBy(key, value);
+				transaction(new JedisResult(transaction.incrBy(key, value)));
 				return null;
 			}
 			return jedis.incrBy(key, value);
@@ -1261,7 +1285,7 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.strlen(key);
+				transaction(new JedisResult(transaction.strlen(key)));
 				return null;
 			}
 			return jedis.strlen(key);
@@ -1296,7 +1320,7 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.lpush(key, value);
+				transaction(new JedisResult(transaction.lpush(key, value)));
 				return null;
 			}
 			return jedis.lpush(key, value);
@@ -1313,7 +1337,7 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.rpush(key, value);
+				transaction(new JedisResult(transaction.rpush(key, value)));
 				return null;
 			}
 			return jedis.rpush(key, value);
@@ -1326,11 +1350,13 @@ public class JedisConnection implements RedisConnection {
 	public List<byte[]> bLPop(int timeout, byte[]... keys) {
 		try {
 			if (isPipelined()) {
-				pipeline(new JedisResult(pipeline.blpop(bXPopArgs(timeout, keys)), JedisConverters.stringListToByteList()));
+				pipeline(new JedisResult(pipeline.blpop(bXPopArgs(timeout, keys)),
+						JedisConverters.stringListToByteList()));
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.blpop(bXPopArgs(timeout, keys));
+				transaction(new JedisResult(transaction.blpop(bXPopArgs(timeout, keys)),
+						JedisConverters.stringListToByteList()));
 				return null;
 			}
 			return jedis.blpop(timeout, keys);
@@ -1343,11 +1369,13 @@ public class JedisConnection implements RedisConnection {
 	public List<byte[]> bRPop(int timeout, byte[]... keys) {
 		try {
 			if (isPipelined()) {
-				pipeline(new JedisResult(pipeline.brpop(bXPopArgs(timeout, keys)), JedisConverters.stringListToByteList()));
+				pipeline(new JedisResult(pipeline.brpop(bXPopArgs(timeout, keys)),
+						JedisConverters.stringListToByteList()));
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.brpop(bXPopArgs(timeout, keys));
+				transaction(new JedisResult(transaction.brpop(bXPopArgs(timeout, keys)),
+						JedisConverters.stringListToByteList()));
 				return null;
 			}
 			return jedis.brpop(timeout, keys);
@@ -1364,7 +1392,7 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.lindex(key, (int) index);
+				transaction(new JedisResult(transaction.lindex(key, (int) index)));
 				return null;
 			}
 			return jedis.lindex(key, (int) index);
@@ -1377,11 +1405,13 @@ public class JedisConnection implements RedisConnection {
 	public Long lInsert(byte[] key, Position where, byte[] pivot, byte[] value) {
 		try {
 			if (isPipelined()) {
-				pipeline(new JedisResult(pipeline.linsert(key, JedisConverters.toListPosition(where), pivot, value)));
+				pipeline(new JedisResult(pipeline.linsert(key, JedisConverters.toListPosition(where),
+						pivot, value)));
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.linsert(key, JedisConverters.toListPosition(where), pivot, value);
+				transaction(new JedisResult(transaction.linsert(key, JedisConverters.toListPosition(where),
+						pivot, value)));
 				return null;
 			}
 			return jedis.linsert(key, JedisConverters.toListPosition(where), pivot, value);
@@ -1398,7 +1428,7 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.llen(key);
+				transaction(new JedisResult(transaction.llen(key)));
 				return null;
 			}
 			return jedis.llen(key);
@@ -1415,7 +1445,7 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.lpop(key);
+				transaction(new JedisResult(transaction.lpop(key)));
 				return null;
 			}
 			return jedis.lpop(key);
@@ -1428,11 +1458,12 @@ public class JedisConnection implements RedisConnection {
 	public List<byte[]> lRange(byte[] key, long start, long end) {
 		try {
 			if (isPipelined()) {
-				pipeline(new JedisResult(pipeline.lrange(key, (int) start, (int) end), JedisConverters.stringListToByteList()));
+				pipeline(new JedisResult(pipeline.lrange(key, (int) start, (int) end),
+						JedisConverters.stringListToByteList()));
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.lrange(key, (int) start, (int) end);
+				transaction(new JedisResult(transaction.lrange(key, (int) start, (int) end)));
 				return null;
 			}
 			return jedis.lrange(key, (int) start, (int) end);
@@ -1449,7 +1480,7 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.lrem(key, (int) count, value);
+				transaction(new JedisResult(transaction.lrem(key, (int) count, value)));
 				return null;
 			}
 			return jedis.lrem(key, (int) count, value);
@@ -1466,7 +1497,7 @@ public class JedisConnection implements RedisConnection {
 				return;
 			}
 			if (isQueueing()) {
-				transaction.lset(key, (int) index, value);
+				transaction(new JedisStatusResult(transaction.lset(key, (int) index, value)));
 				return;
 			}
 			jedis.lset(key, (int) index, value);
@@ -1483,7 +1514,7 @@ public class JedisConnection implements RedisConnection {
 				return;
 			}
 			if (isQueueing()) {
-				transaction.ltrim(key, (int) start, (int) end);
+				transaction(new JedisStatusResult(transaction.ltrim(key, (int) start, (int) end)));
 				return;
 			}
 			jedis.ltrim(key, (int) start, (int) end);
@@ -1500,7 +1531,7 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.rpop(key);
+				transaction(new JedisResult(transaction.rpop(key)));
 				return null;
 			}
 			return jedis.rpop(key);
@@ -1517,7 +1548,7 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.rpoplpush(srcKey, dstKey);
+				transaction(new JedisResult(transaction.rpoplpush(srcKey, dstKey)));
 				return null;
 			}
 			return jedis.rpoplpush(srcKey, dstKey);
@@ -1534,7 +1565,7 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.brpoplpush(srcKey, dstKey, timeout);
+				transaction(new JedisResult(transaction.brpoplpush(srcKey, dstKey, timeout)));
 				return null;
 			}
 			return jedis.brpoplpush(srcKey, dstKey, timeout);
@@ -1551,7 +1582,7 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.lpushx(key, value);
+				transaction(new JedisResult(transaction.lpushx(key, value)));
 				return null;
 			}
 			return jedis.lpushx(key, value);
@@ -1568,7 +1599,7 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.rpushx(key, value);
+				transaction(new JedisResult(transaction.rpushx(key, value)));
 				return null;
 			}
 			return jedis.rpushx(key, value);
@@ -1586,11 +1617,13 @@ public class JedisConnection implements RedisConnection {
 	public Boolean sAdd(byte[] key, byte[] value) {
 		try {
 			if (isPipelined()) {
-				pipeline(new JedisResult(pipeline.sadd(key, value), JedisConverters.longToBoolean()));
+				pipeline(new JedisResult(pipeline.sadd(key, value),
+						JedisConverters.longToBoolean()));
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.sadd(key, value);
+				transaction(new JedisResult(transaction.sadd(key, value),
+						JedisConverters.longToBoolean()));
 				return null;
 			}
 			return JedisConverters.toBoolean(jedis.sadd(key, value));
@@ -1607,7 +1640,7 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.scard(key);
+				transaction(new JedisResult(transaction.scard(key)));
 				return null;
 			}
 			return jedis.scard(key);
@@ -1624,7 +1657,7 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.sdiff(keys);
+				transaction(new JedisResult(transaction.sdiff(keys)));
 				return null;
 			}
 			return jedis.sdiff(keys);
@@ -1641,7 +1674,7 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.sdiffstore(destKey, keys);
+				transaction(new JedisResult(transaction.sdiffstore(destKey, keys)));
 				return null;
 			}
 			return jedis.sdiffstore(destKey, keys);
@@ -1658,7 +1691,7 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.sinter(keys);
+				transaction(new JedisResult(transaction.sinter(keys)));
 				return null;
 			}
 			return jedis.sinter(keys);
@@ -1675,7 +1708,7 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.sinterstore(destKey, keys);
+				transaction(new JedisResult(transaction.sinterstore(destKey, keys)));
 				return null;
 			}
 			return jedis.sinterstore(destKey, keys);
@@ -1692,7 +1725,7 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.sismember(key, value);
+				transaction(new JedisResult(transaction.sismember(key, value)));
 				return null;
 			}
 			return jedis.sismember(key, value);
@@ -1709,7 +1742,7 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.smembers(key);
+				transaction(new JedisResult(transaction.smembers(key)));
 				return null;
 			}
 			return jedis.smembers(key);
@@ -1726,7 +1759,8 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.smove(srcKey, destKey, value);
+				transaction(new JedisResult(transaction.smove(srcKey, destKey, value),
+						JedisConverters.longToBoolean()));
 				return null;
 			}
 			return JedisConverters.toBoolean(jedis.smove(srcKey, destKey, value));
@@ -1743,7 +1777,7 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.spop(key);
+				transaction(new JedisResult(transaction.spop(key)));
 				return null;
 			}
 			return jedis.spop(key);
@@ -1760,7 +1794,7 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.srandmember(key);
+				transaction(new JedisResult(transaction.srandmember(key)));
 				return null;
 			}
 			return jedis.srandmember(key);
@@ -1780,7 +1814,8 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.srem(key, value);
+				transaction(new JedisResult(transaction.srem(key, value),
+						JedisConverters.longToBoolean()));
 				return null;
 			}
 			return JedisConverters.toBoolean(jedis.srem(key, value));
@@ -1797,7 +1832,7 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.sunion(keys);
+				transaction(new JedisResult(transaction.sunion(keys)));
 				return null;
 			}
 			return jedis.sunion(keys);
@@ -1814,7 +1849,7 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.sunionstore(destKey, keys);
+				transaction(new JedisResult(transaction.sunionstore(destKey, keys)));
 				return null;
 			}
 			return jedis.sunionstore(destKey, keys);
@@ -1835,7 +1870,7 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.zadd(key, score, value);
+				transaction(new JedisResult(transaction.zadd(key, score, value), JedisConverters.longToBoolean()));
 				return null;
 			}
 			return JedisConverters.toBoolean(jedis.zadd(key, score, value));
@@ -1852,7 +1887,7 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.zcard(key);
+				transaction(new JedisResult(transaction.zcard(key)));
 				return null;
 			}
 			return jedis.zcard(key);
@@ -1869,7 +1904,7 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.zcount(key, min, max);
+				transaction(new JedisResult(transaction.zcount(key, min, max)));
 				return null;
 			}
 			return jedis.zcount(key, min, max);
@@ -1886,7 +1921,7 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.zincrby(key, increment, value);
+				transaction(new JedisResult(transaction.zincrby(key, increment, value)));
 				return null;
 			}
 			return jedis.zincrby(key, increment, value);
@@ -1906,7 +1941,7 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.zinterstore(destKey, zparams, sets);
+				transaction(new JedisResult(transaction.zinterstore(destKey, zparams, sets)));
 				return null;
 			}
 			return jedis.zinterstore(destKey, zparams, sets);
@@ -1923,7 +1958,7 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.zinterstore(destKey, sets);
+				transaction(new JedisResult(transaction.zinterstore(destKey, sets)));
 				return null;
 			}
 			return jedis.zinterstore(destKey, sets);
@@ -1940,7 +1975,7 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.zrange(key, (int) start, (int) end);
+				transaction(new JedisResult(transaction.zrange(key, (int) start, (int) end)));
 				return null;
 			}
 			return jedis.zrange(key, (int) start, (int) end);
@@ -1953,11 +1988,13 @@ public class JedisConnection implements RedisConnection {
 	public Set<Tuple> zRangeWithScores(byte[] key, long start, long end) {
 		try {
 			if (isPipelined()) {
-				pipeline(new JedisResult(pipeline.zrangeWithScores(key, (int) start, (int) end), JedisConverters.tupleSetToTupleSet()));
+				pipeline(new JedisResult(pipeline.zrangeWithScores(key, (int) start, (int) end),
+						JedisConverters.tupleSetToTupleSet()));
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.zrangeWithScores(key, (int) start, (int) end);
+				transaction(new JedisResult(transaction.zrangeWithScores(key, (int) start, (int) end),
+						JedisConverters.tupleSetToTupleSet()));
 				return null;
 			}
 			return JedisConverters.toTupleSet(jedis.zrangeWithScores(key, (int) start, (int) end));
@@ -1974,7 +2011,7 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.zrangeByScore(key, min, max);
+				transaction(new JedisResult(transaction.zrangeByScore(key, min, max)));
 				return null;
 			}
 			return jedis.zrangeByScore(key, min, max);
@@ -1987,11 +2024,13 @@ public class JedisConnection implements RedisConnection {
 	public Set<Tuple> zRangeByScoreWithScores(byte[] key, double min, double max) {
 		try {
 			if (isPipelined()) {
-				pipeline(new JedisResult(pipeline.zrangeByScoreWithScores(key, min, max), JedisConverters.tupleSetToTupleSet()));
+				pipeline(new JedisResult(pipeline.zrangeByScoreWithScores(key, min, max),
+						JedisConverters.tupleSetToTupleSet()));
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.zrangeByScoreWithScores(key, min, max);
+				transaction(new JedisResult(transaction.zrangeByScoreWithScores(key, min, max),
+						JedisConverters.tupleSetToTupleSet()));
 				return null;
 			}
 			return JedisConverters.toTupleSet(jedis.zrangeByScoreWithScores(key, min, max));
@@ -2004,11 +2043,13 @@ public class JedisConnection implements RedisConnection {
 	public Set<Tuple> zRevRangeWithScores(byte[] key, long start, long end) {
 		try {
 			if (isPipelined()) {
-				pipeline(new JedisResult(pipeline.zrevrangeWithScores(key, (int) start, (int) end), JedisConverters.tupleSetToTupleSet()));
+				pipeline(new JedisResult(pipeline.zrevrangeWithScores(key, (int) start, (int) end),
+						JedisConverters.tupleSetToTupleSet()));
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.zrevrangeWithScores(key, (int) start, (int) end);
+				transaction(new JedisResult(transaction.zrevrangeWithScores(key, (int) start, (int) end),
+						JedisConverters.tupleSetToTupleSet()));
 				return null;
 			}
 			return JedisConverters.toTupleSet(jedis.zrevrangeWithScores(key, (int) start, (int) end));
@@ -2021,11 +2062,12 @@ public class JedisConnection implements RedisConnection {
 	public Set<byte[]> zRangeByScore(byte[] key, double min, double max, long offset, long count) {
 		try {
 			if (isPipelined()) {
-				pipeline(new JedisResult(pipeline.zrangeByScore(key, min, max, (int) offset, (int) count), JedisConverters.stringSetToByteSet()));
+				pipeline(new JedisResult(pipeline.zrangeByScore(key, min, max, (int) offset, (int) count),
+						JedisConverters.stringSetToByteSet()));
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.zrangeByScore(key, min, max, (int) offset, (int) count);
+				transaction(new JedisResult(transaction.zrangeByScore(key, min, max, (int) offset, (int) count)));
 				return null;
 			}
 			return jedis.zrangeByScore(key, min, max, (int) offset, (int) count);
@@ -2038,11 +2080,13 @@ public class JedisConnection implements RedisConnection {
 	public Set<Tuple> zRangeByScoreWithScores(byte[] key, double min, double max, long offset, long count) {
 		try {
 			if (isPipelined()) {
-				pipeline(new JedisResult(pipeline.zrangeByScoreWithScores(key, min, max, (int) offset, (int) count), JedisConverters.tupleSetToTupleSet()));
+				pipeline(new JedisResult(pipeline.zrangeByScoreWithScores(key, min, max, (int) offset, (int) count),
+						JedisConverters.tupleSetToTupleSet()));
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.zrangeByScoreWithScores(key, min, max, (int) offset, (int) count);
+				transaction(new JedisResult(transaction.zrangeByScoreWithScores(key, min, max, (int) offset, (int) count),
+						JedisConverters.tupleSetToTupleSet()));
 				return null;
 			}
 			return JedisConverters.toTupleSet(jedis.zrangeByScoreWithScores(key, min, max, (int) offset, (int) count));
@@ -2120,7 +2164,7 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.zrank(key, value);
+				transaction(new JedisResult(transaction.zrank(key, value)));
 				return null;
 			}
 			return jedis.zrank(key, value);
@@ -2137,7 +2181,7 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.zrem(key, value);
+				transaction(new JedisResult(transaction.zrem(key, value), JedisConverters.longToBoolean()));
 				return null;
 			}
 			return JedisConverters.toBoolean(jedis.zrem(key, value));
@@ -2154,7 +2198,7 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.zremrangeByRank(key, (int) start, (int) end);
+				transaction(new JedisResult(transaction.zremrangeByRank(key, (int) start, (int) end)));
 				return null;
 			}
 			return jedis.zremrangeByRank(key, (int) start, (int) end);
@@ -2171,7 +2215,7 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.zremrangeByScore(key, min, max);
+				transaction(new JedisResult(transaction.zremrangeByScore(key, min, max)));
 				return null;
 			}
 			return jedis.zremrangeByScore(key, min, max);
@@ -2184,11 +2228,12 @@ public class JedisConnection implements RedisConnection {
 	public Set<byte[]> zRevRange(byte[] key, long start, long end) {
 		try {
 			if (isPipelined()) {
-				pipeline(new JedisResult(pipeline.zrevrange(key, (int) start, (int) end), JedisConverters.stringSetToByteSet()));
+				pipeline(new JedisResult(pipeline.zrevrange(key, (int) start, (int) end),
+						JedisConverters.stringSetToByteSet()));
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.zrevrange(key, (int) start, (int) end);
+				transaction(new JedisResult(transaction.zrevrange(key, (int) start, (int) end)));
 				return null;
 			}
 			return jedis.zrevrange(key, (int) start, (int) end);
@@ -2205,7 +2250,7 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.zrevrank(key, value);
+				transaction(new JedisResult(transaction.zrevrank(key, value)));
 				return null;
 			}
 			return jedis.zrevrank(key, value);
@@ -2222,7 +2267,7 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.zscore(key, value);
+				transaction(new JedisResult(transaction.zscore(key, value)));
 				return null;
 			}
 			return jedis.zscore(key, value);
@@ -2242,7 +2287,7 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.zunionstore(destKey, zparams, sets);
+				transaction(new JedisResult(transaction.zunionstore(destKey, zparams, sets)));
 				return null;
 			}
 			return jedis.zunionstore(destKey, zparams, sets);
@@ -2259,7 +2304,7 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.zunionstore(destKey, sets);
+				transaction(new JedisResult(transaction.zunionstore(destKey, sets)));
 				return null;
 			}
 			return jedis.zunionstore(destKey, sets);
@@ -2280,7 +2325,8 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.hset(key, field, value);
+				transaction(new JedisResult(transaction.hset(key, field, value),
+						JedisConverters.longToBoolean()));
 				return null;
 			}
 			return JedisConverters.toBoolean(jedis.hset(key, field, value));
@@ -2293,11 +2339,13 @@ public class JedisConnection implements RedisConnection {
 	public Boolean hSetNX(byte[] key, byte[] field, byte[] value) {
 		try {
 			if (isPipelined()) {
-				pipeline(new JedisResult(pipeline.hsetnx(key, field, value), JedisConverters.longToBoolean()));
+				pipeline(new JedisResult(pipeline.hsetnx(key, field, value),
+						JedisConverters.longToBoolean()));
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.hsetnx(key, field, value);
+				transaction(new JedisResult(transaction.hsetnx(key, field, value),
+						JedisConverters.longToBoolean()));
 				return null;
 			}
 			return JedisConverters.toBoolean(jedis.hsetnx(key, field, value));
@@ -2314,7 +2362,7 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.hdel(key, field);
+				transaction(new JedisResult(transaction.hdel(key, field), JedisConverters.longToBoolean()));
 				return null;
 			}
 			return JedisConverters.toBoolean(jedis.hdel(key, field));
@@ -2331,7 +2379,7 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.hexists(key, field);
+				transaction(new JedisResult(transaction.hexists(key, field)));
 				return null;
 			}
 			return jedis.hexists(key, field);
@@ -2348,7 +2396,7 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.hget(key, field);
+				transaction(new JedisResult(transaction.hget(key, field)));
 				return null;
 			}
 			return jedis.hget(key, field);
@@ -2365,7 +2413,7 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.hgetAll(key);
+				transaction(new JedisResult(transaction.hgetAll(key), JedisConverters.stringMapToByteMap()));
 				return null;
 			}
 			return jedis.hgetAll(key);
@@ -2382,7 +2430,7 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.hincrBy(key, field, delta);
+				transaction(new JedisResult(transaction.hincrBy(key, field, delta)));
 				return null;
 			}
 			return jedis.hincrBy(key, field, delta);
@@ -2402,7 +2450,7 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.hkeys(key);
+				transaction(new JedisResult(transaction.hkeys(key)));
 				return null;
 			}
 			return jedis.hkeys(key);
@@ -2419,7 +2467,7 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.hlen(key);
+				transaction(new JedisResult(transaction.hlen(key)));
 				return null;
 			}
 			return jedis.hlen(key);
@@ -2436,7 +2484,7 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.hmget(key, fields);
+				transaction(new JedisResult(transaction.hmget(key, fields)));
 				return null;
 			}
 			return jedis.hmget(key, fields);
@@ -2453,7 +2501,7 @@ public class JedisConnection implements RedisConnection {
 				return;
 			}
 			if (isQueueing()) {
-				transaction.hmset(key, tuple);
+				transaction(new JedisStatusResult(transaction.hmset(key, tuple)));
 				return;
 			}
 			jedis.hmset(key, tuple);
@@ -2470,7 +2518,7 @@ public class JedisConnection implements RedisConnection {
 				return null;
 			}
 			if (isQueueing()) {
-				transaction.hvals(key);
+				transaction(new JedisResult(transaction.hvals(key)));
 				return null;
 			}
 			return jedis.hvals(key);
@@ -2656,13 +2704,13 @@ public class JedisConnection implements RedisConnection {
 
 	/**
 	 * Specifies if pipelined results should be converted to the expected data
-	 * type. If false, results of {@link #closePipeline()} will be of the
+	 * type. If false, results of {@link #closePipeline()} and {@link #exec()} will be of the
 	 * type returned by the Jedis driver
 	 *
-	 * @param convertPipelineResults Whether or not to convert pipeline results
+	 * @param convertPipelineAndTxResults Whether or not to convert pipeline and tx results
 	 */
-	public void setConvertPipelineResults(boolean convertPipelineResults) {
-		this.convertPipelineResults = convertPipelineResults;
+	public void setConvertPipelineAndTxResults(boolean convertPipelineAndTxResults) {
+		this.convertPipelineAndTxResults = convertPipelineAndTxResults;
 	}
 
 	private byte[][] bXPopArgs(int timeout, byte[]... keys) {
diff --git a/src/main/java/org/springframework/data/redis/core/StringRedisTemplate.java b/src/main/java/org/springframework/data/redis/core/StringRedisTemplate.java
index 28f838bcb..260501a94 100644
--- a/src/main/java/org/springframework/data/redis/core/StringRedisTemplate.java
+++ b/src/main/java/org/springframework/data/redis/core/StringRedisTemplate.java
@@ -34,7 +34,7 @@ import org.springframework.data.redis.serializer.StringRedisSerializer;
  */
 public class StringRedisTemplate extends RedisTemplate<String, String> {
 
-	private boolean deserializePipelineResults = true;
+	private boolean deserializePipelineAndTxResults = true;
 
 	/**
 	 * Constructs a new <code>StringRedisTemplate</code> instance.
@@ -61,19 +61,19 @@ public class StringRedisTemplate extends RedisTemplate<String, String> {
 	}
 
 	/**
-	 * Specifies if pipelined results should be deserialized to Strings.
-	 * If false, results of {@link StringRedisConnection#closePipeline()} will be of the
-	 * type returned by the underlying connection
+	 * Specifies if pipelined and tx results should be deserialized to Strings.
+	 * If false, results of {@link StringRedisConnection#closePipeline()} and {@link StringRedisConnection#exec()}
+	 * will be of the type returned by the underlying connection
 	 *
-	 * @param deserializePipelineResults Whether or not to deserialize pipeline results
+	 * @param deserializePipelineAndTxResults Whether or not to deserialize pipeline and tx results
 	 */
-	public void setDeserializePipelineResults(boolean deserializePipelineResults) {
-		this.deserializePipelineResults = deserializePipelineResults;
+	public void setDeserializePipelineAndTxResults(boolean deserializePipelineAndTxResults) {
+		this.deserializePipelineAndTxResults = deserializePipelineAndTxResults;
 	}
 
 	protected RedisConnection preProcessConnection(RedisConnection connection, boolean existingConnection) {
 		DefaultStringRedisConnection stringConn =  new DefaultStringRedisConnection(connection);
-		stringConn.setDeserializePipelineResults(deserializePipelineResults);
+		stringConn.setDeserializePipelineAndTxResults(deserializePipelineAndTxResults);
 		return stringConn;
 	}
 }
\ No newline at end of file
diff --git a/src/test/java/org/springframework/data/redis/connection/AbstractConnectionTransactionIntegrationTests.java b/src/test/java/org/springframework/data/redis/connection/AbstractConnectionTransactionIntegrationTests.java
index 4df377373..d659d2d85 100644
--- a/src/test/java/org/springframework/data/redis/connection/AbstractConnectionTransactionIntegrationTests.java
+++ b/src/test/java/org/springframework/data/redis/connection/AbstractConnectionTransactionIntegrationTests.java
@@ -12,6 +12,7 @@ import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
+import org.junit.Before;
 import org.junit.Ignore;
 import org.junit.Test;
 import org.springframework.dao.DataAccessException;
@@ -29,6 +30,12 @@ abstract public class AbstractConnectionTransactionIntegrationTests extends
 
 	protected boolean convertStringToProps = false;
 
+	@Before
+	public void setUp() {
+		super.setUp();
+		((DefaultStringRedisConnection)connection).setDeserializePipelineAndTxResults(false);
+	}
+
 	@Ignore
 	public void testMultiDiscard() {
 	}
diff --git a/src/test/java/org/springframework/data/redis/connection/DefaultStringRedisConnectionPipelineTests.java b/src/test/java/org/springframework/data/redis/connection/DefaultStringRedisConnectionPipelineTests.java
index 00e7e27c5..9e785c854 100644
--- a/src/test/java/org/springframework/data/redis/connection/DefaultStringRedisConnectionPipelineTests.java
+++ b/src/test/java/org/springframework/data/redis/connection/DefaultStringRedisConnectionPipelineTests.java
@@ -142,13 +142,6 @@ public class DefaultStringRedisConnectionPipelineTests extends DefaultStringRedi
 		super.testEcho();
 	}
 
-	@Test
-	public void testExec() {
-		List<Object> results = Arrays.asList(new Object[] { barBytes });
-		doReturn(Arrays.asList(new Object[] { results })).when(nativeConnection).closePipeline();
-		super.testExec();
-	}
-
 	@Test
 	public void testTxResultsNotPipelined() {
 		doReturn(true).when(nativeConnection).isQueueing();
@@ -1408,7 +1401,7 @@ public class DefaultStringRedisConnectionPipelineTests extends DefaultStringRedi
 
 	@Test
 	public void testDisablePipelineDeserialize() {
-		connection.setDeserializePipelineResults(false);
+		connection.setDeserializePipelineAndTxResults(false);
 		doReturn(Arrays.asList(new Object[] { barBytes })).when(nativeConnection).closePipeline();
 		doReturn(barBytes).when(nativeConnection).get(fooBytes);
 		connection.get(foo);
diff --git a/src/test/java/org/springframework/data/redis/connection/DefaultStringRedisConnectionPipelineTxTests.java b/src/test/java/org/springframework/data/redis/connection/DefaultStringRedisConnectionPipelineTxTests.java
new file mode 100644
index 000000000..f07b8f4af
--- /dev/null
+++ b/src/test/java/org/springframework/data/redis/connection/DefaultStringRedisConnectionPipelineTxTests.java
@@ -0,0 +1,1401 @@
+package org.springframework.data.redis.connection;
+
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.when;
+import static org.junit.Assert.assertEquals;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Properties;
+
+import org.junit.Before;
+import org.junit.Test;
+
+public class DefaultStringRedisConnectionPipelineTxTests extends
+		DefaultStringRedisConnectionTxTests {
+
+	@Before
+	public void setUp() {
+		super.setUp();
+		when(nativeConnection.isPipelined()).thenReturn(true);
+	}
+
+	@Test
+	public void testAppend() {
+		doReturn(Arrays.asList(new Object[] { Arrays.asList(new Object[] { 1l })})).when(nativeConnection).closePipeline();
+		super.testAppend();
+	}
+
+	@Test
+	public void testAppendBytes() {
+		doReturn(Arrays.asList(new Object[] { Arrays.asList(new Object[] { 1l })})).when(nativeConnection).closePipeline();
+		super.testAppendBytes();
+	}
+
+	@Test
+	public void testBlPopBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { bytesList })})).when(nativeConnection).closePipeline();
+		super.testBlPopBytes();
+	}
+
+	@Test
+	public void testBlPop() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { bytesList })})).when(nativeConnection).closePipeline();
+		super.testBlPop();
+	}
+
+	@Test
+	public void testBrPopBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { bytesList })})).when(nativeConnection).closePipeline();
+		super.testBrPopBytes();
+	}
+
+	@Test
+	public void testBrPop() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { bytesList })})).when(nativeConnection).closePipeline();
+		super.testBrPop();
+	}
+
+	@Test
+	public void testBrPopLPushBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { barBytes })})).when(nativeConnection).closePipeline();
+		super.testBrPopLPushBytes();
+	}
+
+	@Test
+	public void testBrPopLPush() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { barBytes })})).when(nativeConnection).closePipeline();
+		super.testBrPopLPush();
+	}
+
+	@Test
+	public void testDbSize() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 3l })})).when(nativeConnection).closePipeline();
+		super.testDbSize();
+	}
+
+	@Test
+	public void testDecrBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 3l })})).when(nativeConnection).closePipeline();
+		super.testDecrBytes();
+	}
+
+	@Test
+	public void testDecr() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 3l })})).when(nativeConnection).closePipeline();
+		super.testDecr();
+	}
+
+	@Test
+	public void testDecrByBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 3l })})).when(nativeConnection).closePipeline();
+		super.testDecrByBytes();
+	}
+
+	@Test
+	public void testDecrBy() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 3l })})).when(nativeConnection).closePipeline();
+		super.testDecrBy();
+	}
+
+	@Test
+	public void testDelBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 1l })})).when(nativeConnection).closePipeline();
+		super.testDelBytes();
+	}
+
+	@Test
+	public void testDel() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 1l })})).when(nativeConnection).closePipeline();
+		super.testDel();
+	}
+
+	@Test
+	public void testEchoBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { barBytes })})).when(nativeConnection).closePipeline();
+		super.testEchoBytes();
+	}
+
+	@Test
+	public void testEcho() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { barBytes })})).when(nativeConnection).closePipeline();
+		super.testEcho();
+	}
+
+	@Test
+	public void testExistsBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { true })})).when(nativeConnection).closePipeline();
+		super.testExistsBytes();
+	}
+
+	@Test
+	public void testExists() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { true })})).when(nativeConnection).closePipeline();
+		super.testExists();
+	}
+
+	@Test
+	public void testExpireBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { true })})).when(nativeConnection).closePipeline();
+		super.testExpireBytes();
+	}
+
+	@Test
+	public void testExpire() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { true })})).when(nativeConnection).closePipeline();
+		super.testExpire();
+	}
+
+	@Test
+	public void testExpireAtBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { true })})).when(nativeConnection).closePipeline();
+		super.testExpireAtBytes();
+	}
+
+	@Test
+	public void testExpireAt() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { true })})).when(nativeConnection).closePipeline();
+		super.testExpireAt();
+	}
+
+	@Test
+	public void testGetBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { barBytes })})).when(nativeConnection).closePipeline();
+		super.testGetBytes();
+	}
+
+	@Test
+	public void testGet() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { barBytes })})).when(nativeConnection).closePipeline();
+		super.testGet();
+	}
+
+	@Test
+	public void testGetBitBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { true })})).when(nativeConnection).closePipeline();
+		super.testGetBitBytes();
+	}
+
+	@Test
+	public void testGetBit() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { true })})).when(nativeConnection).closePipeline();
+		super.testGetBit();
+	}
+
+	@Test
+	public void testGetConfig() {
+		List<String> results = Collections.singletonList("bar");
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { results })})).when(nativeConnection).closePipeline();
+		super.testGetConfig();
+	}
+
+	@Test
+	public void testGetNativeConnection() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { "foo" })})).when(nativeConnection).closePipeline();
+		super.testGetNativeConnection();
+	}
+
+	@Test
+	public void testGetRangeBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { barBytes })})).when(nativeConnection).closePipeline();
+		super.testGetRangeBytes();
+	}
+
+	@Test
+	public void testGetRange() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { barBytes })})).when(nativeConnection).closePipeline();
+		super.testGetRange();
+	}
+
+	@Test
+	public void testGetSetBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { barBytes })})).when(nativeConnection).closePipeline();
+		super.testGetSetBytes();
+	}
+
+	@Test
+	public void testGetSet() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { barBytes })})).when(nativeConnection).closePipeline();
+		super.testGetSet();
+	}
+
+	@Test
+	public void testHDelBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { true })})).when(nativeConnection).closePipeline();
+		super.testHDelBytes();
+	}
+
+	@Test
+	public void testHDel() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { true })})).when(nativeConnection).closePipeline();
+		super.testHDel();
+	}
+
+	@Test
+	public void testHExistsBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { true })})).when(nativeConnection).closePipeline();
+		super.testHExistsBytes();
+	}
+
+	@Test
+	public void testHExists() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { true })})).when(nativeConnection).closePipeline();
+		super.testHExists();
+	}
+
+	@Test
+	public void testHGetBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { barBytes })})).when(nativeConnection).closePipeline();
+		super.testHGetBytes();
+	}
+
+	@Test
+	public void testHGet() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { barBytes })})).when(nativeConnection).closePipeline();
+		super.testHGet();
+	}
+
+	@Test
+	public void testHGetAllBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { bytesMap })})).when(nativeConnection).closePipeline();
+		super.testHGetAllBytes();
+	}
+
+	@Test
+	public void testHGetAll() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { bytesMap })})).when(nativeConnection).closePipeline();
+		super.testHGetAll();
+	}
+
+	@Test
+	public void testHIncrByBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 3l })})).when(nativeConnection).closePipeline();
+		super.testHIncrByBytes();
+	}
+
+	@Test
+	public void testHIncrBy() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 3l })})).when(nativeConnection).closePipeline();
+		super.testHIncrBy();
+	}
+
+	@Test
+	public void testHIncrByDoubleBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 3d })})).when(nativeConnection).closePipeline();
+		super.testHIncrByDoubleBytes();
+	}
+
+	@Test
+	public void testHIncrByDouble() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 3d })})).when(nativeConnection).closePipeline();
+		super.testHIncrByDouble();
+	}
+
+	@Test
+	public void testHKeysBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { bytesSet })})).when(nativeConnection).closePipeline();
+		super.testHKeysBytes();
+	}
+
+	@Test
+	public void testHKeys() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { bytesSet })})).when(nativeConnection).closePipeline();
+		super.testHKeys();
+	}
+
+	@Test
+	public void testHLenBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 3l })})).when(nativeConnection).closePipeline();
+		super.testHLenBytes();
+	}
+
+	@Test
+	public void testHLen() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 3l })})).when(nativeConnection).closePipeline();
+		super.testHLen();
+	}
+
+	@Test
+	public void testHMGetBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { bytesList })})).when(nativeConnection).closePipeline();
+		super.testHMGetBytes();
+	}
+
+	@Test
+	public void testHMGet() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { bytesList })})).when(nativeConnection).closePipeline();
+		super.testHMGet();
+	}
+
+	@Test
+	public void testHSetBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { true })})).when(nativeConnection).closePipeline();
+		super.testHSetBytes();
+	}
+
+	@Test
+	public void testHSet() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { true })})).when(nativeConnection).closePipeline();
+		super.testHSet();
+	}
+
+	@Test
+	public void testHSetNXBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { true })})).when(nativeConnection).closePipeline();
+		super.testHSetNXBytes();
+	}
+
+	@Test
+	public void testHSetNX() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { true })})).when(nativeConnection).closePipeline();
+		super.testHSetNX();
+	}
+
+	@Test
+	public void testHValsBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { bytesList })})).when(nativeConnection).closePipeline();
+		super.testHValsBytes();
+	}
+
+	@Test
+	public void testHVals() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { bytesList })})).when(nativeConnection).closePipeline();
+		super.testHVals();
+	}
+
+	@Test
+	public void testIncrBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 2l })})).when(nativeConnection).closePipeline();
+		super.testIncrBytes();
+	}
+
+	@Test
+	public void testIncr() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 2l })})).when(nativeConnection).closePipeline();
+		super.testIncr();
+	}
+
+	@Test
+	public void testIncrByBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 2l })})).when(nativeConnection).closePipeline();
+		super.testIncrByBytes();
+	}
+
+	@Test
+	public void testIncrBy() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 2l })})).when(nativeConnection).closePipeline();
+		super.testIncrBy();
+	}
+
+	@Test
+	public void testIncrByDoubleBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 2d })})).when(nativeConnection).closePipeline();
+		super.testIncrByDoubleBytes();
+	}
+
+	@Test
+	public void testIncrByDouble() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 2d })})).when(nativeConnection).closePipeline();
+		super.testIncrByDouble();
+	}
+
+	@Test
+	public void testInfo() {
+		Properties props = new Properties();
+		props.put("foo", "bar");
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { props })})).when(nativeConnection).closePipeline();
+		super.testInfo();
+	}
+
+	@Test
+	public void testInfoBySection() {
+		Properties props = new Properties();
+		props.put("foo", "bar");
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { props })})).when(nativeConnection).closePipeline();
+		super.testInfoBySection();
+	}
+
+	@Test
+	public void testKeysBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { bytesSet })})).when(nativeConnection).closePipeline();
+		super.testKeysBytes();
+	}
+
+	@Test
+	public void testKeys() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { bytesSet })})).when(nativeConnection).closePipeline();
+		super.testKeys();
+	}
+
+	@Test
+	public void testLastSave() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 6l })})).when(nativeConnection).closePipeline();
+		super.testLastSave();
+	}
+
+	@Test
+	public void testLIndexBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { barBytes })})).when(nativeConnection).closePipeline();
+		super.testLIndexBytes();
+	}
+
+	@Test
+	public void testLIndex() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { barBytes })})).when(nativeConnection).closePipeline();
+		super.testLIndex();
+	}
+
+	@Test
+	public void testLInsertBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 8l })})).when(nativeConnection).closePipeline();
+		super.testLInsertBytes();
+	}
+
+	@Test
+	public void testLInsert() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 8l })})).when(nativeConnection).closePipeline();
+		super.testLInsert();
+	}
+
+	@Test
+	public void testLLenBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 8l })})).when(nativeConnection).closePipeline();
+		super.testLLenBytes();
+	}
+
+	@Test
+	public void testLLen() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 8l })})).when(nativeConnection).closePipeline();
+		super.testLLen();
+	}
+
+	@Test
+	public void testLPopBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { barBytes })})).when(nativeConnection).closePipeline();
+		actual.add(connection.lPop(fooBytes));
+		verifyResults(Arrays.asList(new Object[] { barBytes }));
+	}
+
+	@Test
+	public void testLPop() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { barBytes })})).when(nativeConnection).closePipeline();
+		super.testLPop();
+	}
+
+	@Test
+	public void testLPushBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 8l })})).when(nativeConnection).closePipeline();
+		super.testLPushBytes();
+	}
+
+	@Test
+	public void testLPush() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 8l })})).when(nativeConnection).closePipeline();
+		super.testLPush();
+	}
+
+	@Test
+	public void testLPushXBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 8l })})).when(nativeConnection).closePipeline();
+		super.testLPushXBytes();
+	}
+
+	@Test
+	public void testLPushX() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 8l })})).when(nativeConnection).closePipeline();
+		super.testLPushX();
+	}
+
+	@Test
+	public void testLRangeBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { bytesList })})).when(nativeConnection).closePipeline();
+		super.testLRangeBytes();
+	}
+
+	@Test
+	public void testLRange() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { bytesList })})).when(nativeConnection).closePipeline();
+		super.testLRange();
+	}
+
+	@Test
+	public void testLRemBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 8l })})).when(nativeConnection).closePipeline();
+		super.testLRemBytes();
+	}
+
+	@Test
+	public void testLRem() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 8l })})).when(nativeConnection).closePipeline();
+		super.testLRem();
+	}
+
+	@Test
+	public void testMGetBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { bytesList })})).when(nativeConnection).closePipeline();
+		super.testMGetBytes();
+	}
+
+	@Test
+	public void testMGet() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { bytesList })})).when(nativeConnection).closePipeline();
+		super.testMGet();
+	}
+
+	@Test
+	public void testMSetNXBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { true })})).when(nativeConnection).closePipeline();
+		super.testMSetNXBytes();
+	}
+
+	@Test
+	public void testMSetNXString() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { true })})).when(nativeConnection).closePipeline();
+		super.testMSetNXString();
+	}
+
+	@Test
+	public void testPersistBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { true })})).when(nativeConnection).closePipeline();
+		super.testPersistBytes();
+	}
+
+	@Test
+	public void testPersist() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { true })})).when(nativeConnection).closePipeline();
+		super.testPersist();
+	}
+
+	@Test
+	public void testMoveBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { true })})).when(nativeConnection).closePipeline();
+		super.testMoveBytes();
+	}
+
+	@Test
+	public void testMove() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { true })})).when(nativeConnection).closePipeline();
+		super.testMove();
+	}
+
+	@Test
+	public void testPing() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { "pong" })})).when(nativeConnection).closePipeline();
+		super.testPing();
+	}
+
+	@Test
+	public void testPublishBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 2l })})).when(nativeConnection).closePipeline();
+		super.testPublishBytes();
+	}
+
+	@Test
+	public void testPublish() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 2l })})).when(nativeConnection).closePipeline();
+		super.testPublish();
+	}
+
+	@Test
+	public void testRandomKey() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { fooBytes })})).when(nativeConnection).closePipeline();
+		super.testRandomKey();
+	}
+
+	@Test
+	public void testRenameNXBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { true })})).when(nativeConnection).closePipeline();
+		super.testRenameNXBytes();
+	}
+
+	@Test
+	public void testRenameNX() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { true })})).when(nativeConnection).closePipeline();
+		super.testRenameNX();
+	}
+
+	@Test
+	public void testRPopBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { barBytes })})).when(nativeConnection).closePipeline();
+		super.testRPopBytes();
+	}
+
+	@Test
+	public void testRPop() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { barBytes })})).when(nativeConnection).closePipeline();
+		super.testRPop();
+	}
+
+	@Test
+	public void testRPopLPushBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { barBytes })})).when(nativeConnection).closePipeline();
+		super.testRPopLPushBytes();
+	}
+
+	@Test
+	public void testRPopLPush() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { barBytes })})).when(nativeConnection).closePipeline();
+		super.testRPopLPush();
+	}
+
+	@Test
+	public void testRPushBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 4l })})).when(nativeConnection).closePipeline();
+		super.testRPushBytes();
+	}
+
+	@Test
+	public void testRPush() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 4l })})).when(nativeConnection).closePipeline();
+		super.testRPush();
+	}
+
+	@Test
+	public void testRPushXBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 4l })})).when(nativeConnection).closePipeline();
+		super.testRPushXBytes();
+	}
+
+	@Test
+	public void testRPushX() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 4l })})).when(nativeConnection).closePipeline();
+		super.testRPushX();
+	}
+
+	@Test
+	public void testSAddBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { true })})).when(nativeConnection).closePipeline();
+		super.testSAddBytes();
+	}
+
+	@Test
+	public void testSAdd() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { true })})).when(nativeConnection).closePipeline();
+		super.testSAdd();
+	}
+
+	@Test
+	public void testSCardBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 4l })})).when(nativeConnection).closePipeline();
+		super.testSCardBytes();
+	}
+
+	@Test
+	public void testSCard() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 4l })})).when(nativeConnection).closePipeline();
+		super.testSCard();
+	}
+
+	@Test
+	public void testSDiffBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { bytesSet })})).when(nativeConnection).closePipeline();
+		super.testSDiffBytes();
+	}
+
+	@Test
+	public void testSDiff() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { bytesSet })})).when(nativeConnection).closePipeline();
+		super.testSDiff();
+	}
+
+	@Test
+	public void testSDiffStoreBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 3l })})).when(nativeConnection).closePipeline();
+		super.testSDiffStoreBytes();
+	}
+
+	@Test
+	public void testSDiffStore() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 3l })})).when(nativeConnection).closePipeline();
+		super.testSDiffStore();
+	}
+
+	@Test
+	public void testSetNXBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { true })})).when(nativeConnection).closePipeline();
+		super.testSetNXBytes();
+	}
+
+	@Test
+	public void testSetNX() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { true })})).when(nativeConnection).closePipeline();
+		super.testSetNX();
+	}
+
+	@Test
+	public void testSInterBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { bytesSet })})).when(nativeConnection).closePipeline();
+		super.testSInterBytes();
+	}
+
+	@Test
+	public void testSInter() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { bytesSet })})).when(nativeConnection).closePipeline();
+		super.testSInter();
+	}
+
+	@Test
+	public void testSInterStoreBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 3l })})).when(nativeConnection).closePipeline();
+		super.testSInterStoreBytes();
+	}
+
+	@Test
+	public void testSInterStore() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 3l })})).when(nativeConnection).closePipeline();
+		super.testSInterStore();
+	}
+
+	@Test
+	public void testSIsMemberBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { true })})).when(nativeConnection).closePipeline();
+		super.testSIsMemberBytes();
+	}
+
+	@Test
+	public void testSIsMember() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { true })})).when(nativeConnection).closePipeline();
+		super.testSIsMember();
+	}
+
+	@Test
+	public void testSMembersBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { bytesSet })})).when(nativeConnection).closePipeline();
+		super.testSMembersBytes();
+	}
+
+	@Test
+	public void testSMembers() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { bytesSet })})).when(nativeConnection).closePipeline();
+		super.testSMembers();
+	}
+
+	@Test
+	public void testSMoveBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { true })})).when(nativeConnection).closePipeline();
+		super.testSMoveBytes();
+	}
+
+	@Test
+	public void testSMove() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { true })})).when(nativeConnection).closePipeline();
+		super.testSMove();
+	}
+
+	@Test
+	public void testSortStoreBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 3l })})).when(nativeConnection).closePipeline();
+		super.testSortStoreBytes();
+	}
+
+	@Test
+	public void testSortStore() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 3l })})).when(nativeConnection).closePipeline();
+		super.testSortStore();
+	}
+
+	@Test
+	public void testSortBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { bytesList })})).when(nativeConnection).closePipeline();
+		super.testSortBytes();
+	}
+
+	@Test
+	public void testSort() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { bytesList })})).when(nativeConnection).closePipeline();
+		super.testSort();
+	}
+
+	@Test
+	public void testSPopBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { barBytes })})).when(nativeConnection).closePipeline();
+		super.testSPopBytes();
+	}
+
+	@Test
+	public void testSPop() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { barBytes })})).when(nativeConnection).closePipeline();
+		super.testSPop();
+	}
+
+	@Test
+	public void testSRandMemberBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { barBytes })})).when(nativeConnection).closePipeline();
+		super.testSRandMemberBytes();
+	}
+
+	@Test
+	public void testSRandMember() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { barBytes })})).when(nativeConnection).closePipeline();
+		super.testSRandMember();
+	}
+
+	@Test
+	public void testSRandMemberCountBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { bytesList })})).when(nativeConnection).closePipeline();
+		super.testSRandMemberCountBytes();
+	}
+
+	@Test
+	public void testSRandMemberCount() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { bytesList })})).when(nativeConnection).closePipeline();
+		super.testSRandMemberCount();
+	}
+
+	@Test
+	public void testSRemBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { true })})).when(nativeConnection).closePipeline();
+		super.testSRemBytes();
+	}
+
+	@Test
+	public void testSRem() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { true })})).when(nativeConnection).closePipeline();
+		super.testSRem();
+	}
+
+	@Test
+	public void testStrLenBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 5l })})).when(nativeConnection).closePipeline();
+		super.testStrLenBytes();
+	}
+
+	@Test
+	public void testStrLen() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 5l })})).when(nativeConnection).closePipeline();
+		super.testStrLen();
+	}
+
+	@Test
+	public void testBitCountBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 5l })})).when(nativeConnection).closePipeline();
+		super.testBitCountBytes();
+	}
+
+	@Test
+	public void testBitCount() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 5l })})).when(nativeConnection).closePipeline();
+		super.testBitCount();
+	}
+
+	@Test
+	public void testBitCountRangeBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 5l })})).when(nativeConnection).closePipeline();
+		super.testBitCountRangeBytes();
+	}
+
+	@Test
+	public void testBitCountRange() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 5l })})).when(nativeConnection).closePipeline();
+		super.testBitCountRange();
+	}
+
+	@Test
+	public void testBitOpBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 5l })})).when(nativeConnection).closePipeline();
+		super.testBitOpBytes();
+	}
+
+	@Test
+	public void testBitOp() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 5l })})).when(nativeConnection).closePipeline();
+		super.testBitOp();
+	}
+
+	@Test
+	public void testSUnionBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { bytesSet })})).when(nativeConnection).closePipeline();
+		super.testSUnionBytes();
+	}
+
+	@Test
+	public void testSUnion() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { bytesSet })})).when(nativeConnection).closePipeline();
+		super.testSUnion();
+	}
+
+	@Test
+	public void testSUnionStoreBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 5l })})).when(nativeConnection).closePipeline();
+		super.testSUnionStoreBytes();
+	}
+
+	@Test
+	public void testSUnionStore() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 5l })})).when(nativeConnection).closePipeline();
+		super.testSUnionStore();
+	}
+
+	@Test
+	public void testTtlBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 5l })})).when(nativeConnection).closePipeline();
+		super.testTtlBytes();
+	}
+
+	@Test
+	public void testTtl() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 5l })})).when(nativeConnection).closePipeline();
+		super.testTtl();
+	}
+
+	@Test
+	public void testTypeBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { DataType.HASH })})).when(nativeConnection)
+				.closePipeline();
+		super.testTypeBytes();
+	}
+
+	@Test
+	public void testType() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { DataType.HASH })})).when(nativeConnection)
+				.closePipeline();
+		super.testType();
+	}
+
+	@Test
+	public void testZAddBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { true })})).when(nativeConnection).closePipeline();
+		super.testZAddBytes();
+	}
+
+	@Test
+	public void testZAdd() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { true })})).when(nativeConnection).closePipeline();
+		super.testZAdd();
+	}
+
+	@Test
+	public void testZCardBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 5l })})).when(nativeConnection).closePipeline();
+		super.testZCardBytes();
+	}
+
+	@Test
+	public void testZCard() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 5l })})).when(nativeConnection).closePipeline();
+		super.testZCard();
+	}
+
+	@Test
+	public void testZCountBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 5l })})).when(nativeConnection).closePipeline();
+		super.testZCountBytes();
+	}
+
+	@Test
+	public void testZCount() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 5l })})).when(nativeConnection).closePipeline();
+		super.testZCount();
+	}
+
+	@Test
+	public void testZIncrByBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 3d })})).when(nativeConnection).closePipeline();
+		super.testZIncrByBytes();
+	}
+
+	@Test
+	public void testZIncrBy() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 3d })})).when(nativeConnection).closePipeline();
+		super.testZIncrBy();
+	}
+
+	@Test
+	public void testZInterStoreAggWeightsBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 5l })})).when(nativeConnection).closePipeline();
+		super.testZInterStoreAggWeightsBytes();
+	}
+
+	@Test
+	public void testZInterStoreAggWeights() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 5l })})).when(nativeConnection).closePipeline();
+		super.testZInterStoreAggWeights();
+	}
+
+	@Test
+	public void testZInterStoreBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 5l })})).when(nativeConnection).closePipeline();
+		super.testZInterStoreBytes();
+	}
+
+	@Test
+	public void testZInterStore() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 5l })})).when(nativeConnection).closePipeline();
+		super.testZInterStore();
+	}
+
+	@Test
+	public void testZRangeBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { bytesSet })})).when(nativeConnection).closePipeline();
+		super.testZRangeBytes();
+	}
+
+	@Test
+	public void testZRange() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { bytesSet })})).when(nativeConnection).closePipeline();
+		super.testZRange();
+	}
+
+	@Test
+	public void testZRangeByScoreOffsetCountBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { bytesSet })})).when(nativeConnection).closePipeline();
+		super.testZRangeByScoreOffsetCountBytes();
+	}
+
+	@Test
+	public void testZRangeByScoreOffsetCount() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { bytesSet })})).when(nativeConnection).closePipeline();
+		super.testZRangeByScoreOffsetCount();
+	}
+
+	@Test
+	public void testZRangeByScoreBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { bytesSet })})).when(nativeConnection).closePipeline();
+		super.testZRangeByScoreBytes();
+	}
+
+	@Test
+	public void testZRangeByScore() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { bytesSet })})).when(nativeConnection).closePipeline();
+		super.testZRangeByScore();
+	}
+
+	@Test
+	public void testZRangeByScoreWithScoresOffsetCountBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { tupleSet })})).when(nativeConnection).closePipeline();
+		super.testZRangeByScoreWithScoresOffsetCountBytes();
+	}
+
+	@Test
+	public void testZRangeByScoreWithScoresOffsetCount() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { tupleSet })})).when(nativeConnection).closePipeline();
+		super.testZRangeByScoreWithScoresOffsetCount();
+	}
+
+	@Test
+	public void testZRangeByScoreWithScoresBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { tupleSet })})).when(nativeConnection).closePipeline();
+		super.testZRangeByScoreWithScoresBytes();
+	}
+
+	@Test
+	public void testZRangeByScoreWithScores() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { tupleSet })})).when(nativeConnection).closePipeline();
+		super.testZRangeByScoreWithScores();
+	}
+
+	@Test
+	public void testZRangeWithScoresBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { tupleSet })})).when(nativeConnection).closePipeline();
+		super.testZRangeWithScoresBytes();
+	}
+
+	@Test
+	public void testZRangeWithScores() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { tupleSet })})).when(nativeConnection).closePipeline();
+		super.testZRangeWithScores();
+	}
+
+	@Test
+	public void testZRevRangeByScoreOffsetCountBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { bytesSet })})).when(nativeConnection).closePipeline();
+		super.testZRevRangeByScoreOffsetCountBytes();
+	}
+
+	@Test
+	public void testZRevRangeByScoreOffsetCount() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { bytesSet })})).when(nativeConnection).closePipeline();
+		super.testZRevRangeByScoreOffsetCount();
+	}
+
+	@Test
+	public void testZRevRangeByScoreBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { bytesSet })})).when(nativeConnection).closePipeline();
+		super.testZRevRangeByScoreBytes();
+	}
+
+	@Test
+	public void testZRevRangeByScore() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { bytesSet })})).when(nativeConnection).closePipeline();
+		super.testZRevRangeByScore();
+	}
+
+	@Test
+	public void testZRevRangeByScoreWithScoresOffsetCountBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { tupleSet })})).when(nativeConnection).closePipeline();
+		super.testZRevRangeByScoreWithScoresOffsetCountBytes();
+	}
+
+	@Test
+	public void testZRevRangeByScoreWithScoresOffsetCount() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { tupleSet })})).when(nativeConnection).closePipeline();
+		super.testZRevRangeByScoreWithScoresOffsetCount();
+	}
+
+	@Test
+	public void testZRevRangeByScoreWithScoresBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { tupleSet })})).when(nativeConnection).closePipeline();
+		super.testZRevRangeByScoreWithScoresBytes();
+	}
+
+	@Test
+	public void testZRevRangeByScoreWithScores() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { tupleSet })})).when(nativeConnection).closePipeline();
+		super.testZRevRangeByScoreWithScores();
+	}
+
+	@Test
+	public void testZRankBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 5l })})).when(nativeConnection).closePipeline();
+		super.testZRankBytes();
+	}
+
+	@Test
+	public void testZRank() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 5l })})).when(nativeConnection).closePipeline();
+		super.testZRank();
+	}
+
+	@Test
+	public void testZRemBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { true })})).when(nativeConnection).closePipeline();
+		super.testZRemBytes();
+	}
+
+	@Test
+	public void testZRem() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { true })})).when(nativeConnection).closePipeline();
+		super.testZRem();
+	}
+
+	@Test
+	public void testZRemRangeBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 5l })})).when(nativeConnection).closePipeline();
+		super.testZRemRangeBytes();
+	}
+
+	@Test
+	public void testZRemRange() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 5l })})).when(nativeConnection).closePipeline();
+		super.testZRemRange();
+	}
+
+	@Test
+	public void testZRemRangeByScoreBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 5l })})).when(nativeConnection).closePipeline();
+		super.testZRemRangeByScoreBytes();
+	}
+
+	@Test
+	public void testZRemRangeByScore() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 5l })})).when(nativeConnection).closePipeline();
+		super.testZRemRangeByScore();
+	}
+
+	@Test
+	public void testZRevRangeBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { bytesSet })})).when(nativeConnection).closePipeline();
+		super.testZRevRangeBytes();
+	}
+
+	@Test
+	public void testZRevRange() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { bytesSet })})).when(nativeConnection).closePipeline();
+		super.testZRevRange();
+	}
+
+	@Test
+	public void testZRevRangeWithScoresBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { tupleSet })})).when(nativeConnection).closePipeline();
+		super.testZRevRangeWithScoresBytes();
+	}
+
+	@Test
+	public void testZRevRangeWithScores() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { tupleSet })})).when(nativeConnection).closePipeline();
+		super.testZRevRangeWithScores();
+	}
+
+	@Test
+	public void testZRevRankBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 5l })})).when(nativeConnection).closePipeline();
+		super.testZRevRankBytes();
+	}
+
+	@Test
+	public void testZRevRank() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 5l })})).when(nativeConnection).closePipeline();
+		super.testZRevRank();
+	}
+
+	@Test
+	public void testZScoreBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 3d })})).when(nativeConnection).closePipeline();
+		super.testZScoreBytes();
+	}
+
+	@Test
+	public void testZScore() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 3d })})).when(nativeConnection).closePipeline();
+		super.testZScore();
+	}
+
+	@Test
+	public void testZUnionStoreAggWeightsBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 5l })})).when(nativeConnection).closePipeline();
+		super.testZUnionStoreAggWeightsBytes();
+	}
+
+	@Test
+	public void testZUnionStoreAggWeights() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 5l })})).when(nativeConnection).closePipeline();
+		super.testZUnionStoreAggWeights();
+	}
+
+	@Test
+	public void testZUnionStoreBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 5l })})).when(nativeConnection).closePipeline();
+		super.testZUnionStoreBytes();
+	}
+
+	@Test
+	public void testZUnionStore() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 5l })})).when(nativeConnection).closePipeline();
+		super.testZUnionStore();
+	}
+
+	@Test
+	public void testPExpireBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { true })})).when(nativeConnection).closePipeline();
+		super.testPExpireBytes();
+	}
+
+	@Test
+	public void testPExpire() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { true })})).when(nativeConnection).closePipeline();
+		super.testPExpire();
+	}
+
+	@Test
+	public void testPExpireAtBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { true })})).when(nativeConnection).closePipeline();
+		super.testPExpireAtBytes();
+	}
+
+	@Test
+	public void testPExpireAt() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { true })})).when(nativeConnection).closePipeline();
+		super.testPExpireAt();
+	}
+
+	@Test
+	public void testPTtlBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 5l })})).when(nativeConnection).closePipeline();
+		super.testPTtlBytes();
+	}
+
+	@Test
+	public void testPTtl() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { 5l })})).when(nativeConnection).closePipeline();
+		super.testPTtl();
+	}
+
+	@Test
+	public void testDump() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { barBytes })})).when(nativeConnection).closePipeline();
+		super.testDump();
+	}
+
+	@Test
+	public void testScriptLoadBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { "foo" })})).when(nativeConnection).closePipeline();
+		super.testScriptLoadBytes();
+	}
+
+	@Test
+	public void testScriptLoad() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { "foo" })})).when(nativeConnection).closePipeline();
+		super.testScriptLoad();
+	}
+
+	@Test
+	public void testScriptExists() {
+		List<Boolean> results = Collections.singletonList(true);
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { results })})).when(nativeConnection).closePipeline();
+		super.testScriptExists();
+	}
+
+	@Test
+	public void testEvalBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { "foo" })})).when(nativeConnection).closePipeline();
+		super.testEvalBytes();
+	}
+
+	@Test
+	public void testEval() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { "foo" })})).when(nativeConnection).closePipeline();
+		super.testEval();
+	}
+
+	@Test
+	public void testEvalShaBytes() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { "foo" })})).when(nativeConnection).closePipeline();
+		super.testEvalShaBytes();
+	}
+
+	@Test
+	public void testEvalSha() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { "foo" })})).when(nativeConnection).closePipeline();
+		super.testEvalSha();
+	}
+
+	@Test
+	public void testExecute() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { "foo" })})).when(nativeConnection).closePipeline();
+		super.testExecute();
+	}
+
+	@Test
+	public void testExecuteByteArgs() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { "foo" })})).when(nativeConnection).closePipeline();
+		super.testExecuteByteArgs();
+	}
+
+	@Test
+	public void testExecuteStringArgs() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { "foo" })})).when(nativeConnection).closePipeline();
+		super.testExecuteStringArgs();
+	}
+
+	@Test
+	public void testTxResultsNotSameSizeAsResults() {
+		// Only call one method, but return 2 results from nativeConnection.exec()
+		// Emulates scenario where user has called some methods directly on the native connection
+		// while tx is open
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { barBytes, 3l })})).when(nativeConnection).closePipeline();
+		doReturn(barBytes).when(nativeConnection).get(fooBytes);
+		connection.get(foo);
+		verifyResults(Arrays.asList(new Object[] { barBytes, 3l }));
+	}
+
+	@Test
+	public void testTwoTxs() {
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { barBytes }),
+				Arrays.asList(new Object[] { fooBytes })})).when(nativeConnection).closePipeline();
+		connection.get(foo);
+		connection.exec();
+		connection.get(bar);
+		connection.exec();
+		List<Object> results =  connection.closePipeline();
+		assertEquals(Arrays.asList(new Object[] {Arrays.asList(new Object[] { bar }),
+				Arrays.asList(new Object[] { foo })}), results);
+	}
+
+	@SuppressWarnings("unchecked")
+	protected List<Object> getResults() {
+		connection.exec();
+		List<Object> txResults = (List<Object>) connection.closePipeline().get(0);
+		return txResults;
+	}
+}
diff --git a/src/test/java/org/springframework/data/redis/connection/DefaultStringRedisConnectionTests.java b/src/test/java/org/springframework/data/redis/connection/DefaultStringRedisConnectionTests.java
index 401870b9e..d131a37da 100644
--- a/src/test/java/org/springframework/data/redis/connection/DefaultStringRedisConnectionTests.java
+++ b/src/test/java/org/springframework/data/redis/connection/DefaultStringRedisConnectionTests.java
@@ -211,14 +211,6 @@ public class DefaultStringRedisConnectionTests {
 		verifyResults(Arrays.asList(new Object[] { bar }));
 	}
 
-	@Test
-	public void testExec() {
-		List<Object> results = Arrays.asList(new Object[] { barBytes });
-		doReturn(results).when(nativeConnection).exec();
-		actual.add(connection.exec());
-		verifyResults(Arrays.asList(new Object[] { results }));
-	}
-
 	@Test
 	public void testExistsBytes() {
 		doReturn(true).when(nativeConnection).exists(fooBytes);
diff --git a/src/test/java/org/springframework/data/redis/connection/DefaultStringRedisConnectionTxTests.java b/src/test/java/org/springframework/data/redis/connection/DefaultStringRedisConnectionTxTests.java
new file mode 100644
index 000000000..1bfd0d76d
--- /dev/null
+++ b/src/test/java/org/springframework/data/redis/connection/DefaultStringRedisConnectionTxTests.java
@@ -0,0 +1,1406 @@
+package org.springframework.data.redis.connection;
+
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.when;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Properties;
+
+import org.junit.Before;
+import org.junit.Test;
+
+public class DefaultStringRedisConnectionTxTests extends DefaultStringRedisConnectionTests {
+
+	@Before
+	public void setUp() {
+		super.setUp();
+		when(nativeConnection.isQueueing()).thenReturn(true);
+	}
+
+	@Test
+	public void testAppend() {
+		doReturn(Arrays.asList(new Object[] { 1l })).when(nativeConnection).exec();
+		super.testAppend();
+	}
+
+	@Test
+	public void testAppendBytes() {
+		doReturn(Arrays.asList(new Object[] { 1l })).when(nativeConnection).exec();
+		super.testAppendBytes();
+	}
+
+	@Test
+	public void testBlPopBytes() {
+		doReturn(Arrays.asList(new Object[] { bytesList })).when(nativeConnection).exec();
+		super.testBlPopBytes();
+	}
+
+	@Test
+	public void testBlPop() {
+		doReturn(Arrays.asList(new Object[] { bytesList })).when(nativeConnection).exec();
+		super.testBlPop();
+	}
+
+	@Test
+	public void testBrPopBytes() {
+		doReturn(Arrays.asList(new Object[] { bytesList })).when(nativeConnection).exec();
+		super.testBrPopBytes();
+	}
+
+	@Test
+	public void testBrPop() {
+		doReturn(Arrays.asList(new Object[] { bytesList })).when(nativeConnection).exec();
+		super.testBrPop();
+	}
+
+	@Test
+	public void testBrPopLPushBytes() {
+		doReturn(Arrays.asList(new Object[] { barBytes })).when(nativeConnection).exec();
+		super.testBrPopLPushBytes();
+	}
+
+	@Test
+	public void testBrPopLPush() {
+		doReturn(Arrays.asList(new Object[] { barBytes })).when(nativeConnection).exec();
+		super.testBrPopLPush();
+	}
+
+	@Test
+	public void testDbSize() {
+		doReturn(Arrays.asList(new Object[] { 3l })).when(nativeConnection).exec();
+		super.testDbSize();
+	}
+
+	@Test
+	public void testDecrBytes() {
+		doReturn(Arrays.asList(new Object[] { 3l })).when(nativeConnection).exec();
+		super.testDecrBytes();
+	}
+
+	@Test
+	public void testDecr() {
+		doReturn(Arrays.asList(new Object[] { 3l })).when(nativeConnection).exec();
+		super.testDecr();
+	}
+
+	@Test
+	public void testDecrByBytes() {
+		doReturn(Arrays.asList(new Object[] { 3l })).when(nativeConnection).exec();
+		super.testDecrByBytes();
+	}
+
+	@Test
+	public void testDecrBy() {
+		doReturn(Arrays.asList(new Object[] { 3l })).when(nativeConnection).exec();
+		super.testDecrBy();
+	}
+
+	@Test
+	public void testDelBytes() {
+		doReturn(Arrays.asList(new Object[] { 1l })).when(nativeConnection).exec();
+		super.testDelBytes();
+	}
+
+	@Test
+	public void testDel() {
+		doReturn(Arrays.asList(new Object[] { 1l })).when(nativeConnection).exec();
+		super.testDel();
+	}
+
+	@Test
+	public void testEchoBytes() {
+		doReturn(Arrays.asList(new Object[] { barBytes })).when(nativeConnection).exec();
+		super.testEchoBytes();
+	}
+
+	@Test
+	public void testEcho() {
+		doReturn(Arrays.asList(new Object[] { barBytes })).when(nativeConnection).exec();
+		super.testEcho();
+	}
+
+	@Test
+	public void testExistsBytes() {
+		doReturn(Arrays.asList(new Object[] { true })).when(nativeConnection).exec();
+		super.testExistsBytes();
+	}
+
+	@Test
+	public void testExists() {
+		doReturn(Arrays.asList(new Object[] { true })).when(nativeConnection).exec();
+		super.testExists();
+	}
+
+	@Test
+	public void testExpireBytes() {
+		doReturn(Arrays.asList(new Object[] { true })).when(nativeConnection).exec();
+		super.testExpireBytes();
+	}
+
+	@Test
+	public void testExpire() {
+		doReturn(Arrays.asList(new Object[] { true })).when(nativeConnection).exec();
+		super.testExpire();
+	}
+
+	@Test
+	public void testExpireAtBytes() {
+		doReturn(Arrays.asList(new Object[] { true })).when(nativeConnection).exec();
+		super.testExpireAtBytes();
+	}
+
+	@Test
+	public void testExpireAt() {
+		doReturn(Arrays.asList(new Object[] { true })).when(nativeConnection).exec();
+		super.testExpireAt();
+	}
+
+	@Test
+	public void testGetBytes() {
+		doReturn(Arrays.asList(new Object[] { barBytes })).when(nativeConnection).exec();
+		super.testGetBytes();
+	}
+
+	@Test
+	public void testGet() {
+		doReturn(Arrays.asList(new Object[] { barBytes })).when(nativeConnection).exec();
+		super.testGet();
+	}
+
+	@Test
+	public void testGetBitBytes() {
+		doReturn(Arrays.asList(new Object[] { true })).when(nativeConnection).exec();
+		super.testGetBitBytes();
+	}
+
+	@Test
+	public void testGetBit() {
+		doReturn(Arrays.asList(new Object[] { true })).when(nativeConnection).exec();
+		super.testGetBit();
+	}
+
+	@Test
+	public void testGetConfig() {
+		List<String> results = Collections.singletonList("bar");
+		doReturn(Arrays.asList(new Object[] { results })).when(nativeConnection).exec();
+		super.testGetConfig();
+	}
+
+	@Test
+	public void testGetNativeConnection() {
+		doReturn(Arrays.asList(new Object[] { "foo" })).when(nativeConnection).exec();
+		super.testGetNativeConnection();
+	}
+
+	@Test
+	public void testGetRangeBytes() {
+		doReturn(Arrays.asList(new Object[] { barBytes })).when(nativeConnection).exec();
+		super.testGetRangeBytes();
+	}
+
+	@Test
+	public void testGetRange() {
+		doReturn(Arrays.asList(new Object[] { barBytes })).when(nativeConnection).exec();
+		super.testGetRange();
+	}
+
+	@Test
+	public void testGetSetBytes() {
+		doReturn(Arrays.asList(new Object[] { barBytes })).when(nativeConnection).exec();
+		super.testGetSetBytes();
+	}
+
+	@Test
+	public void testGetSet() {
+		doReturn(Arrays.asList(new Object[] { barBytes })).when(nativeConnection).exec();
+		super.testGetSet();
+	}
+
+	@Test
+	public void testHDelBytes() {
+		doReturn(Arrays.asList(new Object[] { true })).when(nativeConnection).exec();
+		super.testHDelBytes();
+	}
+
+	@Test
+	public void testHDel() {
+		doReturn(Arrays.asList(new Object[] { true })).when(nativeConnection).exec();
+		super.testHDel();
+	}
+
+	@Test
+	public void testHExistsBytes() {
+		doReturn(Arrays.asList(new Object[] { true })).when(nativeConnection).exec();
+		super.testHExistsBytes();
+	}
+
+	@Test
+	public void testHExists() {
+		doReturn(Arrays.asList(new Object[] { true })).when(nativeConnection).exec();
+		super.testHExists();
+	}
+
+	@Test
+	public void testHGetBytes() {
+		doReturn(Arrays.asList(new Object[] { barBytes })).when(nativeConnection).exec();
+		super.testHGetBytes();
+	}
+
+	@Test
+	public void testHGet() {
+		doReturn(Arrays.asList(new Object[] { barBytes })).when(nativeConnection).exec();
+		super.testHGet();
+	}
+
+	@Test
+	public void testHGetAllBytes() {
+		doReturn(Arrays.asList(new Object[] { bytesMap })).when(nativeConnection).exec();
+		super.testHGetAllBytes();
+	}
+
+	@Test
+	public void testHGetAll() {
+		doReturn(Arrays.asList(new Object[] { bytesMap })).when(nativeConnection).exec();
+		super.testHGetAll();
+	}
+
+	@Test
+	public void testHIncrByBytes() {
+		doReturn(Arrays.asList(new Object[] { 3l })).when(nativeConnection).exec();
+		super.testHIncrByBytes();
+	}
+
+	@Test
+	public void testHIncrBy() {
+		doReturn(Arrays.asList(new Object[] { 3l })).when(nativeConnection).exec();
+		super.testHIncrBy();
+	}
+
+	@Test
+	public void testHIncrByDoubleBytes() {
+		doReturn(Arrays.asList(new Object[] { 3d })).when(nativeConnection).exec();
+		super.testHIncrByDoubleBytes();
+	}
+
+	@Test
+	public void testHIncrByDouble() {
+		doReturn(Arrays.asList(new Object[] { 3d })).when(nativeConnection).exec();
+		super.testHIncrByDouble();
+	}
+
+	@Test
+	public void testHKeysBytes() {
+		doReturn(Arrays.asList(new Object[] { bytesSet })).when(nativeConnection).exec();
+		super.testHKeysBytes();
+	}
+
+	@Test
+	public void testHKeys() {
+		doReturn(Arrays.asList(new Object[] { bytesSet })).when(nativeConnection).exec();
+		super.testHKeys();
+	}
+
+	@Test
+	public void testHLenBytes() {
+		doReturn(Arrays.asList(new Object[] { 3l })).when(nativeConnection).exec();
+		super.testHLenBytes();
+	}
+
+	@Test
+	public void testHLen() {
+		doReturn(Arrays.asList(new Object[] { 3l })).when(nativeConnection).exec();
+		super.testHLen();
+	}
+
+	@Test
+	public void testHMGetBytes() {
+		doReturn(Arrays.asList(new Object[] { bytesList })).when(nativeConnection).exec();
+		super.testHMGetBytes();
+	}
+
+	@Test
+	public void testHMGet() {
+		doReturn(Arrays.asList(new Object[] { bytesList })).when(nativeConnection).exec();
+		super.testHMGet();
+	}
+
+	@Test
+	public void testHSetBytes() {
+		doReturn(Arrays.asList(new Object[] { true })).when(nativeConnection).exec();
+		super.testHSetBytes();
+	}
+
+	@Test
+	public void testHSet() {
+		doReturn(Arrays.asList(new Object[] { true })).when(nativeConnection).exec();
+		super.testHSet();
+	}
+
+	@Test
+	public void testHSetNXBytes() {
+		doReturn(Arrays.asList(new Object[] { true })).when(nativeConnection).exec();
+		super.testHSetNXBytes();
+	}
+
+	@Test
+	public void testHSetNX() {
+		doReturn(Arrays.asList(new Object[] { true })).when(nativeConnection).exec();
+		super.testHSetNX();
+	}
+
+	@Test
+	public void testHValsBytes() {
+		doReturn(Arrays.asList(new Object[] { bytesList })).when(nativeConnection).exec();
+		super.testHValsBytes();
+	}
+
+	@Test
+	public void testHVals() {
+		doReturn(Arrays.asList(new Object[] { bytesList })).when(nativeConnection).exec();
+		super.testHVals();
+	}
+
+	@Test
+	public void testIncrBytes() {
+		doReturn(Arrays.asList(new Object[] { 2l })).when(nativeConnection).exec();
+		super.testIncrBytes();
+	}
+
+	@Test
+	public void testIncr() {
+		doReturn(Arrays.asList(new Object[] { 2l })).when(nativeConnection).exec();
+		super.testIncr();
+	}
+
+	@Test
+	public void testIncrByBytes() {
+		doReturn(Arrays.asList(new Object[] { 2l })).when(nativeConnection).exec();
+		super.testIncrByBytes();
+	}
+
+	@Test
+	public void testIncrBy() {
+		doReturn(Arrays.asList(new Object[] { 2l })).when(nativeConnection).exec();
+		super.testIncrBy();
+	}
+
+	@Test
+	public void testIncrByDoubleBytes() {
+		doReturn(Arrays.asList(new Object[] { 2d })).when(nativeConnection).exec();
+		super.testIncrByDoubleBytes();
+	}
+
+	@Test
+	public void testIncrByDouble() {
+		doReturn(Arrays.asList(new Object[] { 2d })).when(nativeConnection).exec();
+		super.testIncrByDouble();
+	}
+
+	@Test
+	public void testInfo() {
+		Properties props = new Properties();
+		props.put("foo", "bar");
+		doReturn(Arrays.asList(new Object[] { props })).when(nativeConnection).exec();
+		super.testInfo();
+	}
+
+	@Test
+	public void testInfoBySection() {
+		Properties props = new Properties();
+		props.put("foo", "bar");
+		doReturn(Arrays.asList(new Object[] { props })).when(nativeConnection).exec();
+		super.testInfoBySection();
+	}
+
+	@Test
+	public void testKeysBytes() {
+		doReturn(Arrays.asList(new Object[] { bytesSet })).when(nativeConnection).exec();
+		super.testKeysBytes();
+	}
+
+	@Test
+	public void testKeys() {
+		doReturn(Arrays.asList(new Object[] { bytesSet })).when(nativeConnection).exec();
+		super.testKeys();
+	}
+
+	@Test
+	public void testLastSave() {
+		doReturn(Arrays.asList(new Object[] { 6l })).when(nativeConnection).exec();
+		super.testLastSave();
+	}
+
+	@Test
+	public void testLIndexBytes() {
+		doReturn(Arrays.asList(new Object[] { barBytes })).when(nativeConnection).exec();
+		super.testLIndexBytes();
+	}
+
+	@Test
+	public void testLIndex() {
+		doReturn(Arrays.asList(new Object[] { barBytes })).when(nativeConnection).exec();
+		super.testLIndex();
+	}
+
+	@Test
+	public void testLInsertBytes() {
+		doReturn(Arrays.asList(new Object[] { 8l })).when(nativeConnection).exec();
+		super.testLInsertBytes();
+	}
+
+	@Test
+	public void testLInsert() {
+		doReturn(Arrays.asList(new Object[] { 8l })).when(nativeConnection).exec();
+		super.testLInsert();
+	}
+
+	@Test
+	public void testLLenBytes() {
+		doReturn(Arrays.asList(new Object[] { 8l })).when(nativeConnection).exec();
+		super.testLLenBytes();
+	}
+
+	@Test
+	public void testLLen() {
+		doReturn(Arrays.asList(new Object[] { 8l })).when(nativeConnection).exec();
+		super.testLLen();
+	}
+
+	@Test
+	public void testLPopBytes() {
+		doReturn(Arrays.asList(new Object[] { barBytes })).when(nativeConnection).exec();
+		actual.add(connection.lPop(fooBytes));
+		verifyResults(Arrays.asList(new Object[] { barBytes }));
+	}
+
+	@Test
+	public void testLPop() {
+		doReturn(Arrays.asList(new Object[] { barBytes })).when(nativeConnection).exec();
+		super.testLPop();
+	}
+
+	@Test
+	public void testLPushBytes() {
+		doReturn(Arrays.asList(new Object[] { 8l })).when(nativeConnection).exec();
+		super.testLPushBytes();
+	}
+
+	@Test
+	public void testLPush() {
+		doReturn(Arrays.asList(new Object[] { 8l })).when(nativeConnection).exec();
+		super.testLPush();
+	}
+
+	@Test
+	public void testLPushXBytes() {
+		doReturn(Arrays.asList(new Object[] { 8l })).when(nativeConnection).exec();
+		super.testLPushXBytes();
+	}
+
+	@Test
+	public void testLPushX() {
+		doReturn(Arrays.asList(new Object[] { 8l })).when(nativeConnection).exec();
+		super.testLPushX();
+	}
+
+	@Test
+	public void testLRangeBytes() {
+		doReturn(Arrays.asList(new Object[] { bytesList })).when(nativeConnection).exec();
+		super.testLRangeBytes();
+	}
+
+	@Test
+	public void testLRange() {
+		doReturn(Arrays.asList(new Object[] { bytesList })).when(nativeConnection).exec();
+		super.testLRange();
+	}
+
+	@Test
+	public void testLRemBytes() {
+		doReturn(Arrays.asList(new Object[] { 8l })).when(nativeConnection).exec();
+		super.testLRemBytes();
+	}
+
+	@Test
+	public void testLRem() {
+		doReturn(Arrays.asList(new Object[] { 8l })).when(nativeConnection).exec();
+		super.testLRem();
+	}
+
+	@Test
+	public void testMGetBytes() {
+		doReturn(Arrays.asList(new Object[] { bytesList })).when(nativeConnection).exec();
+		super.testMGetBytes();
+	}
+
+	@Test
+	public void testMGet() {
+		doReturn(Arrays.asList(new Object[] { bytesList })).when(nativeConnection).exec();
+		super.testMGet();
+	}
+
+	@Test
+	public void testMSetNXBytes() {
+		doReturn(Arrays.asList(new Object[] { true })).when(nativeConnection).exec();
+		super.testMSetNXBytes();
+	}
+
+	@Test
+	public void testMSetNXString() {
+		doReturn(Arrays.asList(new Object[] { true })).when(nativeConnection).exec();
+		super.testMSetNXString();
+	}
+
+	@Test
+	public void testPersistBytes() {
+		doReturn(Arrays.asList(new Object[] { true })).when(nativeConnection).exec();
+		super.testPersistBytes();
+	}
+
+	@Test
+	public void testPersist() {
+		doReturn(Arrays.asList(new Object[] { true })).when(nativeConnection).exec();
+		super.testPersist();
+	}
+
+	@Test
+	public void testMoveBytes() {
+		doReturn(Arrays.asList(new Object[] { true })).when(nativeConnection).exec();
+		super.testMoveBytes();
+	}
+
+	@Test
+	public void testMove() {
+		doReturn(Arrays.asList(new Object[] { true })).when(nativeConnection).exec();
+		super.testMove();
+	}
+
+	@Test
+	public void testPing() {
+		doReturn(Arrays.asList(new Object[] { "pong" })).when(nativeConnection).exec();
+		super.testPing();
+	}
+
+	@Test
+	public void testPublishBytes() {
+		doReturn(Arrays.asList(new Object[] { 2l })).when(nativeConnection).exec();
+		super.testPublishBytes();
+	}
+
+	@Test
+	public void testPublish() {
+		doReturn(Arrays.asList(new Object[] { 2l })).when(nativeConnection).exec();
+		super.testPublish();
+	}
+
+	@Test
+	public void testRandomKey() {
+		doReturn(Arrays.asList(new Object[] { fooBytes })).when(nativeConnection).exec();
+		super.testRandomKey();
+	}
+
+	@Test
+	public void testRenameNXBytes() {
+		doReturn(Arrays.asList(new Object[] { true })).when(nativeConnection).exec();
+		super.testRenameNXBytes();
+	}
+
+	@Test
+	public void testRenameNX() {
+		doReturn(Arrays.asList(new Object[] { true })).when(nativeConnection).exec();
+		super.testRenameNX();
+	}
+
+	@Test
+	public void testRPopBytes() {
+		doReturn(Arrays.asList(new Object[] { barBytes })).when(nativeConnection).exec();
+		super.testRPopBytes();
+	}
+
+	@Test
+	public void testRPop() {
+		doReturn(Arrays.asList(new Object[] { barBytes })).when(nativeConnection).exec();
+		super.testRPop();
+	}
+
+	@Test
+	public void testRPopLPushBytes() {
+		doReturn(Arrays.asList(new Object[] { barBytes })).when(nativeConnection).exec();
+		super.testRPopLPushBytes();
+	}
+
+	@Test
+	public void testRPopLPush() {
+		doReturn(Arrays.asList(new Object[] { barBytes })).when(nativeConnection).exec();
+		super.testRPopLPush();
+	}
+
+	@Test
+	public void testRPushBytes() {
+		doReturn(Arrays.asList(new Object[] { 4l })).when(nativeConnection).exec();
+		super.testRPushBytes();
+	}
+
+	@Test
+	public void testRPush() {
+		doReturn(Arrays.asList(new Object[] { 4l })).when(nativeConnection).exec();
+		super.testRPush();
+	}
+
+	@Test
+	public void testRPushXBytes() {
+		doReturn(Arrays.asList(new Object[] { 4l })).when(nativeConnection).exec();
+		super.testRPushXBytes();
+	}
+
+	@Test
+	public void testRPushX() {
+		doReturn(Arrays.asList(new Object[] { 4l })).when(nativeConnection).exec();
+		super.testRPushX();
+	}
+
+	@Test
+	public void testSAddBytes() {
+		doReturn(Arrays.asList(new Object[] { true })).when(nativeConnection).exec();
+		super.testSAddBytes();
+	}
+
+	@Test
+	public void testSAdd() {
+		doReturn(Arrays.asList(new Object[] { true })).when(nativeConnection).exec();
+		super.testSAdd();
+	}
+
+	@Test
+	public void testSCardBytes() {
+		doReturn(Arrays.asList(new Object[] { 4l })).when(nativeConnection).exec();
+		super.testSCardBytes();
+	}
+
+	@Test
+	public void testSCard() {
+		doReturn(Arrays.asList(new Object[] { 4l })).when(nativeConnection).exec();
+		super.testSCard();
+	}
+
+	@Test
+	public void testSDiffBytes() {
+		doReturn(Arrays.asList(new Object[] { bytesSet })).when(nativeConnection).exec();
+		super.testSDiffBytes();
+	}
+
+	@Test
+	public void testSDiff() {
+		doReturn(Arrays.asList(new Object[] { bytesSet })).when(nativeConnection).exec();
+		super.testSDiff();
+	}
+
+	@Test
+	public void testSDiffStoreBytes() {
+		doReturn(Arrays.asList(new Object[] { 3l })).when(nativeConnection).exec();
+		super.testSDiffStoreBytes();
+	}
+
+	@Test
+	public void testSDiffStore() {
+		doReturn(Arrays.asList(new Object[] { 3l })).when(nativeConnection).exec();
+		super.testSDiffStore();
+	}
+
+	@Test
+	public void testSetNXBytes() {
+		doReturn(Arrays.asList(new Object[] { true })).when(nativeConnection).exec();
+		super.testSetNXBytes();
+	}
+
+	@Test
+	public void testSetNX() {
+		doReturn(Arrays.asList(new Object[] { true })).when(nativeConnection).exec();
+		super.testSetNX();
+	}
+
+	@Test
+	public void testSInterBytes() {
+		doReturn(Arrays.asList(new Object[] { bytesSet })).when(nativeConnection).exec();
+		super.testSInterBytes();
+	}
+
+	@Test
+	public void testSInter() {
+		doReturn(Arrays.asList(new Object[] { bytesSet })).when(nativeConnection).exec();
+		super.testSInter();
+	}
+
+	@Test
+	public void testSInterStoreBytes() {
+		doReturn(Arrays.asList(new Object[] { 3l })).when(nativeConnection).exec();
+		super.testSInterStoreBytes();
+	}
+
+	@Test
+	public void testSInterStore() {
+		doReturn(Arrays.asList(new Object[] { 3l })).when(nativeConnection).exec();
+		super.testSInterStore();
+	}
+
+	@Test
+	public void testSIsMemberBytes() {
+		doReturn(Arrays.asList(new Object[] { true })).when(nativeConnection).exec();
+		super.testSIsMemberBytes();
+	}
+
+	@Test
+	public void testSIsMember() {
+		doReturn(Arrays.asList(new Object[] { true })).when(nativeConnection).exec();
+		super.testSIsMember();
+	}
+
+	@Test
+	public void testSMembersBytes() {
+		doReturn(Arrays.asList(new Object[] { bytesSet })).when(nativeConnection).exec();
+		super.testSMembersBytes();
+	}
+
+	@Test
+	public void testSMembers() {
+		doReturn(Arrays.asList(new Object[] { bytesSet })).when(nativeConnection).exec();
+		super.testSMembers();
+	}
+
+	@Test
+	public void testSMoveBytes() {
+		doReturn(Arrays.asList(new Object[] { true })).when(nativeConnection).exec();
+		super.testSMoveBytes();
+	}
+
+	@Test
+	public void testSMove() {
+		doReturn(Arrays.asList(new Object[] { true })).when(nativeConnection).exec();
+		super.testSMove();
+	}
+
+	@Test
+	public void testSortStoreBytes() {
+		doReturn(Arrays.asList(new Object[] { 3l })).when(nativeConnection).exec();
+		super.testSortStoreBytes();
+	}
+
+	@Test
+	public void testSortStore() {
+		doReturn(Arrays.asList(new Object[] { 3l })).when(nativeConnection).exec();
+		super.testSortStore();
+	}
+
+	@Test
+	public void testSortBytes() {
+		doReturn(Arrays.asList(new Object[] { bytesList })).when(nativeConnection).exec();
+		super.testSortBytes();
+	}
+
+	@Test
+	public void testSort() {
+		doReturn(Arrays.asList(new Object[] { bytesList })).when(nativeConnection).exec();
+		super.testSort();
+	}
+
+	@Test
+	public void testSPopBytes() {
+		doReturn(Arrays.asList(new Object[] { barBytes })).when(nativeConnection).exec();
+		super.testSPopBytes();
+	}
+
+	@Test
+	public void testSPop() {
+		doReturn(Arrays.asList(new Object[] { barBytes })).when(nativeConnection).exec();
+		super.testSPop();
+	}
+
+	@Test
+	public void testSRandMemberBytes() {
+		doReturn(Arrays.asList(new Object[] { barBytes })).when(nativeConnection).exec();
+		super.testSRandMemberBytes();
+	}
+
+	@Test
+	public void testSRandMember() {
+		doReturn(Arrays.asList(new Object[] { barBytes })).when(nativeConnection).exec();
+		super.testSRandMember();
+	}
+
+	@Test
+	public void testSRandMemberCountBytes() {
+		doReturn(Arrays.asList(new Object[] { bytesList })).when(nativeConnection).exec();
+		super.testSRandMemberCountBytes();
+	}
+
+	@Test
+	public void testSRandMemberCount() {
+		doReturn(Arrays.asList(new Object[] { bytesList })).when(nativeConnection).exec();
+		super.testSRandMemberCount();
+	}
+
+	@Test
+	public void testSRemBytes() {
+		doReturn(Arrays.asList(new Object[] { true })).when(nativeConnection).exec();
+		super.testSRemBytes();
+	}
+
+	@Test
+	public void testSRem() {
+		doReturn(Arrays.asList(new Object[] { true })).when(nativeConnection).exec();
+		super.testSRem();
+	}
+
+	@Test
+	public void testStrLenBytes() {
+		doReturn(Arrays.asList(new Object[] { 5l })).when(nativeConnection).exec();
+		super.testStrLenBytes();
+	}
+
+	@Test
+	public void testStrLen() {
+		doReturn(Arrays.asList(new Object[] { 5l })).when(nativeConnection).exec();
+		super.testStrLen();
+	}
+
+	@Test
+	public void testBitCountBytes() {
+		doReturn(Arrays.asList(new Object[] { 5l })).when(nativeConnection).exec();
+		super.testBitCountBytes();
+	}
+
+	@Test
+	public void testBitCount() {
+		doReturn(Arrays.asList(new Object[] { 5l })).when(nativeConnection).exec();
+		super.testBitCount();
+	}
+
+	@Test
+	public void testBitCountRangeBytes() {
+		doReturn(Arrays.asList(new Object[] { 5l })).when(nativeConnection).exec();
+		super.testBitCountRangeBytes();
+	}
+
+	@Test
+	public void testBitCountRange() {
+		doReturn(Arrays.asList(new Object[] { 5l })).when(nativeConnection).exec();
+		super.testBitCountRange();
+	}
+
+	@Test
+	public void testBitOpBytes() {
+		doReturn(Arrays.asList(new Object[] { 5l })).when(nativeConnection).exec();
+		super.testBitOpBytes();
+	}
+
+	@Test
+	public void testBitOp() {
+		doReturn(Arrays.asList(new Object[] { 5l })).when(nativeConnection).exec();
+		super.testBitOp();
+	}
+
+	@Test
+	public void testSUnionBytes() {
+		doReturn(Arrays.asList(new Object[] { bytesSet })).when(nativeConnection).exec();
+		super.testSUnionBytes();
+	}
+
+	@Test
+	public void testSUnion() {
+		doReturn(Arrays.asList(new Object[] { bytesSet })).when(nativeConnection).exec();
+		super.testSUnion();
+	}
+
+	@Test
+	public void testSUnionStoreBytes() {
+		doReturn(Arrays.asList(new Object[] { 5l })).when(nativeConnection).exec();
+		super.testSUnionStoreBytes();
+	}
+
+	@Test
+	public void testSUnionStore() {
+		doReturn(Arrays.asList(new Object[] { 5l })).when(nativeConnection).exec();
+		super.testSUnionStore();
+	}
+
+	@Test
+	public void testTtlBytes() {
+		doReturn(Arrays.asList(new Object[] { 5l })).when(nativeConnection).exec();
+		super.testTtlBytes();
+	}
+
+	@Test
+	public void testTtl() {
+		doReturn(Arrays.asList(new Object[] { 5l })).when(nativeConnection).exec();
+		super.testTtl();
+	}
+
+	@Test
+	public void testTypeBytes() {
+		doReturn(Arrays.asList(new Object[] { DataType.HASH })).when(nativeConnection)
+				.exec();
+		super.testTypeBytes();
+	}
+
+	@Test
+	public void testType() {
+		doReturn(Arrays.asList(new Object[] { DataType.HASH })).when(nativeConnection)
+				.exec();
+		super.testType();
+	}
+
+	@Test
+	public void testZAddBytes() {
+		doReturn(Arrays.asList(new Object[] { true })).when(nativeConnection).exec();
+		super.testZAddBytes();
+	}
+
+	@Test
+	public void testZAdd() {
+		doReturn(Arrays.asList(new Object[] { true })).when(nativeConnection).exec();
+		super.testZAdd();
+	}
+
+	@Test
+	public void testZCardBytes() {
+		doReturn(Arrays.asList(new Object[] { 5l })).when(nativeConnection).exec();
+		super.testZCardBytes();
+	}
+
+	@Test
+	public void testZCard() {
+		doReturn(Arrays.asList(new Object[] { 5l })).when(nativeConnection).exec();
+		super.testZCard();
+	}
+
+	@Test
+	public void testZCountBytes() {
+		doReturn(Arrays.asList(new Object[] { 5l })).when(nativeConnection).exec();
+		super.testZCountBytes();
+	}
+
+	@Test
+	public void testZCount() {
+		doReturn(Arrays.asList(new Object[] { 5l })).when(nativeConnection).exec();
+		super.testZCount();
+	}
+
+	@Test
+	public void testZIncrByBytes() {
+		doReturn(Arrays.asList(new Object[] { 3d })).when(nativeConnection).exec();
+		super.testZIncrByBytes();
+	}
+
+	@Test
+	public void testZIncrBy() {
+		doReturn(Arrays.asList(new Object[] { 3d })).when(nativeConnection).exec();
+		super.testZIncrBy();
+	}
+
+	@Test
+	public void testZInterStoreAggWeightsBytes() {
+		doReturn(Arrays.asList(new Object[] { 5l })).when(nativeConnection).exec();
+		super.testZInterStoreAggWeightsBytes();
+	}
+
+	@Test
+	public void testZInterStoreAggWeights() {
+		doReturn(Arrays.asList(new Object[] { 5l })).when(nativeConnection).exec();
+		super.testZInterStoreAggWeights();
+	}
+
+	@Test
+	public void testZInterStoreBytes() {
+		doReturn(Arrays.asList(new Object[] { 5l })).when(nativeConnection).exec();
+		super.testZInterStoreBytes();
+	}
+
+	@Test
+	public void testZInterStore() {
+		doReturn(Arrays.asList(new Object[] { 5l })).when(nativeConnection).exec();
+		super.testZInterStore();
+	}
+
+	@Test
+	public void testZRangeBytes() {
+		doReturn(Arrays.asList(new Object[] { bytesSet })).when(nativeConnection).exec();
+		super.testZRangeBytes();
+	}
+
+	@Test
+	public void testZRange() {
+		doReturn(Arrays.asList(new Object[] { bytesSet })).when(nativeConnection).exec();
+		super.testZRange();
+	}
+
+	@Test
+	public void testZRangeByScoreOffsetCountBytes() {
+		doReturn(Arrays.asList(new Object[] { bytesSet })).when(nativeConnection).exec();
+		super.testZRangeByScoreOffsetCountBytes();
+	}
+
+	@Test
+	public void testZRangeByScoreOffsetCount() {
+		doReturn(Arrays.asList(new Object[] { bytesSet })).when(nativeConnection).exec();
+		super.testZRangeByScoreOffsetCount();
+	}
+
+	@Test
+	public void testZRangeByScoreBytes() {
+		doReturn(Arrays.asList(new Object[] { bytesSet })).when(nativeConnection).exec();
+		super.testZRangeByScoreBytes();
+	}
+
+	@Test
+	public void testZRangeByScore() {
+		doReturn(Arrays.asList(new Object[] { bytesSet })).when(nativeConnection).exec();
+		super.testZRangeByScore();
+	}
+
+	@Test
+	public void testZRangeByScoreWithScoresOffsetCountBytes() {
+		doReturn(Arrays.asList(new Object[] { tupleSet })).when(nativeConnection).exec();
+		super.testZRangeByScoreWithScoresOffsetCountBytes();
+	}
+
+	@Test
+	public void testZRangeByScoreWithScoresOffsetCount() {
+		doReturn(Arrays.asList(new Object[] { tupleSet })).when(nativeConnection).exec();
+		super.testZRangeByScoreWithScoresOffsetCount();
+	}
+
+	@Test
+	public void testZRangeByScoreWithScoresBytes() {
+		doReturn(Arrays.asList(new Object[] { tupleSet })).when(nativeConnection).exec();
+		super.testZRangeByScoreWithScoresBytes();
+	}
+
+	@Test
+	public void testZRangeByScoreWithScores() {
+		doReturn(Arrays.asList(new Object[] { tupleSet })).when(nativeConnection).exec();
+		super.testZRangeByScoreWithScores();
+	}
+
+	@Test
+	public void testZRangeWithScoresBytes() {
+		doReturn(Arrays.asList(new Object[] { tupleSet })).when(nativeConnection).exec();
+		super.testZRangeWithScoresBytes();
+	}
+
+	@Test
+	public void testZRangeWithScores() {
+		doReturn(Arrays.asList(new Object[] { tupleSet })).when(nativeConnection).exec();
+		super.testZRangeWithScores();
+	}
+
+	@Test
+	public void testZRevRangeByScoreOffsetCountBytes() {
+		doReturn(Arrays.asList(new Object[] { bytesSet })).when(nativeConnection).exec();
+		super.testZRevRangeByScoreOffsetCountBytes();
+	}
+
+	@Test
+	public void testZRevRangeByScoreOffsetCount() {
+		doReturn(Arrays.asList(new Object[] { bytesSet })).when(nativeConnection).exec();
+		super.testZRevRangeByScoreOffsetCount();
+	}
+
+	@Test
+	public void testZRevRangeByScoreBytes() {
+		doReturn(Arrays.asList(new Object[] { bytesSet })).when(nativeConnection).exec();
+		super.testZRevRangeByScoreBytes();
+	}
+
+	@Test
+	public void testZRevRangeByScore() {
+		doReturn(Arrays.asList(new Object[] { bytesSet })).when(nativeConnection).exec();
+		super.testZRevRangeByScore();
+	}
+
+	@Test
+	public void testZRevRangeByScoreWithScoresOffsetCountBytes() {
+		doReturn(Arrays.asList(new Object[] { tupleSet })).when(nativeConnection).exec();
+		super.testZRevRangeByScoreWithScoresOffsetCountBytes();
+	}
+
+	@Test
+	public void testZRevRangeByScoreWithScoresOffsetCount() {
+		doReturn(Arrays.asList(new Object[] { tupleSet })).when(nativeConnection).exec();
+		super.testZRevRangeByScoreWithScoresOffsetCount();
+	}
+
+	@Test
+	public void testZRevRangeByScoreWithScoresBytes() {
+		doReturn(Arrays.asList(new Object[] { tupleSet })).when(nativeConnection).exec();
+		super.testZRevRangeByScoreWithScoresBytes();
+	}
+
+	@Test
+	public void testZRevRangeByScoreWithScores() {
+		doReturn(Arrays.asList(new Object[] { tupleSet })).when(nativeConnection).exec();
+		super.testZRevRangeByScoreWithScores();
+	}
+
+	@Test
+	public void testZRankBytes() {
+		doReturn(Arrays.asList(new Object[] { 5l })).when(nativeConnection).exec();
+		super.testZRankBytes();
+	}
+
+	@Test
+	public void testZRank() {
+		doReturn(Arrays.asList(new Object[] { 5l })).when(nativeConnection).exec();
+		super.testZRank();
+	}
+
+	@Test
+	public void testZRemBytes() {
+		doReturn(Arrays.asList(new Object[] { true })).when(nativeConnection).exec();
+		super.testZRemBytes();
+	}
+
+	@Test
+	public void testZRem() {
+		doReturn(Arrays.asList(new Object[] { true })).when(nativeConnection).exec();
+		super.testZRem();
+	}
+
+	@Test
+	public void testZRemRangeBytes() {
+		doReturn(Arrays.asList(new Object[] { 5l })).when(nativeConnection).exec();
+		super.testZRemRangeBytes();
+	}
+
+	@Test
+	public void testZRemRange() {
+		doReturn(Arrays.asList(new Object[] { 5l })).when(nativeConnection).exec();
+		super.testZRemRange();
+	}
+
+	@Test
+	public void testZRemRangeByScoreBytes() {
+		doReturn(Arrays.asList(new Object[] { 5l })).when(nativeConnection).exec();
+		super.testZRemRangeByScoreBytes();
+	}
+
+	@Test
+	public void testZRemRangeByScore() {
+		doReturn(Arrays.asList(new Object[] { 5l })).when(nativeConnection).exec();
+		super.testZRemRangeByScore();
+	}
+
+	@Test
+	public void testZRevRangeBytes() {
+		doReturn(Arrays.asList(new Object[] { bytesSet })).when(nativeConnection).exec();
+		super.testZRevRangeBytes();
+	}
+
+	@Test
+	public void testZRevRange() {
+		doReturn(Arrays.asList(new Object[] { bytesSet })).when(nativeConnection).exec();
+		super.testZRevRange();
+	}
+
+	@Test
+	public void testZRevRangeWithScoresBytes() {
+		doReturn(Arrays.asList(new Object[] { tupleSet })).when(nativeConnection).exec();
+		super.testZRevRangeWithScoresBytes();
+	}
+
+	@Test
+	public void testZRevRangeWithScores() {
+		doReturn(Arrays.asList(new Object[] { tupleSet })).when(nativeConnection).exec();
+		super.testZRevRangeWithScores();
+	}
+
+	@Test
+	public void testZRevRankBytes() {
+		doReturn(Arrays.asList(new Object[] { 5l })).when(nativeConnection).exec();
+		super.testZRevRankBytes();
+	}
+
+	@Test
+	public void testZRevRank() {
+		doReturn(Arrays.asList(new Object[] { 5l })).when(nativeConnection).exec();
+		super.testZRevRank();
+	}
+
+	@Test
+	public void testZScoreBytes() {
+		doReturn(Arrays.asList(new Object[] { 3d })).when(nativeConnection).exec();
+		super.testZScoreBytes();
+	}
+
+	@Test
+	public void testZScore() {
+		doReturn(Arrays.asList(new Object[] { 3d })).when(nativeConnection).exec();
+		super.testZScore();
+	}
+
+	@Test
+	public void testZUnionStoreAggWeightsBytes() {
+		doReturn(Arrays.asList(new Object[] { 5l })).when(nativeConnection).exec();
+		super.testZUnionStoreAggWeightsBytes();
+	}
+
+	@Test
+	public void testZUnionStoreAggWeights() {
+		doReturn(Arrays.asList(new Object[] { 5l })).when(nativeConnection).exec();
+		super.testZUnionStoreAggWeights();
+	}
+
+	@Test
+	public void testZUnionStoreBytes() {
+		doReturn(Arrays.asList(new Object[] { 5l })).when(nativeConnection).exec();
+		super.testZUnionStoreBytes();
+	}
+
+	@Test
+	public void testZUnionStore() {
+		doReturn(Arrays.asList(new Object[] { 5l })).when(nativeConnection).exec();
+		super.testZUnionStore();
+	}
+
+	@Test
+	public void testPExpireBytes() {
+		doReturn(Arrays.asList(new Object[] { true })).when(nativeConnection).exec();
+		super.testPExpireBytes();
+	}
+
+	@Test
+	public void testPExpire() {
+		doReturn(Arrays.asList(new Object[] { true })).when(nativeConnection).exec();
+		super.testPExpire();
+	}
+
+	@Test
+	public void testPExpireAtBytes() {
+		doReturn(Arrays.asList(new Object[] { true })).when(nativeConnection).exec();
+		super.testPExpireAtBytes();
+	}
+
+	@Test
+	public void testPExpireAt() {
+		doReturn(Arrays.asList(new Object[] { true })).when(nativeConnection).exec();
+		super.testPExpireAt();
+	}
+
+	@Test
+	public void testPTtlBytes() {
+		doReturn(Arrays.asList(new Object[] { 5l })).when(nativeConnection).exec();
+		super.testPTtlBytes();
+	}
+
+	@Test
+	public void testPTtl() {
+		doReturn(Arrays.asList(new Object[] { 5l })).when(nativeConnection).exec();
+		super.testPTtl();
+	}
+
+	@Test
+	public void testDump() {
+		doReturn(Arrays.asList(new Object[] { barBytes })).when(nativeConnection).exec();
+		super.testDump();
+	}
+
+	@Test
+	public void testScriptLoadBytes() {
+		doReturn(Arrays.asList(new Object[] { "foo" })).when(nativeConnection).exec();
+		super.testScriptLoadBytes();
+	}
+
+	@Test
+	public void testScriptLoad() {
+		doReturn(Arrays.asList(new Object[] { "foo" })).when(nativeConnection).exec();
+		super.testScriptLoad();
+	}
+
+	@Test
+	public void testScriptExists() {
+		List<Boolean> results = Collections.singletonList(true);
+		doReturn(Arrays.asList(new Object[] { results })).when(nativeConnection).exec();
+		super.testScriptExists();
+	}
+
+	@Test
+	public void testEvalBytes() {
+		doReturn(Arrays.asList(new Object[] { "foo" })).when(nativeConnection).exec();
+		super.testEvalBytes();
+	}
+
+	@Test
+	public void testEval() {
+		doReturn(Arrays.asList(new Object[] { "foo" })).when(nativeConnection).exec();
+		super.testEval();
+	}
+
+	@Test
+	public void testEvalShaBytes() {
+		doReturn(Arrays.asList(new Object[] { "foo" })).when(nativeConnection).exec();
+		super.testEvalShaBytes();
+	}
+
+	@Test
+	public void testEvalSha() {
+		doReturn(Arrays.asList(new Object[] { "foo" })).when(nativeConnection).exec();
+		super.testEvalSha();
+	}
+
+	@Test
+	public void testExecute() {
+		doReturn(Arrays.asList(new Object[] { "foo" })).when(nativeConnection).exec();
+		super.testExecute();
+	}
+
+	@Test
+	public void testExecuteByteArgs() {
+		doReturn(Arrays.asList(new Object[] { "foo" })).when(nativeConnection).exec();
+		super.testExecuteByteArgs();
+	}
+
+	@Test
+	public void testExecuteStringArgs() {
+		doReturn(Arrays.asList(new Object[] { "foo" })).when(nativeConnection).exec();
+		super.testExecuteStringArgs();
+	}
+
+	@Test
+	public void testDisablePipelineAndTxDeserialize() {
+		connection.setDeserializePipelineAndTxResults(false);
+		doReturn(Arrays.asList(new Object[] { barBytes })).when(nativeConnection).exec();
+		doReturn(Arrays.asList(new Object[] {Arrays.asList(new Object[] { barBytes })})).when(nativeConnection).closePipeline();
+		doReturn(barBytes).when(nativeConnection).get(fooBytes);
+		connection.get(foo);
+		verifyResults(Arrays.asList(new Object[] { barBytes }));
+	}
+
+	@Test
+	public void testTxResultsNotSameSizeAsResults() {
+		// Only call one method, but return 2 results from nativeConnection.exec()
+		// Emulates scenario where user has called some methods directly on the native connection
+		// while tx is open
+		doReturn(Arrays.asList(new Object[] { barBytes, 3l })).when(nativeConnection).exec();
+		doReturn(barBytes).when(nativeConnection).get(fooBytes);
+		connection.get(foo);
+		verifyResults(Arrays.asList(new Object[] { barBytes, 3l }));
+	}
+
+	@Test
+	public void testDiscard() {
+		doReturn(Arrays.asList(new Object[] { fooBytes })).when(nativeConnection).exec();
+		doReturn(Arrays.asList(new Object[] { Arrays.asList(new Object[] { fooBytes })})).when(nativeConnection).closePipeline();
+		doReturn(barBytes).when(nativeConnection).get(fooBytes);
+		doReturn(fooBytes).when(nativeConnection).get(barBytes);
+		connection.get(foo);
+		connection.discard();
+		connection.get(bar);
+		// Converted results of get(bar) should be included
+		verifyResults(Arrays.asList(new Object[] { foo }));
+	}
+
+	protected List<Object> getResults() {
+		return connection.exec();
+	}
+}
diff --git a/src/test/java/org/springframework/data/redis/core/StringRedisTemplateTests.java b/src/test/java/org/springframework/data/redis/core/StringRedisTemplateTests.java
index 6e677a456..68f0f5683 100644
--- a/src/test/java/org/springframework/data/redis/core/StringRedisTemplateTests.java
+++ b/src/test/java/org/springframework/data/redis/core/StringRedisTemplateTests.java
@@ -131,7 +131,7 @@ public class StringRedisTemplateTests {
 	@Test
 	public void testStringTemplateExecutePipelineResultsNotConverted() {
 		final StringRedisTemplate template2 = new StringRedisTemplate(redisTemplate.getConnectionFactory());
-		template2.setDeserializePipelineResults(false);
+		template2.setDeserializePipelineAndTxResults(false);
 		template2.afterPropertiesSet();
 		String result = template2.execute(new RedisCallback<String>() {
 			public String doInRedis(RedisConnection connection) {