content: package redis.clients.jedis.tests.commands;
  
  import static redis.clients.jedis.ScanParams.SCAN_POINTER_START;
  import static redis.clients.jedis.ScanParams.SCAN_POINTER_START_BINARY;
  import static redis.clients.jedis.params.set.SetParams.setParams;
  
  import java.util.Arrays;
  import java.util.HashSet;
  import java.util.Set;
  
  import org.junit.Test;
  
  import redis.clients.jedis.Protocol.Keyword;
  import redis.clients.jedis.ScanParams;
  import redis.clients.jedis.ScanResult;
  import redis.clients.jedis.exceptions.JedisDataException;
  import redis.clients.util.SafeEncoder;
  
  public class AllKindOfValuesCommandsTest extends JedisCommandTestBase {
    final byte[] bfoo = { 0x01, 0x02, 0x03, 0x04 };
    final byte[] bfoo1 = { 0x01, 0x02, 0x03, 0x04, 0x0A };
    final byte[] bfoo2 = { 0x01, 0x02, 0x03, 0x04, 0x0B };
    final byte[] bfoo3 = { 0x01, 0x02, 0x03, 0x04, 0x0C };
    final byte[] bbar = { 0x05, 0x06, 0x07, 0x08 };
    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[] bfoobar = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 };
    final byte[] bfoostar = { 0x01, 0x02, 0x03, 0x04, '*' };
    final byte[] bbarstar = { 0x05, 0x06, 0x07, 0x08, '*' };
  
    final byte[] bnx = { 0x6E, 0x78 };
    final byte[] bex = { 0x65, 0x78 };
    final int expireSeconds = 2;
  
    @Test
    public void ping() {
      String status = jedis.ping();
      assertEquals("PONG", status);
    }
  
    @Test
    public void exists() {
      String status = jedis.set("foo", "bar");
      assertEquals("OK", status);
  
      status = jedis.set(bfoo, bbar);
      assertEquals("OK", status);
  
      boolean reply = jedis.exists("foo");
      assertTrue(reply);
  
      reply = jedis.exists(bfoo);
      assertTrue(reply);
  
      long lreply = jedis.del("foo");
      assertEquals(1, lreply);
  
      lreply = jedis.del(bfoo);
      assertEquals(1, lreply);
  
      reply = jedis.exists("foo");
      assertFalse(reply);
  
      reply = jedis.exists(bfoo);
      assertFalse(reply);
    }
  
    @Test
    public void existsMany() {
      String status = jedis.set("foo1", "bar1");
      assertEquals("OK", status);
  
      status = jedis.set("foo2", "bar2");
      assertEquals("OK", status);
  
      long reply = jedis.exists("foo1", "foo2");
      assertEquals(2, reply);
  
      long lreply = jedis.del("foo1");
      assertEquals(1, lreply);
  
      reply = jedis.exists("foo1", "foo2");
      assertEquals(1, reply);
    }
  
    @Test
    public void del() {
      jedis.set("foo1", "bar1");
      jedis.set("foo2", "bar2");
      jedis.set("foo3", "bar3");
  
      long reply = jedis.del("foo1", "foo2", "foo3");
      assertEquals(3, reply);
  
      Boolean breply = jedis.exists("foo1");
      assertFalse(breply);
      breply = jedis.exists("foo2");
      assertFalse(breply);
      breply = jedis.exists("foo3");
      assertFalse(breply);
  
      jedis.set("foo1", "bar1");
  
      reply = jedis.del("foo1", "foo2");
      assertEquals(1, reply);
  
      reply = jedis.del("foo1", "foo2");
      assertEquals(0, reply);
  
      // Binary ...
      jedis.set(bfoo1, bbar1);
      jedis.set(bfoo2, bbar2);
      jedis.set(bfoo3, bbar3);
  
      reply = jedis.del(bfoo1, bfoo2, bfoo3);
      assertEquals(3, reply);
  
      breply = jedis.exists(bfoo1);
      assertFalse(breply);
      breply = jedis.exists(bfoo2);
      assertFalse(breply);
      breply = jedis.exists(bfoo3);
      assertFalse(breply);
  
      jedis.set(bfoo1, bbar1);
  
      reply = jedis.del(bfoo1, bfoo2);
      assertEquals(1, reply);
  
      reply = jedis.del(bfoo1, bfoo2);
      assertEquals(0, reply);
    }
  
    @Test
    public void type() {
      jedis.set("foo", "bar");
      String status = jedis.type("foo");
      assertEquals("string", status);
  
      // Binary
      jedis.set(bfoo, bbar);
      status = jedis.type(bfoo);
      assertEquals("string", status);
    }
  
    @Test
    public void keys() {
      jedis.set("foo", "bar");
      jedis.set("foobar", "bar");
  
      Set<String> keys = jedis.keys("foo*");
      Set<String> expected = new HashSet<String>();
      expected.add("foo");
      expected.add("foobar");
      assertEquals(expected, keys);
  
      expected = new HashSet<String>();
      keys = jedis.keys("bar*");
  
      assertEquals(expected, keys);
  
      // Binary
      jedis.set(bfoo, bbar);
      jedis.set(bfoobar, bbar);
  
      Set<byte[]> bkeys = jedis.keys(bfoostar);
      assertEquals(2, bkeys.size());
      assertTrue(setContains(bkeys, bfoo));
      assertTrue(setContains(bkeys, bfoobar));
  
      bkeys = jedis.keys(bbarstar);
  
      assertEquals(0, bkeys.size());
    }
  
    @Test
    public void randomKey() {
      assertEquals(null, jedis.randomKey());
  
      jedis.set("foo", "bar");
  
      assertEquals("foo", jedis.randomKey());
  
      jedis.set("bar", "foo");
  
      String randomkey = jedis.randomKey();
      assertTrue(randomkey.equals("foo") || randomkey.equals("bar"));
  
      // Binary
      jedis.del("foo");
      jedis.del("bar");
      assertEquals(null, jedis.randomKey());
  
      jedis.set(bfoo, bbar);
  
      assertArrayEquals(bfoo, jedis.randomBinaryKey());
  
      jedis.set(bbar, bfoo);
  
      byte[] randomBkey = jedis.randomBinaryKey();
      assertTrue(Arrays.equals(randomBkey, bfoo) || Arrays.equals(randomBkey, bbar));
  
    }
  
    @Test
    public void rename() {
      jedis.set("foo", "bar");
      String status = jedis.rename("foo", "bar");
      assertEquals("OK", status);
  
      String value = jedis.get("foo");
      assertEquals(null, value);
  
      value = jedis.get("bar");
      assertEquals("bar", value);
  
      // Binary
      jedis.set(bfoo, bbar);
      String bstatus = jedis.rename(bfoo, bbar);
      assertEquals("OK", bstatus);
  
      byte[] bvalue = jedis.get(bfoo);
      assertEquals(null, bvalue);
  
      bvalue = jedis.get(bbar);
      assertArrayEquals(bbar, bvalue);
    }
  
    @Test
    public void renameOldAndNewAreTheSame() {
      jedis.set("foo", "bar");
      jedis.rename("foo", "foo");
  
      // Binary
      jedis.set(bfoo, bbar);
      jedis.rename(bfoo, bfoo);
    }
  
    @Test
    public void renamenx() {
      jedis.set("foo", "bar");
      long status = jedis.renamenx("foo", "bar");
      assertEquals(1, status);
  
      jedis.set("foo", "bar");
      status = jedis.renamenx("foo", "bar");
      assertEquals(0, status);
  
      // Binary
      jedis.set(bfoo, bbar);
      long bstatus = jedis.renamenx(bfoo, bbar);
      assertEquals(1, bstatus);
  
      jedis.set(bfoo, bbar);
      bstatus = jedis.renamenx(bfoo, bbar);
      assertEquals(0, bstatus);
  
    }
  
    @Test
    public void dbSize() {
      long size = jedis.dbSize();
      assertEquals(0, size);
  
      jedis.set("foo", "bar");
      size = jedis.dbSize();
      assertEquals(1, size);
  
      // Binary
      jedis.set(bfoo, bbar);
      size = jedis.dbSize();
      assertEquals(2, size);
    }
  
    @Test
    public void expire() {
      long status = jedis.expire("foo", 20);
      assertEquals(0, status);
  
      jedis.set("foo", "bar");
      status = jedis.expire("foo", 20);
      assertEquals(1, status);
  
      // Binary
      long bstatus = jedis.expire(bfoo, 20);
      assertEquals(0, bstatus);
  
      jedis.set(bfoo, bbar);
      bstatus = jedis.expire(bfoo, 20);
      assertEquals(1, bstatus);
  
    }
  
    @Test
    public void expireAt() {
      long unixTime = (System.currentTimeMillis() / 1000L) + 20;
  
      long status = jedis.expireAt("foo", unixTime);
      assertEquals(0, status);
  
      jedis.set("foo", "bar");
      unixTime = (System.currentTimeMillis() / 1000L) + 20;
      status = jedis.expireAt("foo", unixTime);
      assertEquals(1, status);
  
      // Binary
      long bstatus = jedis.expireAt(bfoo, unixTime);
      assertEquals(0, bstatus);
  
      jedis.set(bfoo, bbar);
      unixTime = (System.currentTimeMillis() / 1000L) + 20;
      bstatus = jedis.expireAt(bfoo, unixTime);
      assertEquals(1, bstatus);
  
    }
  
    @Test
    public void ttl() {
      long ttl = jedis.ttl("foo");
      assertEquals(-2, ttl);
  
      jedis.set("foo", "bar");
      ttl = jedis.ttl("foo");
      assertEquals(-1, ttl);
  
      jedis.expire("foo", 20);
      ttl = jedis.ttl("foo");
      assertTrue(ttl >= 0 && ttl <= 20);
  
      // Binary
      long bttl = jedis.ttl(bfoo);
      assertEquals(-2, bttl);
  
      jedis.set(bfoo, bbar);
      bttl = jedis.ttl(bfoo);
      assertEquals(-1, bttl);
  
      jedis.expire(bfoo, 20);
      bttl = jedis.ttl(bfoo);
      assertTrue(bttl >= 0 && bttl <= 20);
  
    }
  
    @Test
    public void select() {
      jedis.set("foo", "bar");
      String status = jedis.select(1);
      assertEquals("OK", status);
      assertEquals(null, jedis.get("foo"));
      status = jedis.select(0);
      assertEquals("OK", status);
      assertEquals("bar", jedis.get("foo"));
      // Binary
      jedis.set(bfoo, bbar);
      String bstatus = jedis.select(1);
      assertEquals("OK", bstatus);
      assertEquals(null, jedis.get(bfoo));
      bstatus = jedis.select(0);
      assertEquals("OK", bstatus);
      assertArrayEquals(bbar, jedis.get(bfoo));
    }
  
    @Test
    public void getDB() {
      assertEquals(0, jedis.getDB());
      jedis.select(1);
      assertEquals(1, jedis.getDB());
    }
  
    @Test
    public void move() {
      long status = jedis.move("foo", 1);
      assertEquals(0, status);
  
      jedis.set("foo", "bar");
      status = jedis.move("foo", 1);
      assertEquals(1, status);
      assertEquals(null, jedis.get("foo"));
  
      jedis.select(1);
      assertEquals("bar", jedis.get("foo"));
  
      // Binary
      jedis.select(0);
      long bstatus = jedis.move(bfoo, 1);
      assertEquals(0, bstatus);
  
      jedis.set(bfoo, bbar);
      bstatus = jedis.move(bfoo, 1);
      assertEquals(1, bstatus);
      assertEquals(null, jedis.get(bfoo));
  
      jedis.select(1);
      assertArrayEquals(bbar, jedis.get(bfoo));
  
    }
  
    @Test
    public void flushDB() {
      jedis.set("foo", "bar");
      assertEquals(1, jedis.dbSize().intValue());
      jedis.set("bar", "foo");
      jedis.move("bar", 1);
      String status = jedis.flushDB();
      assertEquals("OK", status);
      assertEquals(0, jedis.dbSize().intValue());
      jedis.select(1);
      assertEquals(1, jedis.dbSize().intValue());
      jedis.del("bar");
  
      // Binary
      jedis.select(0);
      jedis.set(bfoo, bbar);
      assertEquals(1, jedis.dbSize().intValue());
      jedis.set(bbar, bfoo);
      jedis.move(bbar, 1);
      String bstatus = jedis.flushDB();
      assertEquals("OK", bstatus);
      assertEquals(0, jedis.dbSize().intValue());
      jedis.select(1);
      assertEquals(1, jedis.dbSize().intValue());
  
    }
  
    @Test
    public void flushAll() {
      jedis.set("foo", "bar");
      assertEquals(1, jedis.dbSize().intValue());
      jedis.set("bar", "foo");
      jedis.move("bar", 1);
      String status = jedis.flushAll();
      assertEquals("OK", status);
      assertEquals(0, jedis.dbSize().intValue());
      jedis.select(1);
      assertEquals(0, jedis.dbSize().intValue());
  
      // Binary
      jedis.select(0);
      jedis.set(bfoo, bbar);
      assertEquals(1, jedis.dbSize().intValue());
      jedis.set(bbar, bfoo);
      jedis.move(bbar, 1);
      String bstatus = jedis.flushAll();
      assertEquals("OK", bstatus);
      assertEquals(0, jedis.dbSize().intValue());
      jedis.select(1);
      assertEquals(0, jedis.dbSize().intValue());
  
    }
  
    @Test
    public void persist() {
      jedis.setex("foo", 60 * 60, "bar");
      assertTrue(jedis.ttl("foo") > 0);
      long status = jedis.persist("foo");
      assertEquals(1, status);
      assertEquals(-1, jedis.ttl("foo").intValue());
  
      // Binary
      jedis.setex(bfoo, 60 * 60, bbar);
      assertTrue(jedis.ttl(bfoo) > 0);
      long bstatus = jedis.persist(bfoo);
      assertEquals(1, bstatus);
      assertEquals(-1, jedis.ttl(bfoo).intValue());
  
    }
  
    @Test
    public void echo() {
      String result = jedis.echo("hello world");
      assertEquals("hello world", result);
  
      // Binary
      byte[] bresult = jedis.echo(SafeEncoder.encode("hello world"));
      assertArrayEquals(SafeEncoder.encode("hello world"), bresult);
    }
  
    @Test
    public void dumpAndRestore() {
      jedis.set("foo1", "bar1");
      byte[] sv = jedis.dump("foo1");
      jedis.restore("foo2", 0, sv);
      assertTrue(jedis.exists("foo2"));
    }
  
    @Test
    public void pexpire() {
      long status = jedis.pexpire("foo", 10000);
      assertEquals(0, status);
  
      jedis.set("foo1", "bar1");
      status = jedis.pexpire("foo1", 10000);
      assertEquals(1, status);
  
      jedis.set("foo2", "bar2");
      status = jedis.pexpire("foo2", 200000000000L);
      assertEquals(1, status);
  
      long pttl = jedis.pttl("foo2");
      assertTrue(pttl > 100000000000L);
    }
  
    @Test
    public void pexpireAt() {
      long unixTime = (System.currentTimeMillis()) + 10000;
  
      long status = jedis.pexpireAt("foo", unixTime);
      assertEquals(0, status);
  
      jedis.set("foo", "bar");
      unixTime = (System.currentTimeMillis()) + 10000;
      status = jedis.pexpireAt("foo", unixTime);
      assertEquals(1, status);
    }
  
    @Test
    public void pttl() {
      long pttl = jedis.pttl("foo");
      assertEquals(-2, pttl);
  
      jedis.set("foo", "bar");
      pttl = jedis.pttl("foo");
      assertEquals(-1, pttl);
  
      jedis.pexpire("foo", 20000);
      pttl = jedis.pttl("foo");
      assertTrue(pttl >= 0 && pttl <= 20000);
    }
  
    @Test
    public void psetex() {
      long pttl = jedis.pttl("foo");
      assertEquals(-2, pttl);
  
      String status = jedis.psetex("foo", 200000000000L, "bar");
      assertTrue(Keyword.OK.name().equalsIgnoreCase(status));
  
      pttl = jedis.pttl("foo");
      assertTrue(pttl > 100000000000L);
    }
  
    @Test
    public void scan() {
      jedis.set("b", "b");
      jedis.set("a", "a");
  
      ScanResult<String> result = jedis.scan(SCAN_POINTER_START);
  
      assertEquals(SCAN_POINTER_START, result.getCursor());
      assertFalse(result.getResult().isEmpty());
  
      // binary
      ScanResult<byte[]> bResult = jedis.scan(SCAN_POINTER_START_BINARY);
  
      assertArrayEquals(SCAN_POINTER_START_BINARY, bResult.getCursorAsBytes());
      assertFalse(bResult.getResult().isEmpty());
    }
  
    @Test
    public void scanMatch() {
      ScanParams params = new ScanParams();
      params.match("a*");
  
      jedis.set("b", "b");
      jedis.set("a", "a");
      jedis.set("aa", "aa");
      ScanResult<String> result = jedis.scan(SCAN_POINTER_START, params);
  
      assertEquals(SCAN_POINTER_START, result.getCursor());
      assertFalse(result.getResult().isEmpty());
  
      // binary
      params = new ScanParams();
      params.match(bfoostar);
  
      jedis.set(bfoo1, bbar);
      jedis.set(bfoo2, bbar);
      jedis.set(bfoo3, bbar);
  
      ScanResult<byte[]> bResult = jedis.scan(SCAN_POINTER_START_BINARY, params);
  
      assertArrayEquals(SCAN_POINTER_START_BINARY, bResult.getCursorAsBytes());
      assertFalse(bResult.getResult().isEmpty());
    }
  
    @Test
    public void scanCount() {
      ScanParams params = new ScanParams();
      params.count(2);
  
      for (int i = 0; i < 10; i++) {
        jedis.set("a" + i, "a" + i);
      }
  
      ScanResult<String> result = jedis.scan(SCAN_POINTER_START, params);
  
      assertFalse(result.getResult().isEmpty());
  
      // binary
      params = new ScanParams();
      params.count(2);
  
      jedis.set(bfoo1, bbar);
      jedis.set(bfoo2, bbar);
      jedis.set(bfoo3, bbar);
  
      ScanResult<byte[]> bResult = jedis.scan(SCAN_POINTER_START_BINARY, params);
  
      assertFalse(bResult.getResult().isEmpty());
    }
  
    @Test
    public void setNxExAndGet() {
      String status = jedis.set("hello", "world", setParams().nx().ex(expireSeconds));
      assertTrue(Keyword.OK.name().equalsIgnoreCase(status));
      String value = jedis.get("hello");
      assertEquals("world", value);
  
      jedis.set("hello", "bar", setParams().nx().ex(expireSeconds));
      value = jedis.get("hello");
      assertEquals("world", value);
  
      long ttl = jedis.ttl("hello");
      assertTrue(ttl > 0 && ttl <= expireSeconds);
  
      // binary
      byte[] bworld = { 0x77, 0x6F, 0x72, 0x6C, 0x64 };
      byte[] bhello = { 0x68, 0x65, 0x6C, 0x6C, 0x6F };
  
      String bstatus = jedis.set(bworld, bhello, setParams().nx().ex(expireSeconds));
      assertTrue(Keyword.OK.name().equalsIgnoreCase(bstatus));
      byte[] bvalue = jedis.get(bworld);
      assertTrue(Arrays.equals(bhello, bvalue));
  
      jedis.set(bworld, bbar, setParams().nx().ex(expireSeconds));
      bvalue = jedis.get(bworld);
      assertTrue(Arrays.equals(bhello, bvalue));
  
      long bttl = jedis.ttl(bworld);
      assertTrue(bttl > 0 && bttl <= expireSeconds);
    }
  }
  