RedisMockClient (redis-java 0.0.5 API)

java.lang.Object
- org.rarefiedredis.redis.AbstractRedisMock
- - org.rarefiedredis.redis.RedisMockClient

All Implemented Interfaces:

IRedis, IRedisClient, IRedisHash, IRedisKeys, IRedisList, IRedisSet, IRedisSortedSet, IRedisString, IRedisTransaction
```
public final class RedisMockClient
extends AbstractRedisMock
```

Nested Class Summary
- Nested classes/interfaces inherited from interface org.rarefiedredis.redis.IRedisSortedSet
  IRedisSortedSet.ZsetPair

Constructor Summary

Constructors
Constructor and Description

RedisMockClient(RedisMock redisMock)

Constructors
Constructor and Description
`RedisMockClient(RedisMock redisMock)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Long`	`append(String key, String value)` Append value onto key.
`Long`	`bitcount(String key, long... options)` Count the number of set bits in a string.
`Long`	`bitop(String operation, String destkey, String... keys)` Perform a bitwise operation between multiple keys and store the result in the destination key.
`Long`	`bitpos(String key, long bit, long... options)` Return the position of the first bit set to 0 or 1 in a string.
`IRedisClient`	`createClient()` IRedis special overrides
`Long`	`decr(String key)` Decrement the number stored at key by one.
`Long`	`decrby(String key, long decrement)` Decrement the number stored at key by the given decrement.
`Long`	`del(String... keys)`
`String`	`discard()`
`List<Object>`	`exec()`
`Boolean`	`exists(String key)`
`Boolean`	`expire(String key, int seconds)`
`Boolean`	`expireat(String key, long timestamp)`
`String`	`get(String key)` Get the value of a key.
`Boolean`	`getbit(String key, long offset)` Returns the bit value at offset in the string value stored at key.
`String`	`getrange(String key, long start, long end)` Returns the substring of the string value stored at key, determined by the inclusive offsets start and end.
`String`	`getset(String key, String value)` Atomically set a key and return its previous value.
`Long`	`hdel(String key, String field, String... fields)`
`Boolean`	`hexists(String key, String field)`
`String`	`hget(String key, String field)`
`Map<String,String>`	`hgetall(String key)`
`Long`	`hincrby(String key, String field, long increment)`
`String`	`hincrbyfloat(String key, String field, double increment)`
`Set<String>`	`hkeys(String key)`
`Long`	`hlen(String key)`
`List<String>`	`hmget(String key, String field, String... fields)`
`String`	`hmset(String key, String field, String value, String... fieldsvalues)`
`ScanResult<Map<String,String>>`	`hscan(String key, long cursor, String... options)`
`Boolean`	`hset(String key, String field, String value)`
`Boolean`	`hsetnx(String key, String field, String value)`
`Long`	`hstrlen(String key, String field)`
`List<String>`	`hvals(String key)`
`Long`	`incr(String key)` Increment the number stored at key by one.
`Long`	`incrby(String key, long increment)` Increment the number stored at key by the given increment.
`String`	`incrbyfloat(String key, double increment)` Increment the number stored at key by the given increment.
`String`	`lindex(String key, long index)`
`Long`	`linsert(String key, String before_after, String pivot, String value)`
`Long`	`llen(String key)`
`String`	`lpop(String key)`
`Long`	`lpush(String key, String element, String... elements)`
`Long`	`lpushx(String key, String element)`
`List<String>`	`lrange(String key, long start, long end)`
`Long`	`lrem(String key, long count, String element)`
`String`	`lset(String key, long index, String element)`
`String`	`ltrim(String key, long start, long end)`
`String[]`	`mget(String... keys)` Returns the values of all specified keys.
`boolean`	`modified(Integer hashCode, String command, List<Object> args)` Determine if a command might be operating on a modified key.
`String`	`mset(String... keyvalues)` Sets the given keys to their respective values.
`Boolean`	`msetnx(String... keyvalues)` Sets the given keys to their respective values.
`IRedisClient`	`multi()`
`Boolean`	`persist(String key)`
`Boolean`	`pexpire(String key, long milliseconds)`
`Boolean`	`pexpireat(String key, long timestamp)`
`String`	`psetex(String key, long milliseconds, String value)` Set and expire a key in milliseconds.
`String`	`rpop(String key)`
`String`	`rpoplpush(String source, String dest)`
`Long`	`rpush(String key, String element, String... elements)`
`Long`	`rpushx(String key, String element)`
`Long`	`sadd(String key, String member, String... members)`
`Long`	`scard(String key)`
`Set<String>`	`sdiff(String key, String... keys)`
`Long`	`sdiffstore(String destination, String key, String... keys)`
`String`	`set(String key, String value, String... options)` Set key to hold the string value.
`Long`	`setbit(String key, long offset, boolean value)` Sets or clears the bit at offset in the string value stored at key.
`String`	`setex(String key, int seconds, String value)` Set and expire a key in seconds.
`Long`	`setnx(String key, String value)` Set a key only if it does not already exist.
`Long`	`setrange(String key, long offset, String value)` Ovewrite part of the string starting at offset with value.
`Set<String>`	`sinter(String key, String... keys)`
`Long`	`sinterstore(String destination, String key, String... keys)`
`Boolean`	`sismember(String key, String member)`
`Set<String>`	`smembers(String key)`
`Boolean`	`smove(String source, String dest, String member)`
`String`	`spop(String key)`
`String`	`srandmember(String key)`
`List<String>`	`srandmember(String key, long count)`
`Long`	`srem(String key, String member, String... members)`
`ScanResult<Set<String>>`	`sscan(String key, long cursor, String... options)`
`Long`	`strlen(String key)` Return the length of the string at key.
`Set<String>`	`sunion(String key, String... keys)`
`Long`	`sunionstore(String destination, String key, String... keys)`
`String`	`type(String key)`
`String`	`unwatch()`
`String`	`watch(String key)`

