content: package redis.clients.jedis.tests.commands;
  
  import org.junit.Test;
  
  import redis.clients.jedis.BitOP;
  import redis.clients.jedis.BitPosParams;
  import redis.clients.jedis.Protocol;
  
  public class BitCommandsTest extends JedisCommandTestBase {
    @Test
    public void setAndgetbit() {
      boolean bit = jedis.setbit("foo", 0, true);
      assertEquals(false, bit);
  
      bit = jedis.getbit("foo", 0);
      assertEquals(true, bit);
  
      boolean bbit = jedis.setbit("bfoo".getBytes(), 0, "1".getBytes());
      assertFalse(bbit);
  
      bbit = jedis.getbit("bfoo".getBytes(), 0);
      assertTrue(bbit);
    }
  
    @Test
    public void bitpos() {
      String foo = "foo";
  
      jedis.set(foo, String.valueOf(0));
  
      jedis.setbit(foo, 3, true);
      jedis.setbit(foo, 7, true);
      jedis.setbit(foo, 13, true);
      jedis.setbit(foo, 39, true);
  
      /*
       * byte: 0 1 2 3 4 bit: 00010001 / 00000100 / 00000000 / 00000000 / 00000001
       */
      long offset = jedis.bitpos(foo, true);
      assertEquals(2, offset);
      offset = jedis.bitpos(foo, false);
      assertEquals(0, offset);
  
      offset = jedis.bitpos(foo, true, new BitPosParams(1));
      assertEquals(13, offset);
      offset = jedis.bitpos(foo, false, new BitPosParams(1));
      assertEquals(8, offset);
  
      offset = jedis.bitpos(foo, true, new BitPosParams(2, 3));
      assertEquals(-1, offset);
      offset = jedis.bitpos(foo, false, new BitPosParams(2, 3));
      assertEquals(16, offset);
  
      offset = jedis.bitpos(foo, true, new BitPosParams(3, 4));
      assertEquals(39, offset);
    }
  
    @Test
    public void bitposBinary() {
      // binary
      byte[] bfoo = { 0x01, 0x02, 0x03, 0x04 };
  
      jedis.set(bfoo, Protocol.toByteArray(0));
  
      jedis.setbit(bfoo, 3, true);
      jedis.setbit(bfoo, 7, true);
      jedis.setbit(bfoo, 13, true);
      jedis.setbit(bfoo, 39, true);
  
      /*
       * byte: 0 1 2 3 4 bit: 00010001 / 00000100 / 00000000 / 00000000 / 00000001
       */
      long offset = jedis.bitpos(bfoo, true);
      assertEquals(2, offset);
      offset = jedis.bitpos(bfoo, false);
      assertEquals(0, offset);
  
      offset = jedis.bitpos(bfoo, true, new BitPosParams(1));
      assertEquals(13, offset);
      offset = jedis.bitpos(bfoo, false, new BitPosParams(1));
      assertEquals(8, offset);
  
      offset = jedis.bitpos(bfoo, true, new BitPosParams(2, 3));
      assertEquals(-1, offset);
      offset = jedis.bitpos(bfoo, false, new BitPosParams(2, 3));
      assertEquals(16, offset);
  
      offset = jedis.bitpos(bfoo, true, new BitPosParams(3, 4));
      assertEquals(39, offset);
    }
  
    @Test
    public void bitposWithNoMatchingBitExist() {
      String foo = "foo";
  
      jedis.set(foo, String.valueOf(0));
      for (int idx = 0; idx < 8; idx++) {
        jedis.setbit(foo, idx, true);
      }
  
      /*
       * byte: 0 bit: 11111111
       */
      long offset = jedis.bitpos(foo, false);
      // offset should be last index + 1
      assertEquals(8, offset);
    }
  
    @Test
    public void bitposWithNoMatchingBitExistWithinRange() {
      String foo = "foo";
  
      jedis.set(foo, String.valueOf(0));
      for (int idx = 0; idx < 8 * 5; idx++) {
        jedis.setbit(foo, idx, true);
      }
  
      /*
       * byte: 0 1 2 3 4 bit: 11111111 / 11111111 / 11111111 / 11111111 / 11111111
       */
      long offset = jedis.bitpos(foo, false, new BitPosParams(2, 3));
      // offset should be -1
      assertEquals(-1, offset);
    }
  
    @Test
    public void setAndgetrange() {
      jedis.set("key1", "Hello World");
      long reply = jedis.setrange("key1", 6, "Jedis");
      assertEquals(11, reply);
  
      assertEquals(jedis.get("key1"), "Hello Jedis");
  
      assertEquals("Hello", jedis.getrange("key1", 0, 4));
      assertEquals("Jedis", jedis.getrange("key1", 6, 11));
    }
  
    @Test
    public void bitCount() {
      jedis.del("foo");
  
      jedis.setbit("foo", 16, true);
      jedis.setbit("foo", 24, true);
      jedis.setbit("foo", 40, true);
      jedis.setbit("foo", 56, true);
  
      long c4 = jedis.bitcount("foo");
      assertEquals(4, c4);
  
      long c3 = jedis.bitcount("foo", 2L, 5L);
      assertEquals(3, c3);
  
      jedis.del("foo");
    }
  
    @Test
    public void bitOp() {
      jedis.set("key1", "\u0060");
      jedis.set("key2", "\u0044");
  
      jedis.bitop(BitOP.AND, "resultAnd", "key1", "key2");
      String resultAnd = jedis.get("resultAnd");
      assertEquals("\u0040", resultAnd);
  
      jedis.bitop(BitOP.OR, "resultOr", "key1", "key2");
      String resultOr = jedis.get("resultOr");
      assertEquals("\u0064", resultOr);
  
      jedis.bitop(BitOP.XOR, "resultXor", "key1", "key2");
      String resultXor = jedis.get("resultXor");
      assertEquals("\u0024", resultXor);
  
      jedis.del("resultAnd");
      jedis.del("resultOr");
      jedis.del("resultXor");
      jedis.del("key1");
      jedis.del("key2");
    }
  
    @Test
    public void bitOpNot() {
      jedis.del("key");
      jedis.setbit("key", 0, true);
      jedis.setbit("key", 4, true);
  
      jedis.bitop(BitOP.NOT, "resultNot", "key");
  
      String resultNot = jedis.get("resultNot");
      assertEquals("\u0077", resultNot);
  
      jedis.del("key");
      jedis.del("resultNot");
    }
  }
  