content: package redis.clients.jedis.tests.commands;
  
  import static redis.clients.jedis.params.set.SetParams.setParams;
  
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.List;
  
  import org.junit.Before;
  import org.junit.Test;
  
  import redis.clients.jedis.Protocol.Keyword;
  import redis.clients.jedis.exceptions.JedisDataException;
  
  public class BinaryValuesCommandsTest extends JedisCommandTestBase {
    byte[] bfoo = { 0x01, 0x02, 0x03, 0x04 };
    byte[] bbar = { 0x05, 0x06, 0x07, 0x08 };
    byte[] bxx = { 0x78, 0x78 };
    byte[] bnx = { 0x6E, 0x78 };
    byte[] bex = { 0x65, 0x78 };
    byte[] bpx = { 0x70, 0x78 };
    int expireSeconds = 2;
    long expireMillis = expireSeconds * 1000;
    byte[] binaryValue;
  
    @Before
    public void startUp() {
      StringBuilder sb = new StringBuilder();
  
      for (int n = 0; n < 1000; n++) {
        sb.append("A");
      }
  
      binaryValue = sb.toString().getBytes();
    }
  
    @Test
    public void setAndGet() {
      String status = jedis.set(bfoo, binaryValue);
      assertTrue(Keyword.OK.name().equalsIgnoreCase(status));
  
      byte[] value = jedis.get(bfoo);
      assertTrue(Arrays.equals(binaryValue, value));
  
      assertNull(jedis.get(bbar));
    }
  
    @Test
    public void setNxExAndGet() {
      String status = jedis.set(bfoo, binaryValue, setParams().nx().ex(expireSeconds));
      assertTrue(Keyword.OK.name().equalsIgnoreCase(status));
      byte[] value = jedis.get(bfoo);
      assertTrue(Arrays.equals(binaryValue, value));
  
      assertNull(jedis.get(bbar));
    }
  
    @Test
    public void setIfNotExistAndGet() {
      String status = jedis.set(bfoo, binaryValue);
      assertTrue(Keyword.OK.name().equalsIgnoreCase(status));
      // nx should fail if value exists
      String statusFail = jedis.set(bfoo, binaryValue, setParams().nx().ex(expireSeconds));
      assertNull(statusFail);
  
      byte[] value = jedis.get(bfoo);
      assertTrue(Arrays.equals(binaryValue, value));
  
      assertNull(jedis.get(bbar));
    }
  
    @Test
    public void setIfExistAndGet() {
      String status = jedis.set(bfoo, binaryValue);
      assertTrue(Keyword.OK.name().equalsIgnoreCase(status));
      // nx should fail if value exists
      String statusSuccess = jedis.set(bfoo, binaryValue, setParams().xx().ex(expireSeconds));
      assertTrue(Keyword.OK.name().equalsIgnoreCase(statusSuccess));
  
      byte[] value = jedis.get(bfoo);
      assertTrue(Arrays.equals(binaryValue, value));
  
      assertNull(jedis.get(bbar));
    }
  
    @Test
    public void setFailIfNotExistAndGet() {
      // xx should fail if value does NOT exists
      String statusFail = jedis.set(bfoo, binaryValue, setParams().xx().ex(expireSeconds));
      assertNull(statusFail);
    }
  
    @Test
    public void setAndExpireMillis() {
      String status = jedis.set(bfoo, binaryValue, setParams().nx().px(expireMillis));
      assertTrue(Keyword.OK.name().equalsIgnoreCase(status));
      long ttl = jedis.ttl(bfoo);
      assertTrue(ttl > 0 && ttl <= expireSeconds);
    }
  
    @Test
    public void setAndExpire() {
      String status = jedis.set(bfoo, binaryValue, setParams().nx().ex(expireSeconds));
      assertTrue(Keyword.OK.name().equalsIgnoreCase(status));
      long ttl = jedis.ttl(bfoo);
      assertTrue(ttl > 0 && ttl <= expireSeconds);
    }
  
    @Test
    public void getSet() {
      byte[] value = jedis.getSet(bfoo, binaryValue);
      assertNull(value);
      value = jedis.get(bfoo);
      assertTrue(Arrays.equals(binaryValue, value));
    }
  
    @Test
    public void mget() {
      List<byte[]> values = jedis.mget(bfoo, bbar);
      List<byte[]> expected = new ArrayList<byte[]>();
      expected.add(null);
      expected.add(null);
  
      assertEquals(expected, values);
  
      jedis.set(bfoo, binaryValue);
  
      expected = new ArrayList<byte[]>();
      expected.add(binaryValue);
      expected.add(null);
      values = jedis.mget(bfoo, bbar);
  
      assertEquals(expected, values);
  
      jedis.set(bbar, bfoo);
  
      expected = new ArrayList<byte[]>();
      expected.add(binaryValue);
      expected.add(bfoo);
      values = jedis.mget(bfoo, bbar);
  
      assertEquals(expected, values);
    }
  
    @Test
    public void setnx() {
      long status = jedis.setnx(bfoo, binaryValue);
      assertEquals(1, status);
      assertTrue(Arrays.equals(binaryValue, jedis.get(bfoo)));
  
      status = jedis.setnx(bfoo, bbar);
      assertEquals(0, status);
      assertTrue(Arrays.equals(binaryValue, jedis.get(bfoo)));
    }
  
    @Test
    public void setex() {
      String status = jedis.setex(bfoo, 20, binaryValue);
      assertEquals(Keyword.OK.name(), status);
      long ttl = jedis.ttl(bfoo);
      assertTrue(ttl > 0 && ttl <= 20);
    }
  
    @Test
    public void mset() {
      String status = jedis.mset(bfoo, binaryValue, bbar, bfoo);
      assertEquals(Keyword.OK.name(), status);
      assertTrue(Arrays.equals(binaryValue, jedis.get(bfoo)));
      assertTrue(Arrays.equals(bfoo, jedis.get(bbar)));
    }
  
    @Test
    public void msetnx() {
      long status = jedis.msetnx(bfoo, binaryValue, bbar, bfoo);
      assertEquals(1, status);
      assertTrue(Arrays.equals(binaryValue, jedis.get(bfoo)));
      assertTrue(Arrays.equals(bfoo, jedis.get(bbar)));
  
      status = jedis.msetnx(bfoo, bbar, "bar2".getBytes(), "foo2".getBytes());
      assertEquals(0, status);
      assertTrue(Arrays.equals(binaryValue, jedis.get(bfoo)));
      assertTrue(Arrays.equals(bfoo, jedis.get(bbar)));
    }
  
    @Test(expected = JedisDataException.class)
    public void incrWrongValue() {
      jedis.set(bfoo, binaryValue);
      jedis.incr(bfoo);
    }
  
    @Test
    public void incr() {
      long value = jedis.incr(bfoo);
      assertEquals(1, value);
      value = jedis.incr(bfoo);
      assertEquals(2, value);
    }
  
    @Test(expected = JedisDataException.class)
    public void incrByWrongValue() {
      jedis.set(bfoo, binaryValue);
      jedis.incrBy(bfoo, 2);
    }
  
    @Test
    public void incrBy() {
      long value = jedis.incrBy(bfoo, 2);
      assertEquals(2, value);
      value = jedis.incrBy(bfoo, 2);
      assertEquals(4, value);
    }
  
    @Test(expected = JedisDataException.class)
    public void decrWrongValue() {
      jedis.set(bfoo, binaryValue);
      jedis.decr(bfoo);
    }
  
    @Test
    public void decr() {
      long value = jedis.decr(bfoo);
      assertEquals(-1, value);
      value = jedis.decr(bfoo);
      assertEquals(-2, value);
    }
  
    @Test(expected = JedisDataException.class)
    public void decrByWrongValue() {
      jedis.set(bfoo, binaryValue);
      jedis.decrBy(bfoo, 2);
    }
  
    @Test
    public void decrBy() {
      long value = jedis.decrBy(bfoo, 2);
      assertEquals(-2, value);
      value = jedis.decrBy(bfoo, 2);
      assertEquals(-4, value);
    }
  
    @Test
    public void append() {
      byte[] first512 = new byte[512];
      System.arraycopy(binaryValue, 0, first512, 0, 512);
      long value = jedis.append(bfoo, first512);
      assertEquals(512, value);
      assertTrue(Arrays.equals(first512, jedis.get(bfoo)));
  
      byte[] rest = new byte[binaryValue.length - 512];
      System.arraycopy(binaryValue, 512, rest, 0, binaryValue.length - 512);
      value = jedis.append(bfoo, rest);
      assertEquals(binaryValue.length, value);
  
      assertTrue(Arrays.equals(binaryValue, jedis.get(bfoo)));
    }
  
    @Test
    public void substr() {
      jedis.set(bfoo, binaryValue);
  
      byte[] first512 = new byte[512];
      System.arraycopy(binaryValue, 0, first512, 0, 512);
      byte[] rfirst512 = jedis.substr(bfoo, 0, 511);
      assertTrue(Arrays.equals(first512, rfirst512));
  
      byte[] last512 = new byte[512];
      System.arraycopy(binaryValue, binaryValue.length - 512, last512, 0, 512);
      assertTrue(Arrays.equals(last512, jedis.substr(bfoo, -512, -1)));
  
      assertTrue(Arrays.equals(binaryValue, jedis.substr(bfoo, 0, -1)));
  
      assertTrue(Arrays.equals(last512, jedis.substr(bfoo, binaryValue.length - 512, 100000)));
    }
  
    @Test
    public void strlen() {
      jedis.set(bfoo, binaryValue);
      assertEquals(binaryValue.length, jedis.strlen(bfoo).intValue());
    }
  }