Methods inherited from class org.rarefiedredis.redis.AbstractRedisMock
dump, keys, migrate, move, object, pttl, randomkey, rename, renamenx, restore, scan, sort, ttl, zadd, zcard, zcount, zincrby, zinterstore, zlexcount, zrange, zrangebylex, zrangebyscore, zrank, zrem, zremrangebylex, zremrangebyrank, zremrangebyscore, zrevrange, zrevrangebylex, zrevrangebyscore, zrevrank, zscan, zscore, zunionstore

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - RedisMockClient
```
public RedisMockClient(RedisMock redisMock)
```
- Method Detail
  - createClient
```
public IRedisClient createClient()
```
    Description copied from class: AbstractRedisMock
    
    IRedis special overrides
    
    Specified by:
    
    createClient in interface IRedis
    
    Specified by:
    
    createClient in class AbstractRedisMock
    
    Returns:
    
    A client of this IRedis instance.
  - modified
```
public boolean modified(Integer hashCode,
                        String command,
                        List<Object> args)
```
    Description copied from interface: IRedis
    
    Determine if a command might be operating on a modified key. Useful for, e.g., watch/multi.
    
    Specified by:
    
    modified in interface IRedis
    
    Specified by:
    
    modified in class AbstractRedisMock
    
    Parameters:
    
    hashCode - Hash code for the interested object.
    
    command - The redis command.
    
    args - Arguments to the command.
    
    Returns:
    
    true if the command would operate on a key that has been modified; false otherwise.
  - del
```
public Long del(String... keys)
```
    Specified by:
    
    del in interface IRedisKeys
    
    Overrides:
    
    del in class AbstractRedisMock
  - exists
```
public Boolean exists(String key)
```
    Specified by:
    
    exists in interface IRedisKeys
    
    Overrides:
    
    exists in class AbstractRedisMock
  - expire
```
public Boolean expire(String key,
                      int seconds)
```
    Specified by:
    
    expire in interface IRedisKeys
    
    Overrides:
    
    expire in class AbstractRedisMock
  - expireat
```
public Boolean expireat(String key,
                        long timestamp)
```
    Specified by:
    
    expireat in interface IRedisKeys
    
    Overrides:
    
    expireat in class AbstractRedisMock
  - persist
```
public Boolean persist(String key)
```
    Specified by:
    
    persist in interface IRedisKeys
    
    Overrides:
    
    persist in class AbstractRedisMock
  - pexpire
```
public Boolean pexpire(String key,
                       long milliseconds)
```
    Specified by:
    
    pexpire in interface IRedisKeys
    
    Overrides:
    
    pexpire in class AbstractRedisMock
  - pexpireat
```
public Boolean pexpireat(String key,
                         long timestamp)
```
    Specified by:
    
    pexpireat in interface IRedisKeys
    
    Overrides:
    
    pexpireat in class AbstractRedisMock
  - type
```
public String type(String key)
```
    Specified by:
    
    type in interface IRedisKeys
    
    Overrides:
    
    type in class AbstractRedisMock
  - append
