Spring/spring-data-redis
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

DATAREDIS-843 - Polishing.

Browse Source 
Remove usage of deprecated methods, enable ignored test and move to AssertJ.

Original Pull Request: #349
This commit is contained in:
Christoph Strobl
2018-07-12 10:23:24 +02:00
parent a0d8b3a4c6
commit 2dfe1e2b4e
6 changed files with 161 additions and 161 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
src/main/java/org/springframework/data/redis/support/atomic/CompareAndSet.java
View File

@@ -44,7 +44,7 @@ class CompareAndSet<T> implements SessionCallback<Boolean> {
private final Supplier<T> getter;
private final Consumer<T> setter;
private final String key;
private final Object key;
private final T expect;
private final T update;
@@ -56,13 +56,11 @@ class CompareAndSet<T> implements SessionCallback<Boolean> {
@SuppressWarnings("unchecked")
public <K, V> Boolean execute(RedisOperations<K, V> operations) throws DataAccessException {
RedisOperations<String, T> ops = (RedisOperations<String, T>) operations;
ops.watch(key);
operations.watch((K) key);
if (expect.equals(getter.get())) {
ops.multi();
operations.multi();
setter.accept(update);
if (updateSuccessful(operations.exec())) {
@@ -70,7 +68,7 @@ class CompareAndSet<T> implements SessionCallback<Boolean> {
}
}
ops.unwatch();
operations.unwatch();
return false;
}

21
src/test/java/org/springframework/data/redis/support/atomic/AtomicCountersParam.java
View File

@@ -18,8 +18,9 @@ package org.springframework.data.redis.support.atomic;
import java.util.Arrays;
import java.util.Collection;
import org.springframework.data.redis.SettingsUtils;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.connection.lettuce.LettuceClientConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.connection.lettuce.LettuceTestClientResources;
@@ -27,22 +28,20 @@ import org.springframework.data.redis.connection.lettuce.LettuceTestClientResour
* @author Costin Leau
* @author Jennifer Hickey
* @author Mark Paluch
* @author Christoph Strobl
*/
public abstract class AtomicCountersParam {
abstract class AtomicCountersParam {
static Collection<Object[]> testParams() {
public static Collection<Object[]> testParams() {
// Jedis
JedisConnectionFactory jedisConnFactory = new JedisConnectionFactory();
jedisConnFactory.setPort(SettingsUtils.getPort());
jedisConnFactory.setHostName(SettingsUtils.getHost());
jedisConnFactory.setUsePool(true);
JedisConnectionFactory jedisConnFactory = new JedisConnectionFactory(new RedisStandaloneConfiguration());
jedisConnFactory.afterPropertiesSet();
// Lettuce
LettuceConnectionFactory lettuceConnFactory = new LettuceConnectionFactory();
lettuceConnFactory.setClientResources(LettuceTestClientResources.getSharedClientResources());
lettuceConnFactory.setPort(SettingsUtils.getPort());
lettuceConnFactory.setHostName(SettingsUtils.getHost());
LettuceConnectionFactory lettuceConnFactory = new LettuceConnectionFactory(new RedisStandaloneConfiguration(),
LettuceClientConfiguration.builder().clientResources(LettuceTestClientResources.getSharedClientResources())
.build());
lettuceConnFactory.afterPropertiesSet();
return Arrays.asList(new Object[][] { { jedisConnFactory }, { lettuceConnFactory } });

32
src/test/java/org/springframework/data/redis/support/atomic/CompareAndSetIntegrationTests.java
View File

@@ -37,6 +37,7 @@ import org.springframework.data.redis.serializer.StringRedisSerializer;
* Integration tests for {@link CompareAndSet}.
*
* @author Mark Paluch
* @author Christoph Strobl
*/
@RunWith(Parameterized.class)
public class CompareAndSetIntegrationTests {
@@ -62,11 +63,9 @@ public class CompareAndSetIntegrationTests {
ConnectionFactoryTracker.add(factory);
}
@After
public void stop() {
RedisConnection connection = factory.getConnection();
connection.flushDb();
connection.close();
@Parameters
public static Collection<Object[]> testParams() {
return AtomicCountersParam.testParams();
}
@AfterClass
@@ -74,9 +73,12 @@ public class CompareAndSetIntegrationTests {
ConnectionFactoryTracker.cleanUp();
}
@Parameters
public static Collection<Object[]> testParams() {
return AtomicCountersParam.testParams();
@After
public void tearDown() {
RedisConnection connection = factory.getConnection();
connection.flushDb();
connection.close();
}
@Test // DATAREDIS-843
@@ -89,9 +91,7 @@ public class CompareAndSetIntegrationTests {
CompareAndSet<Long> cas = new CompareAndSet<>(() -> actual, newValue -> valueOps.set(KEY, newValue), KEY, expected,
update);
Boolean executed = this.template.execute(cas);
assertThat(executed).isTrue();
assertThat(template.execute(cas)).isTrue();
assertThat(valueOps.get(KEY)).isEqualTo(update);
}
@@ -105,9 +105,7 @@ public class CompareAndSetIntegrationTests {
CompareAndSet<Long> cas = new CompareAndSet<>(() -> actual, newValue -> valueOps.set(KEY, newValue), KEY, expected,
update);
Boolean executed = this.template.execute(cas);
assertThat(executed).isFalse();
assertThat(template.execute(cas)).isFalse();
assertThat(valueOps.get(KEY)).isNull();
}
@@ -121,16 +119,14 @@ public class CompareAndSetIntegrationTests {
CompareAndSet<Long> cas = new CompareAndSet<>(() -> actual, newValue -> {
RedisConnection connection = this.factory.getConnection();
RedisConnection connection = factory.getConnection();
connection.set(KEY.getBytes(), Long.toString(concurrentlyUpdated).getBytes());
connection.close();
valueOps.set(KEY, newValue);
}, KEY, expected, update);
Boolean executed = this.template.execute(cas);
assertThat(executed).isFalse();
assertThat(template.execute(cas)).isFalse();
assertThat(valueOps.get(KEY)).isEqualTo(concurrentlyUpdated);
}
}

116
src/test/java/org/springframework/data/redis/support/atomic/RedisAtomicDoubleTests.java
View File

@@ -15,25 +15,21 @@
*/
package org.springframework.data.redis.support.atomic;
import static org.hamcrest.CoreMatchers.*;
import static org.junit.Assert.*;
import static org.junit.Assume.*;
import static org.assertj.core.api.Assertions.*;
import java.util.Collection;
import java.util.Date;
import java.util.concurrent.TimeUnit;
import org.assertj.core.data.Offset;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameters;
import org.springframework.dao.DataRetrievalFailureException;
import org.springframework.data.redis.ConnectionFactoryTracker;
import org.springframework.data.redis.RedisTestProfileValueSource;
import org.springframework.data.redis.connection.ConnectionUtils;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
@@ -69,11 +65,9 @@ public class RedisAtomicDoubleTests extends AbstractRedisAtomicsTests {
ConnectionFactoryTracker.add(factory);
}
@After
public void stop() {
RedisConnection connection = factory.getConnection();
connection.flushDb();
connection.close();
@Parameters
public static Collection<Object[]> testParams() {
return AtomicCountersParam.testParams();
}
@AfterClass
@@ -81,93 +75,99 @@ public class RedisAtomicDoubleTests extends AbstractRedisAtomicsTests {
ConnectionFactoryTracker.cleanUp();
}
@Parameters
public static Collection<Object[]> testParams() {
return AtomicCountersParam.testParams();
@After
public void tearDown() {
RedisConnection connection = factory.getConnection();
connection.flushDb();
connection.close();
}
@Test
@Test // DATAREDIS-198
public void testCheckAndSet() {
doubleCounter.set(0);
assertFalse(doubleCounter.compareAndSet(1.2, 10.6));
assertTrue(doubleCounter.compareAndSet(0, 10.6));
assertTrue(doubleCounter.compareAndSet(10.6, 0));
assertThat(doubleCounter.compareAndSet(1.2, 10.6)).isFalse();
assertThat(doubleCounter.compareAndSet(0, 10.6)).isTrue();
assertThat(doubleCounter.compareAndSet(10.6, 0)).isTrue();
}
@Test
public void testIncrementAndGet() throws Exception {
assumeTrue(!(ConnectionUtils.isJedis(factory)));
@Test // DATAREDIS-198
public void testIncrementAndGet() {
doubleCounter.set(0);
assertEquals(1.0, doubleCounter.incrementAndGet(), 0);
assertThat(doubleCounter.incrementAndGet()).isEqualTo(1.0);
}
@Test
public void testAddAndGet() throws Exception {
assumeTrue(!(ConnectionUtils.isJedis(factory)));
@Test // DATAREDIS-198
public void testAddAndGet() {
doubleCounter.set(0);
double delta = 1.3;
assertEquals(delta, doubleCounter.addAndGet(delta), .0001);
assertThat(doubleCounter.addAndGet(delta)).isCloseTo(delta, Offset.offset(.0001));
}
@Test
public void testDecrementAndGet() throws Exception {
assumeTrue(!(ConnectionUtils.isJedis(factory)));
@Test // DATAREDIS-198
public void testDecrementAndGet() {
doubleCounter.set(1);
assertEquals(0, doubleCounter.decrementAndGet(), 0);
assertThat(doubleCounter.decrementAndGet()).isZero();
}
@Test
@Test // DATAREDIS-198
public void testGetAndSet() {
doubleCounter.set(3.4);
assertEquals(3.4, doubleCounter.getAndSet(1.2), 0);
assertEquals(1.2, doubleCounter.get(), 0);
assertThat(doubleCounter.getAndSet(1.2)).isEqualTo(3.4);
assertThat(doubleCounter.get()).isEqualTo(1.2);
}
@Test
@Test // DATAREDIS-198
public void testGetAndIncrement() {
assumeTrue(!(ConnectionUtils.isJedis(factory)));
doubleCounter.set(2.3);
assertEquals(2.3, doubleCounter.getAndIncrement(), 0);
assertEquals(3.3, doubleCounter.get(), .0001);
assertThat(doubleCounter.getAndIncrement()).isEqualTo(2.3);
assertThat(doubleCounter.get()).isEqualTo(3.3);
}
@Test
@Test // DATAREDIS-198
public void testGetAndDecrement() {
assumeTrue(!(ConnectionUtils.isJedis(factory)));
doubleCounter.set(0.5);
assertEquals(0.5, doubleCounter.getAndDecrement(), 0);
assertEquals(-0.5, doubleCounter.get(), .0001);
assertThat(doubleCounter.getAndDecrement()).isEqualTo(0.5);
assertThat(doubleCounter.get()).isEqualTo(-0.5);
}
@Test
@Test // DATAREDIS-198
public void testGetAndAdd() {
assumeTrue(!(ConnectionUtils.isJedis(factory)));
doubleCounter.set(0.5);
assertEquals(0.5, doubleCounter.getAndAdd(0.7), 0);
assertEquals(1.2, doubleCounter.get(), .0001);
assertThat(doubleCounter.getAndAdd(0.7)).isEqualTo(0.5);
assertThat(doubleCounter.get()).isEqualTo(1.2);
}
@Test
@Test // DATAREDIS-198
public void testExpire() {
assertTrue(doubleCounter.expire(1, TimeUnit.SECONDS));
assertTrue(doubleCounter.getExpire() > 0);
assertThat(doubleCounter.expire(1, TimeUnit.SECONDS)).isTrue();
assertThat(doubleCounter.getExpire() > 0).isTrue();
}
@Test
@Test // DATAREDIS-198
public void testExpireAt() {
doubleCounter.set(7.8);
assertTrue(doubleCounter.expireAt(new Date(System.currentTimeMillis() + 10000)));
assertTrue(doubleCounter.getExpire() > 0);
assertThat(doubleCounter.expireAt(new Date(System.currentTimeMillis() + 10000))).isTrue();
assertThat(doubleCounter.getExpire() > 0).isTrue();
}
@Test
@Test // DATAREDIS-198
public void testRename() {
doubleCounter.set(5.6);
doubleCounter.rename("foodouble");
assertEquals("5.6", new String(factory.getConnection().get("foodouble".getBytes())));
assertNull(factory.getConnection().get((getClass().getSimpleName() + ":double").getBytes()));
assertThat(new String(factory.getConnection().get("foodouble".getBytes()))).isEqualTo("5.6");
assertThat(factory.getConnection().get((getClass().getSimpleName() + ":double").getBytes())).isNull();
}
@Test // DATAREDIS-317
@@ -196,7 +196,7 @@ public class RedisAtomicDoubleTests extends AbstractRedisAtomicsTests {
RedisAtomicDouble ral = new RedisAtomicDouble("DATAREDIS-317.atomicDouble", template);
ral.set(32.23);
assertThat(ral.get(), is(32.23));
assertThat(ral.get()).isEqualTo(32.23);
}
@Test // DATAREDIS-469
@@ -207,7 +207,7 @@ public class RedisAtomicDoubleTests extends AbstractRedisAtomicsTests {
// setup double
RedisAtomicDouble test = new RedisAtomicDouble("test", factory, 1);
assertThat(test.get(), equalTo(1D)); // this passes
assertThat(test.get()).isOne(); // this passes
template.delete("test");
@@ -219,10 +219,10 @@ public class RedisAtomicDoubleTests extends AbstractRedisAtomicsTests {
// setup double
RedisAtomicDouble test = new RedisAtomicDouble("test", factory, 1);
assertThat(test.get(), equalTo(1D)); // this passes
assertThat(test.get()).isOne(); // this passes
template.delete("test");
assertThat(test.getAndSet(2), is(0D));
assertThat(test.getAndSet(2)).isZero();
}
}

72
src/test/java/org/springframework/data/redis/support/atomic/RedisAtomicIntegerTests.java
View File

@@ -15,8 +15,7 @@
*/
package org.springframework.data.redis.support.atomic;
import static org.hamcrest.CoreMatchers.*;
import static org.junit.Assert.*;
import static org.assertj.core.api.Assertions.*;
import java.util.Collection;
import java.util.concurrent.CountDownLatch;
@@ -24,7 +23,6 @@ import java.util.concurrent.atomic.AtomicBoolean;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Ignore;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
@@ -67,11 +65,9 @@ public class RedisAtomicIntegerTests extends AbstractRedisAtomicsTests {
ConnectionFactoryTracker.add(factory);
}
@After
public void stop() {
RedisConnection connection = factory.getConnection();
connection.flushDb();
connection.close();
@Parameters
public static Collection<Object[]> testParams() {
return AtomicCountersParam.testParams();
}
@AfterClass
@@ -79,73 +75,78 @@ public class RedisAtomicIntegerTests extends AbstractRedisAtomicsTests {
ConnectionFactoryTracker.cleanUp();
}
@Parameters
public static Collection<Object[]> testParams() {
return AtomicCountersParam.testParams();
@After
public void tearDown() {
RedisConnection connection = factory.getConnection();
connection.flushDb();
connection.close();
}
@Test
public void testCheckAndSet() {
intCounter.set(0);
assertFalse(intCounter.compareAndSet(1, 10));
assertTrue(intCounter.compareAndSet(0, 10));
assertTrue(intCounter.compareAndSet(10, 0));
assertThat(intCounter.compareAndSet(1, 10)).isFalse();
assertThat(intCounter.compareAndSet(0, 10)).isTrue();
assertThat(intCounter.compareAndSet(10, 0)).isTrue();
}
@Test
public void testIncrementAndGet() {
intCounter.set(0);
assertEquals(1, intCounter.incrementAndGet());
assertThat(intCounter.incrementAndGet()).isOne();
}
@Test
public void testAddAndGet() throws Exception {
public void testAddAndGet() {
intCounter.set(0);
int delta = 5;
assertEquals(delta, intCounter.addAndGet(delta));
assertThat(intCounter.addAndGet(delta)).isEqualTo(delta);
}
@Test
public void testDecrementAndGet() {
intCounter.set(1);
assertEquals(0, intCounter.decrementAndGet());
assertThat(intCounter.decrementAndGet()).isZero();
}
@Test // DATAREDIS-469
public void testGetAndIncrement() {
intCounter.set(1);
assertEquals(1, intCounter.getAndIncrement());
assertEquals(2, intCounter.get());
assertThat(intCounter.getAndIncrement()).isOne();
assertThat(intCounter.get()).isEqualTo(2);
}
@Test // DATAREDIS-469
public void testGetAndAdd() {
intCounter.set(1);
assertEquals(1, intCounter.getAndAdd(5));
assertEquals(6, intCounter.get());
assertThat(intCounter.getAndAdd(5)).isOne();
assertThat(intCounter.get()).isEqualTo(6);
}
@Test // DATAREDIS-469
public void testGetAndDecrement() {
intCounter.set(1);
assertEquals(1, intCounter.getAndDecrement());
assertEquals(0, intCounter.get());
assertThat(intCounter.getAndDecrement()).isOne();
assertThat(intCounter.get()).isZero();
}
@Test // DATAREDIS-469
public void testGetAndSet() {
intCounter.set(1);
assertEquals(1, intCounter.getAndSet(5));
assertEquals(5, intCounter.get());
assertThat(intCounter.getAndSet(5)).isOne();
assertThat(intCounter.get()).isEqualTo(5);
}
@Test
@Ignore("DATAREDIS-108 Test is intermittently failing")
@Test // DATAREDIS-108, DATAREDIS-843
public void testCompareSet() throws Exception {
final AtomicBoolean alreadySet = new AtomicBoolean(false);
@@ -154,12 +155,14 @@ public class RedisAtomicIntegerTests extends AbstractRedisAtomicsTests {
final CountDownLatch latch = new CountDownLatch(NUM);
final AtomicBoolean failed = new AtomicBoolean(false);
for (int i = 0; i < NUM; i++) {
new Thread(() -> {
RedisAtomicInteger atomicInteger = new RedisAtomicInteger(KEY, factory);
try {
if (atomicInteger.compareAndSet(0, 1)) {
System.out.println(atomicInteger.get());
if (alreadySet.get()) {
failed.set(true);
}
@@ -170,9 +173,10 @@ public class RedisAtomicIntegerTests extends AbstractRedisAtomicsTests {
}
}).start();
}
latch.await();
assertFalse("counter already modified", failed.get());
assertThat(failed.get()).withFailMessage("counter already modified").isFalse();
}
@Test // DATAREDIS-317
@@ -201,7 +205,7 @@ public class RedisAtomicIntegerTests extends AbstractRedisAtomicsTests {
RedisAtomicInteger ral = new RedisAtomicInteger("DATAREDIS-317.atomicInteger", template);
ral.set(32);
assertThat(ral.get(), is(32));
assertThat(ral.get()).isEqualTo(32);
}
@Test // DATAREDIS-469
@@ -212,7 +216,7 @@ public class RedisAtomicIntegerTests extends AbstractRedisAtomicsTests {
// setup integer
RedisAtomicInteger test = new RedisAtomicInteger("test", factory, 1);
assertThat(test.get(), equalTo(1)); // this passes
assertThat(test.get()).isOne(); // this passes
template.delete("test");
@@ -224,10 +228,10 @@ public class RedisAtomicIntegerTests extends AbstractRedisAtomicsTests {
// setup integer
RedisAtomicInteger test = new RedisAtomicInteger("test", factory, 1);
assertThat(test.get(), equalTo(1)); // this passes
assertThat(test.get()).isOne(); // this passes
template.delete("test");
assertThat(test.getAndSet(2), is(0));
assertThat(test.getAndSet(2)).isZero();
}
}

71
src/test/java/org/springframework/data/redis/support/atomic/RedisAtomicLongTests.java
View File

@@ -15,8 +15,7 @@
*/
package org.springframework.data.redis.support.atomic;
import static org.hamcrest.CoreMatchers.*;
import static org.junit.Assert.*;
import static org.assertj.core.api.Assertions.*;
import java.util.Collection;
@@ -64,11 +63,9 @@ public class RedisAtomicLongTests extends AbstractRedisAtomicsTests {
ConnectionFactoryTracker.add(factory);
}
@After
public void stop() {
RedisConnection connection = factory.getConnection();
connection.flushDb();
connection.close();
@Parameters
public static Collection<Object[]> testParams() {
return AtomicCountersParam.testParams();
}
@AfterClass
@@ -76,77 +73,83 @@ public class RedisAtomicLongTests extends AbstractRedisAtomicsTests {
ConnectionFactoryTracker.cleanUp();
}
@Parameters
public static Collection<Object[]> testParams() {
return AtomicCountersParam.testParams();
@After
public void tearDown() {
RedisConnection connection = factory.getConnection();
connection.flushDb();
connection.close();
}
@Test
public void testCheckAndSet() throws Exception {
public void testCheckAndSet() {
longCounter.set(0);
assertFalse(longCounter.compareAndSet(1, 10));
assertTrue(longCounter.compareAndSet(0, 10));
assertTrue(longCounter.compareAndSet(10, 0));
assertThat(longCounter.compareAndSet(1, 10)).isFalse();
assertThat(longCounter.compareAndSet(0, 10)).isTrue();
assertThat(longCounter.compareAndSet(10, 0)).isTrue();
}
@Test
public void testIncrementAndGet() throws Exception {
public void testIncrementAndGet() {
longCounter.set(0);
assertEquals(1, longCounter.incrementAndGet());
assertThat(longCounter.incrementAndGet()).isOne();
}
@Test
public void testAddAndGet() throws Exception {
public void testAddAndGet() {
longCounter.set(0);
long delta = 5;
assertEquals(delta, longCounter.addAndGet(delta));
assertThat(longCounter.addAndGet(delta)).isEqualTo(delta);
}
@Test
public void testDecrementAndGet() throws Exception {
public void testDecrementAndGet() {
longCounter.set(1);
assertEquals(0, longCounter.decrementAndGet());
assertThat(longCounter.decrementAndGet()).isZero();
}
@Test // DATAREDIS-469
public void testGetAndIncrement() {
longCounter.set(1);
assertEquals(1, longCounter.getAndIncrement());
assertEquals(2, longCounter.get());
assertThat(longCounter.getAndIncrement()).isOne();
assertThat(longCounter.get()).isEqualTo(2);
}
@Test // DATAREDIS-469
public void testGetAndAdd() {
longCounter.set(1);
assertEquals(1, longCounter.getAndAdd(5));
assertEquals(6, longCounter.get());
assertThat(longCounter.getAndAdd(5)).isOne();
assertThat(longCounter.get()).isEqualTo(6);
}
@Test // DATAREDIS-469
public void testGetAndDecrement() {
longCounter.set(1);
assertEquals(1, longCounter.getAndDecrement());
assertEquals(0, longCounter.get());
assertThat(longCounter.getAndDecrement()).isOne();
assertThat(longCounter.get()).isZero();
}
@Test // DATAREDIS-469
public void testGetAndSet() {
longCounter.set(1);
assertEquals(1, longCounter.getAndSet(5));
assertEquals(5, longCounter.get());
assertThat(longCounter.getAndSet(5)).isOne();
assertThat(longCounter.get()).isEqualTo(5);
}
@Test
public void testGetExistingValue() throws Exception {
public void testGetExistingValue() {
longCounter.set(5);
RedisAtomicLong keyCopy = new RedisAtomicLong(longCounter.getKey(), factory);
assertEquals(longCounter.get(), keyCopy.get());
assertThat(longCounter.get()).isEqualTo(keyCopy.get());
}
@Test // DATAREDIS-317
@@ -182,7 +185,7 @@ public class RedisAtomicLongTests extends AbstractRedisAtomicsTests {
RedisAtomicLong ral = new RedisAtomicLong("DATAREDIS-317.atomicLong", template);
ral.set(32L);
assertThat(ral.get(), is(32L));
assertThat(ral.get()).isEqualTo(32L);
}
@Test // DATAREDIS-469
@@ -193,7 +196,7 @@ public class RedisAtomicLongTests extends AbstractRedisAtomicsTests {
// setup long
RedisAtomicLong test = new RedisAtomicLong("test", factory, 1);
assertThat(test.get(), equalTo(1L)); // this passes
assertThat(test.get()).isOne();
template.delete("test");
@@ -205,10 +208,10 @@ public class RedisAtomicLongTests extends AbstractRedisAtomicsTests {
// setup long
RedisAtomicLong test = new RedisAtomicLong("test", factory, 1);
assertThat(test.get(), equalTo(1L)); // this passes
assertThat(test.get()).isOne();
template.delete("test");
assertThat(test.getAndSet(2), is(0L));
assertThat(test.getAndSet(2)).isZero();
}
}