diff --git a/src/main/java/org/springframework/data/redis/support/atomic/CompareAndSet.java b/src/main/java/org/springframework/data/redis/support/atomic/CompareAndSet.java index 0708d09d0..86fbf9611 100644 --- a/src/main/java/org/springframework/data/redis/support/atomic/CompareAndSet.java +++ b/src/main/java/org/springframework/data/redis/support/atomic/CompareAndSet.java @@ -44,7 +44,7 @@ class CompareAndSet implements SessionCallback { private final Supplier getter; private final Consumer setter; - private final String key; + private final Object key; private final T expect; private final T update; @@ -56,13 +56,11 @@ class CompareAndSet implements SessionCallback { @SuppressWarnings("unchecked") public Boolean execute(RedisOperations operations) throws DataAccessException { - RedisOperations ops = (RedisOperations) 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 implements SessionCallback { } } - ops.unwatch(); + operations.unwatch(); return false; } diff --git a/src/test/java/org/springframework/data/redis/support/atomic/AtomicCountersParam.java b/src/test/java/org/springframework/data/redis/support/atomic/AtomicCountersParam.java index f3c26417e..d200ac394 100644 --- a/src/test/java/org/springframework/data/redis/support/atomic/AtomicCountersParam.java +++ b/src/test/java/org/springframework/data/redis/support/atomic/AtomicCountersParam.java @@ -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 testParams() { - public static Collection 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 } }); diff --git a/src/test/java/org/springframework/data/redis/support/atomic/CompareAndSetIntegrationTests.java b/src/test/java/org/springframework/data/redis/support/atomic/CompareAndSetIntegrationTests.java index 5d9be91dc..4c094e49a 100644 --- a/src/test/java/org/springframework/data/redis/support/atomic/CompareAndSetIntegrationTests.java +++ b/src/test/java/org/springframework/data/redis/support/atomic/CompareAndSetIntegrationTests.java @@ -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 testParams() { + return AtomicCountersParam.testParams(); } @AfterClass @@ -74,9 +73,12 @@ public class CompareAndSetIntegrationTests { ConnectionFactoryTracker.cleanUp(); } - @Parameters - public static Collection 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 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 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 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); } } diff --git a/src/test/java/org/springframework/data/redis/support/atomic/RedisAtomicDoubleTests.java b/src/test/java/org/springframework/data/redis/support/atomic/RedisAtomicDoubleTests.java index d5c998dc5..860afdb69 100644 --- a/src/test/java/org/springframework/data/redis/support/atomic/RedisAtomicDoubleTests.java +++ b/src/test/java/org/springframework/data/redis/support/atomic/RedisAtomicDoubleTests.java @@ -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 testParams() { + return AtomicCountersParam.testParams(); } @AfterClass @@ -81,93 +75,99 @@ public class RedisAtomicDoubleTests extends AbstractRedisAtomicsTests { ConnectionFactoryTracker.cleanUp(); } - @Parameters - public static Collection 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(); } } diff --git a/src/test/java/org/springframework/data/redis/support/atomic/RedisAtomicIntegerTests.java b/src/test/java/org/springframework/data/redis/support/atomic/RedisAtomicIntegerTests.java index 2a95fc003..74f1c1539 100644 --- a/src/test/java/org/springframework/data/redis/support/atomic/RedisAtomicIntegerTests.java +++ b/src/test/java/org/springframework/data/redis/support/atomic/RedisAtomicIntegerTests.java @@ -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 testParams() { + return AtomicCountersParam.testParams(); } @AfterClass @@ -79,73 +75,78 @@ public class RedisAtomicIntegerTests extends AbstractRedisAtomicsTests { ConnectionFactoryTracker.cleanUp(); } - @Parameters - public static Collection 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(); } } diff --git a/src/test/java/org/springframework/data/redis/support/atomic/RedisAtomicLongTests.java b/src/test/java/org/springframework/data/redis/support/atomic/RedisAtomicLongTests.java index 3ee5a10ee..380341543 100644 --- a/src/test/java/org/springframework/data/redis/support/atomic/RedisAtomicLongTests.java +++ b/src/test/java/org/springframework/data/redis/support/atomic/RedisAtomicLongTests.java @@ -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 testParams() { + return AtomicCountersParam.testParams(); } @AfterClass @@ -76,77 +73,83 @@ public class RedisAtomicLongTests extends AbstractRedisAtomicsTests { ConnectionFactoryTracker.cleanUp(); } - @Parameters - public static Collection 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(); } }