```
public Long append(String key,
                   String value)
            throws WrongTypeException
```
    Description copied from interface: IRedisString
    
    Append value onto key.
    
    Specified by:
    
    append in interface IRedisString
    
    Overrides:
    
    append in class AbstractRedisMock
    
    Parameters:
    
    key - The key
    
    value - The value
    
    Returns:
    
    The length of the key after the append operation.
    
    Throws:
    
    WrongTypeException - If key is not a string
  - bitcount
```
public Long bitcount(String key,
                     long... options)
              throws WrongTypeException
```
    Description copied from interface: IRedisString
    
    Count the number of set bits in a string.
    
    Specified by:
    
    bitcount in interface IRedisString
    
    Overrides:
    
    bitcount in class AbstractRedisMock
    
    Parameters:
    
    key - The key
    
    options - start, end
    
    Returns:
    
    The number of bits in the string set to 1
    
    Throws:
    
    WrongTypeException - If key is not a string
  - bitop
```
public Long bitop(String operation,
                  String destkey,
                  String... keys)
           throws WrongTypeException
```
    Description copied from interface: IRedisString
    
    Perform a bitwise operation between multiple keys and store the result in the destination key.
    
    Specified by:
    
    bitop in interface IRedisString
    
    Overrides:
    
    bitop in class AbstractRedisMock
    
    Parameters:
    
    operation - The operation to perform. Valid values are "and", "or", "xor", and "not".
    
    destkey - The destination key to store the operation result in.
    
    keys - The keys to operate against.
    
    Returns:
    
    The length of the string stored in destkey
    
    Throws:
    
    WrongTypeException - If key is not a string
  - bitpos
```
public Long bitpos(String key,
                   long bit,
                   long... options)
            throws WrongTypeException,
                   BitArgException
```
    Description copied from interface: IRedisString
    
    Return the position of the first bit set to 0 or 1 in a string.
    
    Specified by:
    
    bitpos in interface IRedisString
    
    Overrides:
    
    bitpos in class AbstractRedisMock
    
    Parameters:
    
    key - The key
    
    bit - 0|1
    
    options - start, end
    
    Returns:
    
    The bit position.
    
    Throws:
    
    WrongTypeException - If key is not a string
    
    BitArgException - If bit is not equal to 0 or 1
  - decr
```
public Long decr(String key)
          throws WrongTypeException,
                 NotIntegerException
```
    Description copied from interface: IRedisString
    
    Decrement the number stored at key by one.
    
    Specified by:
    
    decr in interface IRedisString
    
    Overrides:
    
    decr in class AbstractRedisMock
    
    Parameters:
    
    key - The key
    
    Returns:
    
    The new value of the string after the decrement operation, i.e., value - 1
    
    Throws:
    
    WrongTypeException - If key is not a string
    
    NotIntegerException - If key does not hold an integer value
  - decrby
```
public Long decrby(String key,
                   long decrement)
            throws WrongTypeException,
                   NotIntegerException
```
    Description copied from interface: IRedisString
    
    Decrement the number stored at key by the given decrement.
    
    Specified by:
    
    decrby in interface IRedisString
    
    Overrides:
    
    decrby in class AbstractRedisMock
    
    Parameters:
    
    key - The key
    
    decrement - The number to decrement by
    
    Returns:
    
    The new value of the string after the decrement operation, i.e., value - decrement
    
    Throws:
    
    WrongTypeException - If key is not a string
    
    NotIntegerException - If key does not hold an integer value
  - get
```
public String get(String key)
           throws WrongTypeException
```
    Description copied from interface: IRedisString
    
    Get the value of a key.
    
    Specified by:
    
    get in interface IRedisString
    
    Overrides:
    
    get in class AbstractRedisMock
    
    Parameters:
    
    key - The key
    
    Returns:
    
    The value of key
    
    Throws:
    
    WrongTypeException - If key is not a string
  - getbit
```
public Boolean getbit(String key,
                      long offset)
               throws WrongTypeException
```
    Description copied from interface: IRedisString
    
    Returns the bit value at offset in the string value stored at key.
    
    Specified by:
    
    getbit in interface IRedisString
    
    Overrides:
    
    getbit in class AbstractRedisMock
    
    Parameters:
    
    key - The key
    
    offset - The offset within the string
    
    Returns:
    
    The bit value at offset
    
    Throws:
    
    WrongTypeException - If key is not a string
  - getrange
```
public String getrange(String key,
                       long start,
                       long end)
                throws WrongTypeException
```
    Description copied from interface: IRedisString
    
    Returns the substring of the string value stored at key, determined by the inclusive offsets start and end.
    
    Specified by:
    
    getrange in interface IRedisString
    
    Overrides:
    
    getrange in class AbstractRedisMock
    
    Parameters:
    
    key - The key
    
    start - The start index of the range
    
    end - The end index of the range
    
    Returns:
    
    The range
    
    Throws:
    
    WrongTypeException - If key is not a string
  - getset
