diff --git a/src/main/java/redis/clients/jedis/CommandObjects.java b/src/main/java/redis/clients/jedis/CommandObjects.java index da773d5782..2f5e4d16a0 100644 --- a/src/main/java/redis/clients/jedis/CommandObjects.java +++ b/src/main/java/redis/clients/jedis/CommandObjects.java @@ -1128,6 +1128,10 @@ public final CommandObject>> hscan(String k return new CommandObject<>(commandArguments(HSCAN).key(key).add(cursor).addParams(params), BuilderFactory.HSCAN_RESPONSE); } + public final CommandObject> hscanNoValues(String key, String cursor, ScanParams params) { + return new CommandObject<>(commandArguments(HSCAN).key(key).add(cursor).addParams(params).add(NOVALUES), BuilderFactory.SCAN_RESPONSE); + } + public final CommandObject hstrlen(String key, String field) { return new CommandObject<>(commandArguments(HSTRLEN).key(key).add(field), BuilderFactory.LONG); } @@ -1136,6 +1140,10 @@ public final CommandObject>> hscan(byte[] k return new CommandObject<>(commandArguments(HSCAN).key(key).add(cursor).addParams(params), BuilderFactory.HSCAN_BINARY_RESPONSE); } + public final CommandObject> hscanNoValues(byte[] key, byte[] cursor, ScanParams params) { + return new CommandObject<>(commandArguments(HSCAN).key(key).add(cursor).addParams(params).add(NOVALUES), BuilderFactory.SCAN_BINARY_RESPONSE); + } + public final CommandObject hstrlen(byte[] key, byte[] field) { return new CommandObject<>(commandArguments(HSTRLEN).key(key).add(field), BuilderFactory.LONG); } diff --git a/src/main/java/redis/clients/jedis/Jedis.java b/src/main/java/redis/clients/jedis/Jedis.java index 8595a14de7..1e25f2ffcb 100644 --- a/src/main/java/redis/clients/jedis/Jedis.java +++ b/src/main/java/redis/clients/jedis/Jedis.java @@ -4413,11 +4413,6 @@ public ScanResult scan(final byte[] cursor, final ScanParams params, fin return connection.executeCommand(commandObjects.scan(cursor, params, type)); } - @Override - public ScanResult> hscan(final byte[] key, final byte[] cursor) { - return hscan(key, cursor, new ScanParams()); - } - @Override public ScanResult> hscan(final byte[] key, final byte[] cursor, final ScanParams params) { @@ -4425,6 +4420,12 @@ public ScanResult> hscan(final byte[] key, final byte[ return connection.executeCommand(commandObjects.hscan(key, cursor, params)); } + @Override + public ScanResult hscanNoValues(final byte[] key, final byte[] cursor, final ScanParams params) { + checkIsInMultiOrPipeline(); + return connection.executeCommand(commandObjects.hscanNoValues(key, cursor, params)); + } + @Override public ScanResult sscan(final byte[] key, final byte[] cursor) { return sscan(key, cursor, new ScanParams()); @@ -8617,6 +8618,12 @@ public ScanResult> hscan(final String key, final Strin return connection.executeCommand(commandObjects.hscan(key, cursor, params)); } + @Override + public ScanResult hscanNoValues(final String key, final String cursor, final ScanParams params) { + checkIsInMultiOrPipeline(); + return connection.executeCommand(commandObjects.hscanNoValues(key, cursor, params)); + } + @Override public ScanResult sscan(final String key, final String cursor, final ScanParams params) { checkIsInMultiOrPipeline(); diff --git a/src/main/java/redis/clients/jedis/Protocol.java b/src/main/java/redis/clients/jedis/Protocol.java index 24830637fb..31a93e3ebb 100644 --- a/src/main/java/redis/clients/jedis/Protocol.java +++ b/src/main/java/redis/clients/jedis/Protocol.java @@ -301,7 +301,7 @@ public static enum Keyword implements Rawable { DELETE, LIBRARYNAME, WITHCODE, DESCRIPTION, GETKEYS, GETKEYSANDFLAGS, DOCS, FILTERBY, DUMP, MODULE, ACLCAT, PATTERN, DOCTOR, LATEST, HISTORY, USAGE, SAMPLES, PURGE, STATS, LOADEX, CONFIG, ARGS, RANK, NOW, VERSION, ADDR, SKIPME, USER, LADDR, - CHANNELS, NUMPAT, NUMSUB, SHARDCHANNELS, SHARDNUMSUB; + CHANNELS, NUMPAT, NUMSUB, SHARDCHANNELS, SHARDNUMSUB, NOVALUES; private final byte[] raw; diff --git a/src/main/java/redis/clients/jedis/UnifiedJedis.java b/src/main/java/redis/clients/jedis/UnifiedJedis.java index b628be6933..eab452a1f1 100644 --- a/src/main/java/redis/clients/jedis/UnifiedJedis.java +++ b/src/main/java/redis/clients/jedis/UnifiedJedis.java @@ -1549,6 +1549,11 @@ public ScanResult> hscan(String key, String cursor, Sc return executeCommand(commandObjects.hscan(key, cursor, params)); } + @Override + public ScanResult hscanNoValues(String key, String cursor, ScanParams params) { + return executeCommand(commandObjects.hscanNoValues(key, cursor, params)); + } + @Override public long hstrlen(String key, String field) { return executeCommand(commandObjects.hstrlen(key, field)); @@ -1574,6 +1579,11 @@ public ScanResult> hscan(byte[] key, byte[] cursor, Sc return executeCommand(commandObjects.hscan(key, cursor, params)); } + @Override + public ScanResult hscanNoValues(byte[] key, byte[] cursor, ScanParams params) { + return executeCommand(commandObjects.hscanNoValues(key, cursor, params)); + } + @Override public long hstrlen(byte[] key, byte[] field) { return executeCommand(commandObjects.hstrlen(key, field)); diff --git a/src/main/java/redis/clients/jedis/commands/HashBinaryCommands.java b/src/main/java/redis/clients/jedis/commands/HashBinaryCommands.java index 196f7512a8..d0695302b3 100644 --- a/src/main/java/redis/clients/jedis/commands/HashBinaryCommands.java +++ b/src/main/java/redis/clients/jedis/commands/HashBinaryCommands.java @@ -47,8 +47,14 @@ default ScanResult> hscan(byte[] key, byte[] cursor) { return hscan(key, cursor, new ScanParams()); } + default ScanResult hscanNoValues(byte[] key, byte[] cursor) { + return hscanNoValues(key, cursor, new ScanParams()); + } + ScanResult> hscan(byte[] key, byte[] cursor, ScanParams params); + ScanResult hscanNoValues(byte[] key, byte[] cursor, ScanParams params); + long hstrlen(byte[] key, byte[] field); } diff --git a/src/main/java/redis/clients/jedis/commands/HashCommands.java b/src/main/java/redis/clients/jedis/commands/HashCommands.java index d319c4fa39..ad3bed4e32 100644 --- a/src/main/java/redis/clients/jedis/commands/HashCommands.java +++ b/src/main/java/redis/clients/jedis/commands/HashCommands.java @@ -47,7 +47,13 @@ default ScanResult> hscan(String key, String cursor) { return hscan(key, cursor, new ScanParams()); } + default ScanResult hscanNoValues(String key, String cursor) { + return hscanNoValues(key, cursor, new ScanParams()); + } + ScanResult> hscan(String key, String cursor, ScanParams params); + ScanResult hscanNoValues(String key, String cursor, ScanParams params); + long hstrlen(String key, String field); } diff --git a/src/test/java/redis/clients/jedis/commands/jedis/HashesCommandsTest.java b/src/test/java/redis/clients/jedis/commands/jedis/HashesCommandsTest.java index c592d65afa..a30740dcf6 100644 --- a/src/test/java/redis/clients/jedis/commands/jedis/HashesCommandsTest.java +++ b/src/test/java/redis/clients/jedis/commands/jedis/HashesCommandsTest.java @@ -1,5 +1,7 @@ package redis.clients.jedis.commands.jedis; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.containsInAnyOrder; import static org.junit.Assert.assertArrayEquals; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; @@ -10,6 +12,7 @@ import static redis.clients.jedis.params.ScanParams.SCAN_POINTER_START_BINARY; import java.util.ArrayList; +import java.util.Arrays; import java.util.Collections; import java.util.HashMap; import java.util.LinkedHashMap; @@ -17,6 +20,7 @@ import java.util.List; import java.util.Map; import java.util.Set; +import java.util.stream.Collectors; import org.junit.Test; @@ -339,13 +343,20 @@ public void hgetAllPipeline() { @Test public void hscan() { - jedis.hset("foo", "b", "b"); - jedis.hset("foo", "a", "a"); + jedis.hset("foo", "b", "y"); + jedis.hset("foo", "a", "x"); ScanResult> result = jedis.hscan("foo", SCAN_POINTER_START); assertEquals(SCAN_POINTER_START, result.getCursor()); - assertFalse(result.getResult().isEmpty()); + assertEquals(2, result.getResult().size()); + + assertThat( + result.getResult().stream().map(Map.Entry::getKey).collect(Collectors.toList()), + containsInAnyOrder("a", "b")); + assertThat( + result.getResult().stream().map(Map.Entry::getValue).collect(Collectors.toList()), + containsInAnyOrder("x", "y")); // binary jedis.hset(bfoo, bbar, bcar); @@ -353,7 +364,14 @@ public void hscan() { ScanResult> bResult = jedis.hscan(bfoo, SCAN_POINTER_START_BINARY); assertArrayEquals(SCAN_POINTER_START_BINARY, bResult.getCursorAsBytes()); - assertFalse(bResult.getResult().isEmpty()); + assertEquals(1, bResult.getResult().size()); + + assertThat( + bResult.getResult().stream().map(Map.Entry::getKey).collect(Collectors.toList()), + containsInAnyOrder(bbar)); + assertThat( + bResult.getResult().stream().map(Map.Entry::getValue).collect(Collectors.toList()), + containsInAnyOrder(bcar)); } @Test @@ -361,13 +379,20 @@ public void hscanMatch() { ScanParams params = new ScanParams(); params.match("a*"); - jedis.hset("foo", "b", "b"); - jedis.hset("foo", "a", "a"); - jedis.hset("foo", "aa", "aa"); + jedis.hset("foo", "b", "y"); + jedis.hset("foo", "a", "x"); + jedis.hset("foo", "aa", "xx"); ScanResult> result = jedis.hscan("foo", SCAN_POINTER_START, params); assertEquals(SCAN_POINTER_START, result.getCursor()); - assertFalse(result.getResult().isEmpty()); + assertEquals(2, result.getResult().size()); + + assertThat( + result.getResult().stream().map(Map.Entry::getKey).collect(Collectors.toList()), + containsInAnyOrder("a", "aa")); + assertThat( + result.getResult().stream().map(Map.Entry::getValue).collect(Collectors.toList()), + containsInAnyOrder("x", "xx")); // binary params = new ScanParams(); @@ -379,10 +404,17 @@ public void hscanMatch() { jedis.hset(bfoo, bbar3, bcar); ScanResult> bResult = jedis.hscan(bfoo, SCAN_POINTER_START_BINARY, - params); + params); assertArrayEquals(SCAN_POINTER_START_BINARY, bResult.getCursorAsBytes()); - assertFalse(bResult.getResult().isEmpty()); + assertEquals(4, bResult.getResult().size()); + + assertThat( + bResult.getResult().stream().map(Map.Entry::getKey).collect(Collectors.toList()), + containsInAnyOrder(bbar, bbar1, bbar2, bbar3)); + assertThat( + bResult.getResult().stream().map(Map.Entry::getValue).collect(Collectors.toList()), + containsInAnyOrder(bcar, bcar, bcar, bcar)); } @Test @@ -391,13 +423,20 @@ public void hscanCount() { params.count(2); for (int i = 0; i < 10; i++) { - jedis.hset("foo", "a" + i, "a" + i); + jedis.hset("foo", "a" + i, "x" + i); } ScanResult> result = jedis.hscan("foo", SCAN_POINTER_START, params); assertFalse(result.getResult().isEmpty()); + assertThat( + result.getResult().stream().map(Map.Entry::getKey).map(s -> s.substring(0, 1)).collect(Collectors.toSet()), + containsInAnyOrder("a")); + assertThat( + result.getResult().stream().map(Map.Entry::getValue).map(s -> s.substring(0, 1)).collect(Collectors.toSet()), + containsInAnyOrder("x")); + // binary params = new ScanParams(); params.count(2); @@ -407,10 +446,109 @@ public void hscanCount() { jedis.hset(bfoo, bbar2, bcar); jedis.hset(bfoo, bbar3, bcar); - ScanResult> bResult = jedis.hscan(bfoo, SCAN_POINTER_START_BINARY, - params); + ScanResult> bResult = jedis.hscan(bfoo, SCAN_POINTER_START_BINARY, params); + + assertFalse(bResult.getResult().isEmpty()); + + assertThat( + bResult.getResult().stream().map(Map.Entry::getKey) + .map(a -> Arrays.copyOfRange(a, 0, 4)).map(Arrays::toString).collect(Collectors.toSet()), + containsInAnyOrder(Arrays.toString(bbar))); + assertThat( + bResult.getResult().stream().map(Map.Entry::getValue) + .map(a -> Arrays.copyOfRange(a, 0, 4)).map(Arrays::toString).collect(Collectors.toSet()), + containsInAnyOrder(Arrays.toString(bcar))); + } + + @Test + public void hscanNoValues() { + jedis.hset("foo", "b", "y"); + jedis.hset("foo", "a", "x"); + + ScanResult result = jedis.hscanNoValues("foo", SCAN_POINTER_START); + + assertEquals(SCAN_POINTER_START, result.getCursor()); + assertEquals(2, result.getResult().size()); + + assertThat(result.getResult(), containsInAnyOrder("a", "b")); + + // binary + jedis.hset(bfoo, bbar, bcar); + + ScanResult bResult = jedis.hscanNoValues(bfoo, SCAN_POINTER_START_BINARY); + + assertArrayEquals(SCAN_POINTER_START_BINARY, bResult.getCursorAsBytes()); + assertEquals(1, bResult.getResult().size()); + + assertThat(bResult.getResult(), containsInAnyOrder(bbar)); + } + + @Test + public void hscanNoValuesMatch() { + ScanParams params = new ScanParams(); + params.match("a*"); + + jedis.hset("foo", "b", "y"); + jedis.hset("foo", "a", "x"); + jedis.hset("foo", "aa", "xx"); + ScanResult result = jedis.hscanNoValues("foo", SCAN_POINTER_START, params); + + assertEquals(SCAN_POINTER_START, result.getCursor()); + assertEquals(2, result.getResult().size()); + + assertThat(result.getResult(), containsInAnyOrder("a", "aa")); + + // binary + params = new ScanParams(); + params.match(bbarstar); + + jedis.hset(bfoo, bbar, bcar); + jedis.hset(bfoo, bbar1, bcar); + jedis.hset(bfoo, bbar2, bcar); + jedis.hset(bfoo, bbar3, bcar); + + ScanResult bResult = jedis.hscanNoValues(bfoo, SCAN_POINTER_START_BINARY, params); + + assertArrayEquals(SCAN_POINTER_START_BINARY, bResult.getCursorAsBytes()); + assertEquals(4, bResult.getResult().size()); + + assertThat(bResult.getResult(), containsInAnyOrder(bbar, bbar1, bbar2, bbar3)); + } + + @Test + public void hscanNoValuesCount() { + ScanParams params = new ScanParams(); + params.count(2); + + for (int i = 0; i < 10; i++) { + jedis.hset("foo", "a" + i, "a" + i); + } + + ScanResult result = jedis.hscanNoValues("foo", SCAN_POINTER_START, params); + + assertFalse(result.getResult().isEmpty()); + + assertThat( + result.getResult().stream().map(s -> s.substring(0, 1)).collect(Collectors.toSet()), + containsInAnyOrder("a")); + + // binary + params = new ScanParams(); + params.count(2); + + jedis.hset(bfoo, bbar, bcar); + jedis.hset(bfoo, bbar1, bcar); + jedis.hset(bfoo, bbar2, bcar); + jedis.hset(bfoo, bbar3, bcar); + + ScanResult bResult = jedis.hscanNoValues(bfoo, SCAN_POINTER_START_BINARY, params); assertFalse(bResult.getResult().isEmpty()); + + assertThat( + bResult.getResult().stream() + .map(a -> Arrays.copyOfRange(a, 0, 4)).map(Arrays::toString).collect(Collectors.toSet()), + containsInAnyOrder(Arrays.toString(bbar))); } @Test diff --git a/src/test/java/redis/clients/jedis/commands/unified/HashesCommandsTestBase.java b/src/test/java/redis/clients/jedis/commands/unified/HashesCommandsTestBase.java index cac2606984..d06edf38ec 100644 --- a/src/test/java/redis/clients/jedis/commands/unified/HashesCommandsTestBase.java +++ b/src/test/java/redis/clients/jedis/commands/unified/HashesCommandsTestBase.java @@ -1,9 +1,10 @@ package redis.clients.jedis.commands.unified; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.containsInAnyOrder; import static org.junit.Assert.assertArrayEquals; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertTrue; import static org.junit.Assert.assertNull; @@ -11,6 +12,7 @@ import static redis.clients.jedis.params.ScanParams.SCAN_POINTER_START_BINARY; import java.util.ArrayList; +import java.util.Arrays; import java.util.Collections; import java.util.HashMap; import java.util.LinkedHashMap; @@ -18,6 +20,7 @@ import java.util.List; import java.util.Map; import java.util.Set; +import java.util.stream.Collectors; import org.junit.Test; @@ -316,13 +319,20 @@ public void hgetAll() { @Test public void hscan() { - jedis.hset("foo", "b", "b"); - jedis.hset("foo", "a", "a"); + jedis.hset("foo", "b", "y"); + jedis.hset("foo", "a", "x"); ScanResult> result = jedis.hscan("foo", SCAN_POINTER_START); assertEquals(SCAN_POINTER_START, result.getCursor()); - assertFalse(result.getResult().isEmpty()); + assertEquals(2, result.getResult().size()); + + assertThat( + result.getResult().stream().map(Map.Entry::getKey).collect(Collectors.toList()), + containsInAnyOrder("a", "b")); + assertThat( + result.getResult().stream().map(Map.Entry::getValue).collect(Collectors.toList()), + containsInAnyOrder("x", "y")); // binary jedis.hset(bfoo, bbar, bcar); @@ -330,7 +340,14 @@ public void hscan() { ScanResult> bResult = jedis.hscan(bfoo, SCAN_POINTER_START_BINARY); assertArrayEquals(SCAN_POINTER_START_BINARY, bResult.getCursorAsBytes()); - assertFalse(bResult.getResult().isEmpty()); + assertEquals(1, bResult.getResult().size()); + + assertThat( + bResult.getResult().stream().map(Map.Entry::getKey).collect(Collectors.toList()), + containsInAnyOrder(bbar)); + assertThat( + bResult.getResult().stream().map(Map.Entry::getValue).collect(Collectors.toList()), + containsInAnyOrder(bcar)); } @Test @@ -338,13 +355,20 @@ public void hscanMatch() { ScanParams params = new ScanParams(); params.match("a*"); - jedis.hset("foo", "b", "b"); - jedis.hset("foo", "a", "a"); - jedis.hset("foo", "aa", "aa"); + jedis.hset("foo", "b", "y"); + jedis.hset("foo", "a", "x"); + jedis.hset("foo", "aa", "xx"); ScanResult> result = jedis.hscan("foo", SCAN_POINTER_START, params); assertEquals(SCAN_POINTER_START, result.getCursor()); - assertFalse(result.getResult().isEmpty()); + assertEquals(2, result.getResult().size()); + + assertThat( + result.getResult().stream().map(Map.Entry::getKey).collect(Collectors.toList()), + containsInAnyOrder("a", "aa")); + assertThat( + result.getResult().stream().map(Map.Entry::getValue).collect(Collectors.toList()), + containsInAnyOrder("x", "xx")); // binary params = new ScanParams(); @@ -355,11 +379,17 @@ public void hscanMatch() { jedis.hset(bfoo, bbar2, bcar); jedis.hset(bfoo, bbar3, bcar); - ScanResult> bResult = jedis.hscan(bfoo, SCAN_POINTER_START_BINARY, - params); + ScanResult> bResult = jedis.hscan(bfoo, SCAN_POINTER_START_BINARY, params); assertArrayEquals(SCAN_POINTER_START_BINARY, bResult.getCursorAsBytes()); - assertFalse(bResult.getResult().isEmpty()); + assertEquals(4, bResult.getResult().size()); + + assertThat( + bResult.getResult().stream().map(Map.Entry::getKey).collect(Collectors.toList()), + containsInAnyOrder(bbar, bbar1, bbar2, bbar3)); + assertThat( + bResult.getResult().stream().map(Map.Entry::getValue).collect(Collectors.toList()), + containsInAnyOrder(bcar, bcar, bcar, bcar)); } @Test @@ -368,13 +398,20 @@ public void hscanCount() { params.count(2); for (int i = 0; i < 10; i++) { - jedis.hset("foo", "a" + i, "a" + i); + jedis.hset("foo", "a" + i, "x" + i); } ScanResult> result = jedis.hscan("foo", SCAN_POINTER_START, params); assertFalse(result.getResult().isEmpty()); + assertThat( + result.getResult().stream().map(Map.Entry::getKey).map(s -> s.substring(0, 1)).collect(Collectors.toSet()), + containsInAnyOrder("a")); + assertThat( + result.getResult().stream().map(Map.Entry::getValue).map(s -> s.substring(0, 1)).collect(Collectors.toSet()), + containsInAnyOrder("x")); + // binary params = new ScanParams(); params.count(2); @@ -384,10 +421,109 @@ public void hscanCount() { jedis.hset(bfoo, bbar2, bcar); jedis.hset(bfoo, bbar3, bcar); - ScanResult> bResult = jedis.hscan(bfoo, SCAN_POINTER_START_BINARY, - params); + ScanResult> bResult = jedis.hscan(bfoo, SCAN_POINTER_START_BINARY, params); assertFalse(bResult.getResult().isEmpty()); + + assertThat( + bResult.getResult().stream().map(Map.Entry::getKey) + .map(a -> Arrays.copyOfRange(a, 0, 4)).map(Arrays::toString).collect(Collectors.toSet()), + containsInAnyOrder(Arrays.toString(bbar))); + assertThat( + bResult.getResult().stream().map(Map.Entry::getValue) + .map(a -> Arrays.copyOfRange(a, 0, 4)).map(Arrays::toString).collect(Collectors.toSet()), + containsInAnyOrder(Arrays.toString(bcar))); + } + + @Test + public void hscanNoValues() { + jedis.hset("foo", "b", "y"); + jedis.hset("foo", "a", "x"); + + ScanResult result = jedis.hscanNoValues("foo", SCAN_POINTER_START); + + assertEquals(SCAN_POINTER_START, result.getCursor()); + assertEquals(2, result.getResult().size()); + + assertThat(result.getResult(), containsInAnyOrder("a", "b")); + + // binary + jedis.hset(bfoo, bbar, bcar); + + ScanResult bResult = jedis.hscanNoValues(bfoo, SCAN_POINTER_START_BINARY); + + assertArrayEquals(SCAN_POINTER_START_BINARY, bResult.getCursorAsBytes()); + assertEquals(1, bResult.getResult().size()); + + assertThat(bResult.getResult(), containsInAnyOrder(bbar)); + } + + @Test + public void hscanNoValuesMatch() { + ScanParams params = new ScanParams(); + params.match("a*"); + + jedis.hset("foo", "b", "y"); + jedis.hset("foo", "a", "x"); + jedis.hset("foo", "aa", "xx"); + ScanResult result = jedis.hscanNoValues("foo", SCAN_POINTER_START, params); + + assertEquals(SCAN_POINTER_START, result.getCursor()); + assertEquals(2, result.getResult().size()); + + assertThat(result.getResult(), containsInAnyOrder("a", "aa")); + + // binary + params = new ScanParams(); + params.match(bbarstar); + + jedis.hset(bfoo, bbar, bcar); + jedis.hset(bfoo, bbar1, bcar); + jedis.hset(bfoo, bbar2, bcar); + jedis.hset(bfoo, bbar3, bcar); + + ScanResult bResult = jedis.hscanNoValues(bfoo, SCAN_POINTER_START_BINARY, params); + + assertArrayEquals(SCAN_POINTER_START_BINARY, bResult.getCursorAsBytes()); + assertEquals(4, bResult.getResult().size()); + + assertThat(bResult.getResult(), containsInAnyOrder(bbar, bbar1, bbar2, bbar3)); + } + + @Test + public void hscanNoValuesCount() { + ScanParams params = new ScanParams(); + params.count(2); + + for (int i = 0; i < 10; i++) { + jedis.hset("foo", "a" + i, "a" + i); + } + + ScanResult result = jedis.hscanNoValues("foo", SCAN_POINTER_START, params); + + assertFalse(result.getResult().isEmpty()); + + assertThat( + result.getResult().stream().map(s -> s.substring(0, 1)).collect(Collectors.toSet()), + containsInAnyOrder("a")); + + // binary + params = new ScanParams(); + params.count(2); + + jedis.hset(bfoo, bbar, bcar); + jedis.hset(bfoo, bbar1, bcar); + jedis.hset(bfoo, bbar2, bcar); + jedis.hset(bfoo, bbar3, bcar); + + ScanResult bResult = jedis.hscanNoValues(bfoo, SCAN_POINTER_START_BINARY, params); + + assertFalse(bResult.getResult().isEmpty()); + + assertThat( + bResult.getResult().stream() + .map(a -> Arrays.copyOfRange(a, 0, 4)).map(Arrays::toString).collect(Collectors.toSet()), + containsInAnyOrder(Arrays.toString(bbar))); } @Test