content: package redis.clients.jedis.tests.commands;
  
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.LinkedHashSet;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  
  import org.junit.Test;
  
  public class VariadicCommandsTest extends JedisCommandTestBase {
    final byte[] bfoo = { 0x01, 0x02, 0x03, 0x04 };
    final byte[] bbar = { 0x05, 0x06, 0x07, 0x08 };
    final byte[] bcar = { 0x09, 0x0A, 0x0B, 0x0C };
    final byte[] bfoo1 = { 0x01, 0x02, 0x03, 0x04, 0x0A };
    final byte[] bfoo2 = { 0x01, 0x02, 0x03, 0x04, 0x0B };
  
    @Test
    public void hdel() {
      Map<String, String> hash = new HashMap<String, String>();
      hash.put("bar", "car");
      hash.put("car", "bar");
      hash.put("foo2", "bar");
      jedis.hmset("foo", hash);
  
      assertEquals(0, jedis.hdel("bar", "foo", "foo1").intValue());
      assertEquals(0, jedis.hdel("foo", "foo", "foo1").intValue());
      assertEquals(2, jedis.hdel("foo", "bar", "foo2").intValue());
      assertEquals(null, jedis.hget("foo", "bar"));
  
      // Binary
      Map<byte[], byte[]> bhash = new HashMap<byte[], byte[]>();
      bhash.put(bbar, bcar);
      bhash.put(bcar, bbar);
      bhash.put(bfoo2, bbar);
      jedis.hmset(bfoo, bhash);
  
      assertEquals(0, jedis.hdel(bbar, bfoo, bfoo1).intValue());
      assertEquals(0, jedis.hdel(bfoo, bfoo, bfoo1).intValue());
      assertEquals(2, jedis.hdel(bfoo, bbar, bfoo2).intValue());
      assertEquals(null, jedis.hget(bfoo, bbar));
  
    }
  
    @Test
    public void rpush() {
      long size = jedis.rpush("foo", "bar", "foo");
      assertEquals(2, size);
  
      List<String> expected = new ArrayList<String>();
      expected.add("bar");
      expected.add("foo");
  
      List<String> values = jedis.lrange("foo", 0, -1);
      assertEquals(expected, values);
  
      // Binary
      size = jedis.rpush(bfoo, bbar, bfoo);
      assertEquals(2, size);
  
      List<byte[]> bexpected = new ArrayList<byte[]>();
      bexpected.add(bbar);
      bexpected.add(bfoo);
  
      List<byte[]> bvalues = jedis.lrange(bfoo, 0, -1);
      assertEquals(bexpected, bvalues);
  
    }
  
    @Test
    public void lpush() {
      long size = jedis.lpush("foo", "bar", "foo");
      assertEquals(2, size);
  
      List<String> expected = new ArrayList<String>();
      expected.add("foo");
      expected.add("bar");
  
      List<String> values = jedis.lrange("foo", 0, -1);
      assertEquals(expected, values);
  
      // Binary
      size = jedis.lpush(bfoo, bbar, bfoo);
      assertEquals(2, size);
  
      List<byte[]> bexpected = new ArrayList<byte[]>();
      bexpected.add(bfoo);
      bexpected.add(bbar);
  
      List<byte[]> bvalues = jedis.lrange(bfoo, 0, -1);
      assertEquals(bexpected, bvalues);
  
    }
  
    @Test
    public void sadd() {
      long status = jedis.sadd("foo", "bar", "foo1");
      assertEquals(2, status);
  
      status = jedis.sadd("foo", "bar", "car");
      assertEquals(1, status);
  
      status = jedis.sadd("foo", "bar", "foo1");
      assertEquals(0, status);
  
      status = jedis.sadd(bfoo, bbar, bfoo1);
      assertEquals(2, status);
  
      status = jedis.sadd(bfoo, bbar, bcar);
      assertEquals(1, status);
  
      status = jedis.sadd(bfoo, bbar, bfoo1);
      assertEquals(0, status);
  
    }
  
    @Test
    public void zadd() {
      Map<String, Double> scoreMembers = new HashMap<String, Double>();
      scoreMembers.put("bar", 1d);
      scoreMembers.put("foo", 10d);
  
      long status = jedis.zadd("foo", scoreMembers);
      assertEquals(2, status);
  
      scoreMembers.clear();
      scoreMembers.put("car", 0.1d);
      scoreMembers.put("bar", 2d);
  
      status = jedis.zadd("foo", scoreMembers);
      assertEquals(1, status);
  
      Map<byte[], Double> bscoreMembers = new HashMap<byte[], Double>();
      bscoreMembers.put(bbar, 1d);
      bscoreMembers.put(bfoo, 10d);
  
      status = jedis.zadd(bfoo, bscoreMembers);
      assertEquals(2, status);
  
      bscoreMembers.clear();
      bscoreMembers.put(bcar, 0.1d);
      bscoreMembers.put(bbar, 2d);
  
      status = jedis.zadd(bfoo, bscoreMembers);
      assertEquals(1, status);
  
    }
  
    @Test
    public void zrem() {
      jedis.zadd("foo", 1d, "bar");
      jedis.zadd("foo", 2d, "car");
      jedis.zadd("foo", 3d, "foo1");
  
      long status = jedis.zrem("foo", "bar", "car");
  
      Set<String> expected = new LinkedHashSet<String>();
      expected.add("foo1");
  
      assertEquals(2, status);
      assertEquals(expected, jedis.zrange("foo", 0, 100));
  
      status = jedis.zrem("foo", "bar", "car");
      assertEquals(0, status);
  
      status = jedis.zrem("foo", "bar", "foo1");
      assertEquals(1, status);
  
      // Binary
      jedis.zadd(bfoo, 1d, bbar);
      jedis.zadd(bfoo, 2d, bcar);
      jedis.zadd(bfoo, 3d, bfoo1);
  
      status = jedis.zrem(bfoo, bbar, bcar);
  
      Set<byte[]> bexpected = new LinkedHashSet<byte[]>();
      bexpected.add(bfoo);
  
      assertEquals(2, status);
      assertEquals(bexpected, jedis.zrange(bfoo, 0, 100));
  
      status = jedis.zrem(bfoo, bbar, bcar);
      assertEquals(0, status);
  
      status = jedis.zrem(bfoo, bbar, bfoo1);
      assertEquals(1, status);
  
    }
  }