```
public String getset(String key,
                     String value)
              throws WrongTypeException
```
    Description copied from interface: IRedisString
    
    Atomically set a key and return its previous value.
    
    Specified by:
    
    getset in interface IRedisString
    
    Overrides:
    
    getset in class AbstractRedisMock
    
    Parameters:
    
    key - The key
    
    value - The new value
    
    Returns:
    
    The previous value
    
    Throws:
    
    WrongTypeException - If key is not a string
  - incr
```
public Long incr(String key)
          throws WrongTypeException,
                 NotIntegerException
```
    Description copied from interface: IRedisString
    
    Increment the number stored at key by one.
    
    Specified by:
    
    incr in interface IRedisString
    
    Overrides:
    
    incr in class AbstractRedisMock
    
    Parameters:
    
    key - The key
    
    Returns:
    
    The new value of the string after the decrement operation, i.e., value + 1
    
    Throws:
    
    WrongTypeException - If key is not a string
    
    NotIntegerException - If key does not hold an integer value
  - incrby
```
public Long incrby(String key,
                   long increment)
            throws WrongTypeException,
                   NotIntegerException
```
    Description copied from interface: IRedisString
    
    Increment the number stored at key by the given increment.
    
    Specified by:
    
    incrby in interface IRedisString
    
    Overrides:
    
    incrby in class AbstractRedisMock
    
    Parameters:
    
    key - The key
    
    increment - The increment to increase the key by
    
    Returns:
    
    The new value of the string after the decrement operation, i.e., value + increment
    
    Throws:
    
    WrongTypeException - If key is not a string
    
    NotIntegerException - If key does not hold an integer value
  - incrbyfloat
```
public String incrbyfloat(String key,
                          double increment)
                   throws WrongTypeException,
                          NotFloatException
```
    Description copied from interface: IRedisString
    
    Increment the number stored at key by the given increment.
    
    Specified by:
    
    incrbyfloat in interface IRedisString
    
    Overrides:
    
    incrbyfloat in class AbstractRedisMock
    
    Parameters:
    
    key - The key
    
    increment - The increment to increase the key by
    
    Returns:
    
    The new value of the string after the decrement operation, i.e., value + increment, as a string.
    
    Throws:
    
    WrongTypeException - If key is not a string
    
    NotFloatException - If key does not hold a floating point value
  - mget
```
public String[] mget(String... keys)
```
    Description copied from interface: IRedisString
    
    Returns the values of all specified keys. If a given key does not hold a string value, or does not exist, null is returned for that key in the returned array.
    
    Specified by:
    
    mget in interface IRedisString
    
    Overrides:
    
    mget in class AbstractRedisMock
    
    Parameters:
    
    keys - The keys to get
    
    Returns:
    
    List of values at the specified keys
  - mset
```
public String mset(String... keyvalues)
            throws ArgException
```
    Description copied from interface: IRedisString
    
    Sets the given keys to their respective values. Existing keys will be overwritten.
    
    Specified by:
    
    mset in interface IRedisString
    
    Overrides:
    
    mset in class AbstractRedisMock
    
    Parameters:
    
    keyvalues - The key-value pairs to set.
    
    Returns:
    
    "OK"
    
    Throws:
    
    ArgException - If the given arguments are not valid
  - msetnx
```
public Boolean msetnx(String... keyvalues)
               throws ArgException
```
    Description copied from interface: IRedisString
    
    Sets the given keys to their respective values. If at least one of the keys already exists, none of the keys are set.
    
    Specified by:
    
    msetnx in interface IRedisString
    
    Overrides:
    
    msetnx in class AbstractRedisMock
    
    Parameters:
    
    keyvalues - The key-value pairs to set.
    
    Returns:
    
    1 if all of the keys were set, or 0 if at least 1 key already existed and no operation was performed.
    
    Throws:
    
    ArgException - If the given arguments are not valid
  - psetex
```
public String psetex(String key,
                     long milliseconds,
                     String value)
```
    Description copied from interface: IRedisString
    
    Set and expire a key in milliseconds.
    
    Specified by:
    
    psetex in interface IRedisString
    
    Overrides:
    
    psetex in class AbstractRedisMock
    
    Parameters:
    
    key - The key
    
    milliseconds - The expiry time in milliseconds
    
    value - The value
    
    Returns:
    
    "OK"
  - set
