-
Notifications
You must be signed in to change notification settings - Fork 3.9k
Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
- Loading branch information
Showing
4 changed files
with
467 additions
and
4 deletions.
There are no files selected for viewing
391 changes: 391 additions & 0 deletions
391
src/test/java/redis/clients/jedis/commands/unified/pipeline/HashesPipelineCommandsTest.java
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,391 @@ | ||
package redis.clients.jedis.commands.unified.pipeline; | ||
|
||
import static redis.clients.jedis.util.AssertUtil.assertPipelineSyncAll; | ||
|
||
import java.util.*; | ||
|
||
import org.junit.AfterClass; | ||
import org.junit.BeforeClass; | ||
import org.junit.Test; | ||
|
||
import redis.clients.jedis.commands.unified.pooled.PooledCommandsTestHelper; | ||
|
||
public class HashesPipelineCommandsTest extends PipelineCommandsTestBase { | ||
|
||
@BeforeClass | ||
public static void prepare() throws InterruptedException { | ||
jedis = PooledCommandsTestHelper.getPooled(); | ||
} | ||
|
||
@AfterClass | ||
public static void cleanUp() { | ||
jedis.close(); | ||
} | ||
// | ||
// @Before | ||
// public void setUp() { | ||
// PooledCommandsTestHelper.clearData(); | ||
// } | ||
// | ||
// @After | ||
// public void tearDown() { | ||
// PooledCommandsTestHelper.clearData(); | ||
// } | ||
|
||
final byte[] bfoo = { 0x01, 0x02, 0x03, 0x04 }; | ||
final byte[] bbar = { 0x05, 0x06, 0x07, 0x08 }; | ||
final byte[] bcar = { 0x09, 0x0A, 0x0B, 0x0C }; | ||
|
||
final byte[] bbar1 = { 0x05, 0x06, 0x07, 0x08, 0x0A }; | ||
final byte[] bbar2 = { 0x05, 0x06, 0x07, 0x08, 0x0B }; | ||
final byte[] bbar3 = { 0x05, 0x06, 0x07, 0x08, 0x0C }; | ||
final byte[] bbarstar = { 0x05, 0x06, 0x07, 0x08, '*' }; | ||
|
||
@Test | ||
public void hset() { | ||
pipe.hset("foo", "bar", "car"); | ||
pipe.hset("foo", "bar", "foo"); | ||
|
||
// Binary | ||
pipe.hset(bfoo, bbar, bcar); | ||
pipe.hset(bfoo, bbar, bfoo); | ||
|
||
assertPipelineSyncAll( | ||
Arrays.<Object>asList(1L, 0L, 1L, 0L), | ||
pipe.syncAndReturnAll()); | ||
} | ||
|
||
@Test | ||
public void hget() { | ||
pipe.hset("foo", "bar", "car"); | ||
pipe.hget("bar", "foo"); | ||
pipe.hget("foo", "car"); | ||
pipe.hget("foo", "bar"); | ||
|
||
// Binary | ||
pipe.hset(bfoo, bbar, bcar); | ||
pipe.hget(bbar, bfoo); | ||
pipe.hget(bfoo, bcar); | ||
pipe.hget(bfoo, bbar); | ||
|
||
assertPipelineSyncAll( | ||
Arrays.<Object>asList( | ||
1L, null, null, "car", | ||
1L, null, null, bcar), | ||
pipe.syncAndReturnAll()); | ||
} | ||
|
||
@Test | ||
public void hsetnx() { | ||
pipe.hsetnx("foo", "bar", "car"); | ||
pipe.hget("foo", "bar"); | ||
|
||
pipe.hsetnx("foo", "bar", "foo"); | ||
pipe.hget("foo", "bar"); | ||
|
||
pipe.hsetnx("foo", "car", "bar"); | ||
pipe.hget("foo", "car"); | ||
|
||
// Binary | ||
pipe.hsetnx(bfoo, bbar, bcar); | ||
pipe.hget(bfoo, bbar); | ||
|
||
pipe.hsetnx(bfoo, bbar, bfoo); | ||
pipe.hget(bfoo, bbar); | ||
|
||
pipe.hsetnx(bfoo, bcar, bbar); | ||
pipe.hget(bfoo, bcar); | ||
|
||
assertPipelineSyncAll( | ||
Arrays.<Object>asList( | ||
1L, "car", 0L, "car", 1L, "bar", | ||
1L, bcar, 0L, bcar, 1L, bbar), | ||
pipe.syncAndReturnAll()); | ||
} | ||
|
||
@Test | ||
public void hmset() { | ||
Map<String, String> hash = new HashMap<>(); | ||
hash.put("bar", "car"); | ||
hash.put("car", "bar"); | ||
pipe.hmset("foo", hash); | ||
pipe.hget("foo", "bar"); | ||
pipe.hget("foo", "car"); | ||
|
||
// Binary | ||
Map<byte[], byte[]> bhash = new HashMap<>(); | ||
bhash.put(bbar, bcar); | ||
bhash.put(bcar, bbar); | ||
pipe.hmset(bfoo, bhash); | ||
pipe.hget(bfoo, bbar); | ||
pipe.hget(bfoo, bcar); | ||
|
||
assertPipelineSyncAll( | ||
Arrays.<Object>asList("OK", "car", "bar", "OK", bcar, bbar), | ||
pipe.syncAndReturnAll()); | ||
} | ||
|
||
@Test | ||
public void hsetVariadic() { | ||
Map<String, String> hash = new HashMap<>(); | ||
hash.put("bar", "car"); | ||
hash.put("car", "bar"); | ||
pipe.hset("foo", hash); | ||
pipe.hget("foo", "bar"); | ||
pipe.hget("foo", "car"); | ||
|
||
// Binary | ||
Map<byte[], byte[]> bhash = new HashMap<>(); | ||
bhash.put(bbar, bcar); | ||
bhash.put(bcar, bbar); | ||
pipe.hset(bfoo, bhash); | ||
pipe.hget(bfoo, bbar); | ||
pipe.hget(bfoo, bcar); | ||
|
||
assertPipelineSyncAll( | ||
Arrays.<Object>asList(2L, "car", "bar", 2L, bcar, bbar), | ||
pipe.syncAndReturnAll()); | ||
} | ||
|
||
@Test | ||
public void hmget() { | ||
Map<String, String> hash = new HashMap<>(); | ||
hash.put("bar", "car"); | ||
hash.put("car", "bar"); | ||
pipe.hmset("foo", hash); | ||
|
||
pipe.hmget("foo", "bar", "car", "foo"); | ||
List<String> expected = new ArrayList<>(); | ||
expected.add("car"); | ||
expected.add("bar"); | ||
expected.add(null); | ||
|
||
// Binary | ||
Map<byte[], byte[]> bhash = new HashMap<>(); | ||
bhash.put(bbar, bcar); | ||
bhash.put(bcar, bbar); | ||
pipe.hmset(bfoo, bhash); | ||
|
||
pipe.hmget(bfoo, bbar, bcar, bfoo); | ||
List<byte[]> bexpected = new ArrayList<>(); | ||
bexpected.add(bcar); | ||
bexpected.add(bbar); | ||
bexpected.add(null); | ||
|
||
assertPipelineSyncAll( | ||
Arrays.<Object>asList( | ||
"OK", Arrays.asList("car", "bar", null), | ||
"OK", Arrays.asList(bcar, bbar, null)), | ||
pipe.syncAndReturnAll()); | ||
} | ||
|
||
@Test | ||
public void hincrBy() { | ||
pipe.hincrBy("foo", "bar", 1); | ||
pipe.hincrBy("foo", "bar", -1); | ||
pipe.hincrBy("foo", "bar", -10); | ||
|
||
// Binary | ||
pipe.hincrBy(bfoo, bbar, 1); | ||
pipe.hincrBy(bfoo, bbar, -1); | ||
pipe.hincrBy(bfoo, bbar, -10); | ||
|
||
assertPipelineSyncAll( | ||
Arrays.<Object>asList(1L, 0L, -10L, 1L, 0L, -10L), | ||
pipe.syncAndReturnAll()); | ||
} | ||
|
||
@Test | ||
public void hincrByFloat() { | ||
pipe.hincrByFloat("foo", "bar", 1.5d); | ||
pipe.hincrByFloat("foo", "bar", -1.5d); | ||
pipe.hincrByFloat("foo", "bar", -10.7d); | ||
|
||
// Binary | ||
pipe.hincrByFloat(bfoo, bbar, 1.5d); | ||
pipe.hincrByFloat(bfoo, bbar, -1.5d); | ||
pipe.hincrByFloat(bfoo, bbar, -10.7d); | ||
|
||
assertPipelineSyncAll( | ||
Arrays.<Object>asList(1.5, 0d, -10.7, 1.5, 0d, -10.7), | ||
pipe.syncAndReturnAll()); | ||
} | ||
|
||
@Test | ||
public void hexists() { | ||
Map<String, String> hash = new HashMap<>(); | ||
hash.put("bar", "car"); | ||
hash.put("car", "bar"); | ||
pipe.hset("foo", hash); | ||
|
||
pipe.hexists("bar", "foo"); | ||
pipe.hexists("foo", "foo"); | ||
pipe.hexists("foo", "bar"); | ||
|
||
// Binary | ||
Map<byte[], byte[]> bhash = new HashMap<>(); | ||
bhash.put(bbar, bcar); | ||
bhash.put(bcar, bbar); | ||
pipe.hset(bfoo, bhash); | ||
|
||
pipe.hexists(bbar, bfoo); | ||
pipe.hexists(bfoo, bfoo); | ||
pipe.hexists(bfoo, bbar); | ||
|
||
assertPipelineSyncAll( | ||
Arrays.<Object>asList( | ||
2L, false, false, true, | ||
2L, false, false, true), | ||
pipe.syncAndReturnAll()); | ||
} | ||
|
||
@Test | ||
public void hdel() { | ||
Map<String, String> hash = new HashMap<>(); | ||
hash.put("bar", "car"); | ||
hash.put("car", "bar"); | ||
pipe.hset("foo", hash); | ||
|
||
pipe.hdel("bar", "foo"); | ||
pipe.hdel("foo", "foo"); | ||
pipe.hdel("foo", "bar"); | ||
pipe.hget("foo", "bar"); | ||
|
||
// Binary | ||
Map<byte[], byte[]> bhash = new HashMap<>(); | ||
bhash.put(bbar, bcar); | ||
bhash.put(bcar, bbar); | ||
pipe.hset(bfoo, bhash); | ||
|
||
pipe.hdel(bbar, bfoo); | ||
pipe.hdel(bfoo, bfoo); | ||
pipe.hdel(bfoo, bbar); | ||
pipe.hget(bfoo, bbar); | ||
|
||
assertPipelineSyncAll( | ||
Arrays.<Object>asList( | ||
2L, 0L, 0L, 1L, null, | ||
2L, 0L, 0L, 1L, null), | ||
pipe.syncAndReturnAll()); | ||
} | ||
|
||
@Test | ||
public void hlen() { | ||
Map<String, String> hash = new HashMap<>(); | ||
hash.put("bar", "car"); | ||
hash.put("car", "bar"); | ||
pipe.hset("foo", hash); | ||
|
||
pipe.hlen("bar"); | ||
pipe.hlen("foo"); | ||
|
||
// Binary | ||
Map<byte[], byte[]> bhash = new HashMap<>(); | ||
bhash.put(bbar, bcar); | ||
bhash.put(bcar, bbar); | ||
pipe.hset(bfoo, bhash); | ||
|
||
pipe.hlen(bbar); | ||
pipe.hlen(bfoo); | ||
|
||
assertPipelineSyncAll( | ||
Arrays.<Object>asList(2L, 0L, 2L, 2L, 0L, 2L), | ||
pipe.syncAndReturnAll()); | ||
} | ||
|
||
@Test | ||
public void hkeys() { | ||
Map<String, String> hash = new LinkedHashMap<>(); | ||
hash.put("bar", "car"); | ||
hash.put("car", "bar"); | ||
pipe.hset("foo", hash); | ||
|
||
pipe.hkeys("foo"); | ||
Set<String> expected = new LinkedHashSet<>(); | ||
expected.add("bar"); | ||
expected.add("car"); | ||
|
||
// Binary | ||
Map<byte[], byte[]> bhash = new LinkedHashMap<>(); | ||
bhash.put(bbar, bcar); | ||
bhash.put(bcar, bbar); | ||
pipe.hset(bfoo, bhash); | ||
|
||
pipe.hkeys(bfoo); | ||
Set<byte[]> bexpected = new LinkedHashSet<>(); | ||
bexpected.add(bbar); | ||
bexpected.add(bcar); | ||
|
||
assertPipelineSyncAll( | ||
Arrays.<Object>asList( | ||
2L, new HashSet<>(Arrays.asList("bar", "car")), | ||
2L, new HashSet<>(Arrays.asList(bbar, bcar))), | ||
pipe.syncAndReturnAll()); | ||
} | ||
|
||
@Test | ||
public void hvals() { | ||
Map<String, String> hash = new LinkedHashMap<>(); | ||
hash.put("bar", "car"); | ||
//hash.put("car", "bar"); | ||
pipe.hset("foo", hash); | ||
|
||
pipe.hvals("foo"); | ||
|
||
// Binary | ||
Map<byte[], byte[]> bhash = new LinkedHashMap<>(); | ||
bhash.put(bbar, bcar); | ||
//bhash.put(bcar, bbar); | ||
pipe.hset(bfoo, bhash); | ||
|
||
pipe.hvals(bfoo); | ||
|
||
assertPipelineSyncAll( | ||
Arrays.<Object>asList( | ||
//2L, Arrays.asList("bar", "car"), | ||
//2L, Arrays.asList(bbar, bcar)), | ||
1L, Arrays.asList("car"), | ||
1L, Arrays.asList(bcar)), | ||
pipe.syncAndReturnAll()); | ||
} | ||
|
||
@Test | ||
public void hgetAll() { | ||
Map<String, String> hash = new HashMap<>(); | ||
hash.put("bar", "car"); | ||
//hash.put("car", "bar"); | ||
pipe.hset("foo", hash); | ||
|
||
pipe.hgetAll("foo"); | ||
|
||
// Binary | ||
Map<byte[], byte[]> bhash = new HashMap<>(); | ||
bhash.put(bbar, bcar); | ||
//bhash.put(bcar, bbar); | ||
pipe.hset(bfoo, bhash); | ||
|
||
pipe.hgetAll(bfoo); | ||
|
||
// assertPipelineSyncAll( | ||
// Arrays.<Object>asList( | ||
// 1L, hash, | ||
// 1L, bhash), | ||
// pipe.syncAndReturnAll()); | ||
pipe.syncAndReturnAll(); | ||
} | ||
|
||
@Test | ||
public void hstrlen() { | ||
pipe.hstrlen("foo", "key"); | ||
pipe.hset("foo", "key", "value"); | ||
pipe.hstrlen("foo", "key"); | ||
|
||
pipe.hstrlen(bfoo, bbar); | ||
pipe.hset(bfoo, bbar, bcar); | ||
pipe.hstrlen(bfoo, bbar); | ||
|
||
assertPipelineSyncAll( | ||
Arrays.<Object>asList(0L, 1L, 5L, 0L, 1L, 4L), | ||
pipe.syncAndReturnAll()); | ||
} | ||
} |
Oops, something went wrong.