```
public String set(String key,
                  String value,
                  String... options)
           throws SyntaxErrorException
```
    Description copied from interface: IRedisString
    
    Set key to hold the string value.
    
    Specified by:
    
    set in interface IRedisString
    
    Overrides:
    
    set in class AbstractRedisMock
    
    Parameters:
    
    key - The key
    
    value - The value
    
    options - nx|xx, ex|px timeout.
    
    Returns:
    
    "OK" if the key was set, or null if the operation failed.
    
    Throws:
    
    SyntaxErrorException - If the given options were not valid.
  - setbit
```
public Long setbit(String key,
                   long offset,
                   boolean value)
            throws WrongTypeException
```
    Description copied from interface: IRedisString
    
    Sets or clears the bit at offset in the string value stored at key.
    
    Specified by:
    
    setbit in interface IRedisString
    
    Overrides:
    
    setbit in class AbstractRedisMock
    
    Parameters:
    
    key - The key
    
    offset - The offset
    
    value - Whether to set or clear the bit (set = true, clear = false)
    
    Returns:
    
    The original bit value at offset
    
    Throws:
    
    WrongTypeException - If key is not a string
  - setex
```
public String setex(String key,
                    int seconds,
                    String value)
```
    Description copied from interface: IRedisString
    
    Set and expire a key in seconds.
    
    Specified by:
    
    setex in interface IRedisString
    
    Overrides:
    
    setex in class AbstractRedisMock
    
    Parameters:
    
    key - The key
    
    seconds - The expiry time in seconds
    
    value - The value
    
    Returns:
    
    "OK"
  - setnx
```
public Long setnx(String key,
                  String value)
```
    Description copied from interface: IRedisString
    
    Set a key only if it does not already exist.
    
    Specified by:
    
    setnx in interface IRedisString
    
    Overrides:
    
    setnx in class AbstractRedisMock
    
    Parameters:
    
    key - The key
    
    value - The value
    
    Returns:
    
    1 if the key was set; 0 if it already existed and no operation was performed.
  - setrange
```
public Long setrange(String key,
                     long offset,
                     String value)
              throws WrongTypeException
```
    Description copied from interface: IRedisString
    
    Ovewrite part of the string starting at offset with value.
    
    Specified by:
    
    setrange in interface IRedisString
    
    Overrides:
    
    setrange in class AbstractRedisMock
    
    Parameters:
    
    key - The key
    
    offset - Where to start. If greater than the length of the string, the string is padded out to the offset.
    
    value - The value
    
    Returns:
    
    The length of the string after this operation
    
    Throws:
    
    WrongTypeException - If key is not a string
  - strlen
```
public Long strlen(String key)
            throws WrongTypeException
```
    Description copied from interface: IRedisString
    
    Return the length of the string at key.
    
    Specified by:
    
    strlen in interface IRedisString
    
    Overrides:
    
    strlen in class AbstractRedisMock
    
    Parameters:
    
    key - The key
    
    Returns:
    
    The length of the string
    
    Throws:
    
    WrongTypeException - If key is not a string
  - lindex
```
public String lindex(String key,
                     long index)
              throws WrongTypeException
```
    Specified by:
    
    lindex in interface IRedisList
    
    Overrides:
    
    lindex in class AbstractRedisMock
    
    Throws:
    
    WrongTypeException
  - linsert
```
public Long linsert(String key,
                    String before_after,
                    String pivot,
                    String value)
             throws WrongTypeException
```
    Specified by:
    
    linsert in interface IRedisList
    
    Overrides:
    
    linsert in class AbstractRedisMock
    
    Throws:
    
    WrongTypeException
  - llen
```
public Long llen(String key)
          throws WrongTypeException
```
    Specified by:
    
    llen in interface IRedisList
    
    Overrides:
    
    llen in class AbstractRedisMock
    
    Throws:
    
    WrongTypeException
  - lpop
```
public String lpop(String key)
            throws WrongTypeException
```
    Specified by:
    
    lpop in interface IRedisList
    
    Overrides:
    
    lpop in class AbstractRedisMock
    
    Throws:
    
    WrongTypeException
  - lpush
```
public Long lpush(String key,
                  String element,
                  String... elements)
           throws WrongTypeException
```
    Specified by:
    
    lpush in interface IRedisList
    
    Overrides:
    
    lpush in class AbstractRedisMock
    
    Throws:
    
    WrongTypeException
  - lpushx
```
public Long lpushx(String key,
                   String element)
            throws WrongTypeException
```
    Specified by:
    
    lpushx in interface IRedisList
    
    Overrides:
    
    lpushx in class AbstractRedisMock
    
    Throws:
    
    WrongTypeException
  - lrange
```
public List<String> lrange(String key,
                           long start,
                           long end)
                    throws WrongTypeException
```
    Specified by:
    
    lrange in interface IRedisList
    
    Overrides:
    
    lrange in class AbstractRedisMock
    
    Throws:
    
    WrongTypeException
  - lrem
```
public Long lrem(String key,
                 long count,
                 String element)
          throws WrongTypeException
```
    Specified by:
    
    lrem in interface IRedisList
    
    Overrides:
    
    lrem in class AbstractRedisMock
    
    Throws:
    
    WrongTypeException
  - lset
```
public String lset(String key,
                   long index,
                   String element)
            throws WrongTypeException,
                   NoKeyException,
                   IndexOutOfRangeException
```
    Specified by:
    
    lset in interface IRedisList
    
    Overrides:
    
    lset in class AbstractRedisMock
    
    Throws:
    
    WrongTypeException
    
    NoKeyException
    
    IndexOutOfRangeException
  - ltrim
```
public String ltrim(String key,
                    long start,
                    long end)
             throws WrongTypeException
```
    Specified by:
    
    ltrim in interface IRedisList
    
    Overrides:
    
    ltrim in class AbstractRedisMock
    
    Throws:
    
    WrongTypeException
  - rpop
```
public String rpop(String key)
            throws WrongTypeException
```
    Specified by:
    
    rpop in interface IRedisList
    
    Overrides:
    
    rpop in class AbstractRedisMock
    
    Throws:
    
    WrongTypeException
  - rpoplpush
```
public String rpoplpush(String source,
                        String dest)
                 throws WrongTypeException
```
    Specified by:
    
    rpoplpush in interface IRedisList
    
    Overrides:
    
    rpoplpush in class AbstractRedisMock
    
    Throws:
    
    WrongTypeException
  - rpush
```
public Long rpush(String key,
                  String element,
                  String... elements)
           throws WrongTypeException
```
    Specified by:
    
    rpush in interface IRedisList
    
    Overrides:
    
    rpush in class AbstractRedisMock
    
    Throws:
    
    WrongTypeException
  - rpushx
```
public Long rpushx(String key,
                   String element)
            throws WrongTypeException
```
    Specified by:
    
    rpushx in interface IRedisList
    
    Overrides:
    
    rpushx in class AbstractRedisMock
    
    Throws:
    
    WrongTypeException
  - sadd
```
public Long sadd(String key,
                 String member,
                 String... members)
          throws WrongTypeException
```
    Specified by:
    
    sadd in interface IRedisSet
    
    Overrides:
    
    sadd in class AbstractRedisMock
    
    Throws:
    
    WrongTypeException
  - scard
```
public Long scard(String key)
           throws WrongTypeException
```
    Specified by:
    
    scard in interface IRedisSet
    
    Overrides:
    
    scard in class AbstractRedisMock
    
    Throws:
    
    WrongTypeException
  - sdiff
```
public Set<String> sdiff(String key,
                         String... keys)
                  throws WrongTypeException
```
    Specified by:
    
    sdiff in interface IRedisSet
    
    Overrides:
    
    sdiff in class AbstractRedisMock
    
    Throws:
    
    WrongTypeException
  - sdiffstore
```
public Long sdiffstore(String destination,
                       String key,
                       String... keys)
                throws WrongTypeException
```
    Specified by:
    
    sdiffstore in interface IRedisSet
    
    Overrides:
    
    sdiffstore in class AbstractRedisMock
    
    Throws:
    
    WrongTypeException
  - sinter
```
public Set<String> sinter(String key,
                          String... keys)
                   throws WrongTypeException
```
    Specified by:
    
    sinter in interface IRedisSet
    
    Overrides:
    
    sinter in class AbstractRedisMock
    
    Throws:
    
    WrongTypeException
  - sinterstore
```
public Long sinterstore(String destination,
                        String key,
                        String... keys)
                 throws WrongTypeException
```
    Specified by:
    
    sinterstore in interface IRedisSet
    
    Overrides:
    
    sinterstore in class AbstractRedisMock
    
    Throws:
    
    WrongTypeException
  - sismember
```
public Boolean sismember(String key,
                         String member)
                  throws WrongTypeException
```
    Specified by:
    
    sismember in interface IRedisSet
    
    Overrides:
    
    sismember in class AbstractRedisMock
    
    Throws:
    
    WrongTypeException
  - smembers
```
public Set<String> smembers(String key)
                     throws WrongTypeException
```
    Specified by:
    
    smembers in interface IRedisSet
    
    Overrides:
    
    smembers in class AbstractRedisMock
    
    Throws:
    
    WrongTypeException
  - smove
```
public Boolean smove(String source,
                     String dest,
                     String member)
              throws WrongTypeException
```
    Specified by:
    
    smove in interface IRedisSet
    
    Overrides:
    
    smove in class AbstractRedisMock
    
    Throws:
    
    WrongTypeException
  - spop
```
public String spop(String key)
            throws WrongTypeException
```
    Specified by:
    
    spop in interface IRedisSet
    
    Overrides:
    
    spop in class AbstractRedisMock
    
    Throws:
    
    WrongTypeException
  - srandmember
```
public String srandmember(String key)
                   throws WrongTypeException
```
    Specified by:
    
    srandmember in interface IRedisSet
    
    Overrides:
    
    srandmember in class AbstractRedisMock
    
    Throws:
    
    WrongTypeException
  - srandmember
```
public List<String> srandmember(String key,
                                long count)
                         throws WrongTypeException
```
    Specified by:
    
    srandmember in interface IRedisSet
    
    Overrides:
    
    srandmember in class AbstractRedisMock
    
    Throws:
    
    WrongTypeException
  - srem
```
public Long srem(String key,
                 String member,
                 String... members)
          throws WrongTypeException
```
    Specified by:
    
    srem in interface IRedisSet
    
    Overrides:
    
    srem in class AbstractRedisMock
    
    Throws:
    
    WrongTypeException
  - sunion
```
public Set<String> sunion(String key,
                          String... keys)
                   throws WrongTypeException
```
    Specified by:
    
    sunion in interface IRedisSet
    
    Overrides:
    
    sunion in class AbstractRedisMock
    
    Throws:
    
    WrongTypeException
  - sunionstore
```
public Long sunionstore(String destination,
                        String key,
                        String... keys)
                 throws WrongTypeException
```
    Specified by:
    
    sunionstore in interface IRedisSet
    
    Overrides:
    
    sunionstore in class AbstractRedisMock
    
    Throws:
    
    WrongTypeException
  - sscan
```
public ScanResult<Set<String>> sscan(String key,
                                     long cursor,
                                     String... options)
                              throws WrongTypeException
```
    Specified by:
    
    sscan in interface IRedisSet
    
    Overrides:
    
    sscan in class AbstractRedisMock
    
    Throws:
    
    WrongTypeException
  - hdel
```
public Long hdel(String key,
                 String field,
                 String... fields)
          throws WrongTypeException
```
    Specified by:
    
    hdel in interface IRedisHash
    
    Overrides:
    
    hdel in class AbstractRedisMock
    
    Throws:
    
    WrongTypeException
  - hexists
```
public Boolean hexists(String key,
                       String field)
                throws WrongTypeException
```
    Specified by:
    
    hexists in interface IRedisHash
    
    Overrides:
    
    hexists in class AbstractRedisMock
    
    Throws:
    
    WrongTypeException
  - hget
```
public String hget(String key,
                   String field)
            throws WrongTypeException
```
    Specified by:
    
    hget in interface IRedisHash
    
    Overrides:
    
    hget in class AbstractRedisMock
    
    Throws:
    
    WrongTypeException
  - hgetall
```
public Map<String,String> hgetall(String key)
                           throws WrongTypeException
```
    Specified by:
    
    hgetall in interface IRedisHash
    
    Overrides:
    
    hgetall in class AbstractRedisMock
    
    Throws:
    
    WrongTypeException
  - hincrby
```
public Long hincrby(String key,
                    String field,
                    long increment)
             throws WrongTypeException,
                    NotIntegerHashException
```
    Specified by:
    
    hincrby in interface IRedisHash
    
    Overrides:
    
    hincrby in class AbstractRedisMock
    
    Throws:
    
    WrongTypeException
    
    NotIntegerHashException
  - hincrbyfloat
```
public String hincrbyfloat(String key,
                           String field,
                           double increment)
                    throws WrongTypeException,
                           NotFloatHashException
```
    Specified by:
    
    hincrbyfloat in interface IRedisHash
    
    Overrides:
    
    hincrbyfloat in class AbstractRedisMock
    
    Throws:
    
    WrongTypeException
    
    NotFloatHashException
  - hkeys
```
public Set<String> hkeys(String key)
                  throws WrongTypeException
```
    Specified by:
    
    hkeys in interface IRedisHash
    
    Overrides:
    
    hkeys in class AbstractRedisMock
    
    Throws:
    
    WrongTypeException
  - hlen
```
public Long hlen(String key)
          throws WrongTypeException
```
    Specified by:
    
    hlen in interface IRedisHash
    
    Overrides:
    
    hlen in class AbstractRedisMock
    
    Throws:
    
    WrongTypeException
  - hmget
```
public List<String> hmget(String key,
                          String field,
                          String... fields)
                   throws WrongTypeException
```
    Specified by:
    
    hmget in interface IRedisHash
    
    Overrides:
    
    hmget in class AbstractRedisMock
    
    Throws:
    
    WrongTypeException
  - hmset
```
public String hmset(String key,
                    String field,
                    String value,
                    String... fieldsvalues)
             throws WrongTypeException,
                    ArgException
```
    Specified by:
    
    hmset in interface IRedisHash
    
    Overrides:
    
    hmset in class AbstractRedisMock
    
    Throws:
    
    WrongTypeException
    
    ArgException
  - hset
```
public Boolean hset(String key,
                    String field,
                    String value)
             throws WrongTypeException
```
    Specified by:
    
    hset in interface IRedisHash
    
    Overrides:
    
    hset in class AbstractRedisMock
    
    Throws:
    
    WrongTypeException
  - hsetnx
```
public Boolean hsetnx(String key,
                      String field,
                      String value)
               throws WrongTypeException
```
    Specified by:
    
    hsetnx in interface IRedisHash
    
    Overrides:
    
    hsetnx in class AbstractRedisMock
    
    Throws:
    
    WrongTypeException
  - hstrlen
```
public Long hstrlen(String key,
                    String field)
             throws WrongTypeException
```
    Specified by:
    
    hstrlen in interface IRedisHash
    
    Overrides:
    
    hstrlen in class AbstractRedisMock
    
    Throws:
    
    WrongTypeException
  - hvals
```
public List<String> hvals(String key)
                   throws WrongTypeException
```
    Specified by:
    
    hvals in interface IRedisHash
    
    Overrides:
    
    hvals in class AbstractRedisMock
    
    Throws:
    
    WrongTypeException
  - hscan
```
public ScanResult<Map<String,String>> hscan(String key,
                                            long cursor,
                                            String... options)
                                     throws WrongTypeException
```
    Specified by:
    
    hscan in interface IRedisHash
    
    Overrides:
    
    hscan in class AbstractRedisMock
    
    Throws:
    
    WrongTypeException
  - discard
```
public String discard()
               throws DiscardWithoutMultiException
```
    Specified by:
    
    discard in interface IRedisTransaction
    
    Overrides:
    
    discard in class AbstractRedisMock
    
    Throws:
    
    DiscardWithoutMultiException
  - exec
```
public List<Object> exec()
                  throws ExecWithoutMultiException
```
    Specified by:
    
    exec in interface IRedisTransaction
    
    Overrides:
    
    exec in class AbstractRedisMock
    
    Throws:
    
    ExecWithoutMultiException
  - multi
```
public IRedisClient multi()
```
    Specified by:
    
    multi in interface IRedisTransaction
    
    Overrides:
    
    multi in class AbstractRedisMock
  - unwatch
```
public String unwatch()
```
    Specified by:
    
    unwatch in interface IRedisTransaction
    
    Overrides:
    
    unwatch in class AbstractRedisMock
  - watch
```
public String watch(String key)
```
    Specified by:
    
    watch in interface IRedisTransaction
    
    Overrides:
    
    watch in class AbstractRedisMock

Class RedisMockClient

Nested Class Summary

Nested classes/interfaces inherited from interface org.rarefiedredis.redis.IRedisSortedSet

Constructor Summary

Method Summary

Methods inherited from class org.rarefiedredis.redis.AbstractRedisMock

Methods inherited from class java.lang.Object

Constructor Detail

RedisMockClient

Method Detail

createClient

modified

del

exists

expire

expireat

persist

pexpire

pexpireat

type

append

bitcount

bitop

bitpos

decr

decrby

get

getbit

getrange

getset

incr

incrby

incrbyfloat

mget

mset

msetnx

psetex

set

setbit

setex

setnx

setrange

strlen

lindex

linsert

llen

lpop

lpush

lpushx

lrange

lrem

lset

ltrim

rpop

rpoplpush

rpush

rpushx

sadd

scard

sdiff

sdiffstore

sinter

sinterstore

sismember

smembers

smove

spop

srandmember

srandmember

srem

sunion

sunionstore

sscan

hdel

hexists

hget

hgetall

hincrby

hincrbyfloat

hkeys