From ae6aaf40f057741fec9429fa5ba1e6576fe6310f Mon Sep 17 00:00:00 2001 From: Florin Hriscu Date: Tue, 10 Mar 2020 00:50:53 +0200 Subject: [PATCH 1/4] BAEL-3859 - Add implementation for AtomicMarkableReference article. --- .../AtomicMarkableReferenceUnitTest.java | 193 ++++++++++++++++++ 1 file changed, 193 insertions(+) create mode 100644 core-java-modules/core-java-concurrency-basic-2/src/test/java/com/baeldung/concurrent/atomic/AtomicMarkableReferenceUnitTest.java diff --git a/core-java-modules/core-java-concurrency-basic-2/src/test/java/com/baeldung/concurrent/atomic/AtomicMarkableReferenceUnitTest.java b/core-java-modules/core-java-concurrency-basic-2/src/test/java/com/baeldung/concurrent/atomic/AtomicMarkableReferenceUnitTest.java new file mode 100644 index 0000000000..b864c78559 --- /dev/null +++ b/core-java-modules/core-java-concurrency-basic-2/src/test/java/com/baeldung/concurrent/atomic/AtomicMarkableReferenceUnitTest.java @@ -0,0 +1,193 @@ +package com.baeldung.concurrent.atomic; + +import java.util.Objects; +import java.util.concurrent.atomic.AtomicMarkableReference; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; + +public class AtomicMarkableReferenceUnitTest { + + private AtomicMarkableReference employeeNode; + + class Employee { + private int id; + private String name; + + Employee(int id, String name) { + this.id = id; + this.name = name; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj == null) { + return false; + } + if (!(obj instanceof Employee)) + return false; + Employee employee = (Employee) obj; + return id == employee.id && name.equals(employee.name); + } + + @Override + public int hashCode() { + return Objects.hash(id, name); + } + } + + @Test + void givenMarkValueAsTrue_whenUsingIsMarkedMethod_thenMarkValueShouldBeTrue() { + employeeNode = new AtomicMarkableReference(new Employee(123, "Mike"), true); + + Assertions.assertTrue(employeeNode.isMarked()); + } + + @Test + void givenMarkValueAsFalse_whenUsingIsMarkedMethod_thenMarkValueShouldBeFalse() { + employeeNode = new AtomicMarkableReference(new Employee(123, "Mike"), false); + + Assertions.assertFalse(employeeNode.isMarked()); + } + + @Test + void whenUsingGetReferenceMethod_thenCurrentReferenceShouldBeReturned() { + Employee employee = new Employee(123, "Mike"); + employeeNode = new AtomicMarkableReference(employee, false); + + Assertions.assertEquals(employeeNode.getReference(), employee); + } + + @Test + void whenUsingGetMethod_thenCurrentReferenceAndMarkShouldBeReturned() { + Employee employee = new Employee(123, "Mike"); + employeeNode = new AtomicMarkableReference(employee, true); + + boolean[] markHolder = new boolean[1]; + Employee currentEmployee = employeeNode.get(markHolder); + + Assertions.assertEquals(currentEmployee, employee); + Assertions.assertTrue(markHolder[0]); + } + + @Test + void givenNewReferenceAndMark_whenUsingSetMethod_thenCurrentReferenceAndMarkShouldBeUpdated() { + Employee employee = new Employee(123, "Mike"); + employeeNode = new AtomicMarkableReference(employee, true); + + Employee newEmployee = new Employee(124, "John"); + employeeNode.set(newEmployee, false); + + Assertions.assertEquals(employeeNode.getReference(), newEmployee); + Assertions.assertFalse(employeeNode.isMarked()); + } + + @Test + void givenTheSameObjectReference_whenUsingAttemptMarkMethod_thenMarkShouldBeUpdated() { + Employee employee = new Employee(123, "Mike"); + employeeNode = new AtomicMarkableReference(employee, true); + + Assertions.assertTrue(employeeNode.attemptMark(employee, false)); + Assertions.assertFalse(employeeNode.isMarked()); + } + + @Test + void givenDifferentObjectReference_whenUsingAttemptMarkMethod_thenMarkShouldNotBeUpdated() { + Employee employee = new Employee(123, "Mike"); + Employee expectedEmployee = new Employee(123, "Mike"); + employeeNode = new AtomicMarkableReference(employee, true); + + Assertions.assertFalse(employeeNode.attemptMark(expectedEmployee, false)); + Assertions.assertTrue(employeeNode.isMarked()); + } + + @Test + void givenCurrentReferenceAndCurrentMark_whenUsingCompareAndSet_thenReferenceAndMarkShouldBeUpdated() { + Employee employee = new Employee(123, "Mike"); + employeeNode = new AtomicMarkableReference(employee, true); + Employee newEmployee = new Employee(124, "John"); + + Assertions.assertTrue(employeeNode.compareAndSet(employee, newEmployee, true, false)); + Assertions.assertEquals(employeeNode.getReference(), newEmployee); + Assertions.assertFalse(employeeNode.isMarked()); + } + + @Test + void givenNotCurrentReferenceAndCurrentMark_whenUsingCompareAndSet_thenReferenceAndMarkShouldNotBeUpdated() { + Employee employee = new Employee(123, "Mike"); + employeeNode = new AtomicMarkableReference(employee, true); + Employee newEmployee = new Employee(124, "John"); + + Assertions.assertFalse(employeeNode.compareAndSet(new Employee(1234, "Steve"), newEmployee, true, false)); + Assertions.assertEquals(employeeNode.getReference(), employee); + Assertions.assertTrue(employeeNode.isMarked()); + } + + @Test + void givenCurrentReferenceAndNotCurrentMark_whenUsingCompareAndSet_thenReferenceAndMarkShouldNotBeUpdated() { + Employee employee = new Employee(123, "Mike"); + employeeNode = new AtomicMarkableReference(employee, true); + Employee newEmployee = new Employee(124, "John"); + + Assertions.assertFalse(employeeNode.compareAndSet(employee, newEmployee, false, true)); + Assertions.assertEquals(employeeNode.getReference(), employee); + Assertions.assertTrue(employeeNode.isMarked()); + } + + @Test + void givenNotCurrentReferenceAndNotCurrentMark_whenUsingCompareAndSet_thenReferenceAndMarkShouldNotBeUpdated() { + Employee employee = new Employee(123, "Mike"); + employeeNode = new AtomicMarkableReference(employee, true); + Employee newEmployee = new Employee(124, "John"); + + Assertions.assertFalse(employeeNode.compareAndSet(new Employee(1234, "Steve"), newEmployee, false, true)); + Assertions.assertEquals(employeeNode.getReference(), employee); + Assertions.assertTrue(employeeNode.isMarked()); + } + + @Test + void givenCurrentReferenceAndCurrentMark_whenUsingWeakCompareAndSet_thenReferenceAndMarkShouldBeUpdated() { + Employee employee = new Employee(123, "Mike"); + employeeNode = new AtomicMarkableReference(employee, true); + Employee newEmployee = new Employee(124, "John"); + + Assertions.assertTrue(employeeNode.weakCompareAndSet(employee, newEmployee, true, false)); + Assertions.assertEquals(employeeNode.getReference(), newEmployee); + Assertions.assertFalse(employeeNode.isMarked()); + } + + @Test + void givenNotCurrentReferenceAndCurrentMark_whenUsingWeakCompareAndSet_thenReferenceAndMarkShouldNotBeUpdated() { + Employee expectedEmployee = new Employee(123, "Mike"); + employeeNode = new AtomicMarkableReference(expectedEmployee, true); + Employee newEmployee = new Employee(124, "John"); + + Assertions.assertFalse(employeeNode.weakCompareAndSet(new Employee(1234, "Steve"), newEmployee, true, false)); + Assertions.assertEquals(employeeNode.getReference(), expectedEmployee); + Assertions.assertTrue(employeeNode.isMarked()); + } + + @Test + void givenCurrentReferenceAndNotCurrentMark_whenUsingWeakCompareAndSet_thenReferenceAndMarkShouldNotBeUpdated() { + Employee expectedEmployee = new Employee(123, "Mike"); + employeeNode = new AtomicMarkableReference(expectedEmployee, true); + Employee newEmployee = new Employee(124, "John"); + + Assertions.assertFalse(employeeNode.weakCompareAndSet(expectedEmployee, newEmployee, false, true)); + Assertions.assertEquals(employeeNode.getReference(), expectedEmployee); + Assertions.assertTrue(employeeNode.isMarked()); + } + + @Test + void givenNotCurrentReferenceAndNotCurrentMark_whenUsingWeakCompareAndSet_thenReferenceAndMarkShouldNotBeUpdated() { + Employee employee = new Employee(123, "Mike"); + employeeNode = new AtomicMarkableReference(employee, true); + Employee newEmployee = new Employee(124, "John"); + + Assertions.assertFalse(employeeNode.weakCompareAndSet(new Employee(1234, "Steve"), newEmployee, false, true)); + Assertions.assertEquals(employeeNode.getReference(), employee); + Assertions.assertTrue(employeeNode.isMarked()); + } +} From 205ee99874c09154d3416729ca964149a72e57a1 Mon Sep 17 00:00:00 2001 From: Florin Hriscu Date: Fri, 13 Mar 2020 21:25:17 +0200 Subject: [PATCH 2/4] BAEL-3859 Remove unnecessary equals and hashcode overriden methods. --- .../AtomicMarkableReferenceUnitTest.java | 28 ++++++++----------- 1 file changed, 12 insertions(+), 16 deletions(-) diff --git a/core-java-modules/core-java-concurrency-basic-2/src/test/java/com/baeldung/concurrent/atomic/AtomicMarkableReferenceUnitTest.java b/core-java-modules/core-java-concurrency-basic-2/src/test/java/com/baeldung/concurrent/atomic/AtomicMarkableReferenceUnitTest.java index b864c78559..4ac9e53a43 100644 --- a/core-java-modules/core-java-concurrency-basic-2/src/test/java/com/baeldung/concurrent/atomic/AtomicMarkableReferenceUnitTest.java +++ b/core-java-modules/core-java-concurrency-basic-2/src/test/java/com/baeldung/concurrent/atomic/AtomicMarkableReferenceUnitTest.java @@ -1,6 +1,5 @@ package com.baeldung.concurrent.atomic; -import java.util.Objects; import java.util.concurrent.atomic.AtomicMarkableReference; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; @@ -18,24 +17,21 @@ public class AtomicMarkableReferenceUnitTest { this.name = name; } - @Override - public boolean equals(Object obj) { - if (this == obj) { - return true; - } - if (obj == null) { - return false; - } - if (!(obj instanceof Employee)) - return false; - Employee employee = (Employee) obj; - return id == employee.id && name.equals(employee.name); + public int getId() { + return id; } - @Override - public int hashCode() { - return Objects.hash(id, name); + public void setId(int id) { + this.id = id; } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } } @Test From f7ae2095371e0c0852724a63c53ea3d14d78367e Mon Sep 17 00:00:00 2001 From: Florin Hriscu Date: Fri, 13 Mar 2020 22:46:41 +0200 Subject: [PATCH 3/4] BAEL-3859 Add type to employeeNode and fix order of parameters in assertEquals method calls. --- .../AtomicMarkableReferenceUnitTest.java | 56 +++++++++---------- 1 file changed, 27 insertions(+), 29 deletions(-) diff --git a/core-java-modules/core-java-concurrency-basic-2/src/test/java/com/baeldung/concurrent/atomic/AtomicMarkableReferenceUnitTest.java b/core-java-modules/core-java-concurrency-basic-2/src/test/java/com/baeldung/concurrent/atomic/AtomicMarkableReferenceUnitTest.java index 4ac9e53a43..d83146c6e8 100644 --- a/core-java-modules/core-java-concurrency-basic-2/src/test/java/com/baeldung/concurrent/atomic/AtomicMarkableReferenceUnitTest.java +++ b/core-java-modules/core-java-concurrency-basic-2/src/test/java/com/baeldung/concurrent/atomic/AtomicMarkableReferenceUnitTest.java @@ -6,8 +6,6 @@ import org.junit.jupiter.api.Test; public class AtomicMarkableReferenceUnitTest { - private AtomicMarkableReference employeeNode; - class Employee { private int id; private String name; @@ -31,19 +29,19 @@ public class AtomicMarkableReferenceUnitTest { public void setName(String name) { this.name = name; - } + } } @Test void givenMarkValueAsTrue_whenUsingIsMarkedMethod_thenMarkValueShouldBeTrue() { - employeeNode = new AtomicMarkableReference(new Employee(123, "Mike"), true); + AtomicMarkableReference employeeNode = new AtomicMarkableReference(new Employee(123, "Mike"), true); Assertions.assertTrue(employeeNode.isMarked()); } @Test void givenMarkValueAsFalse_whenUsingIsMarkedMethod_thenMarkValueShouldBeFalse() { - employeeNode = new AtomicMarkableReference(new Employee(123, "Mike"), false); + AtomicMarkableReference employeeNode = new AtomicMarkableReference(new Employee(123, "Mike"), false); Assertions.assertFalse(employeeNode.isMarked()); } @@ -51,39 +49,39 @@ public class AtomicMarkableReferenceUnitTest { @Test void whenUsingGetReferenceMethod_thenCurrentReferenceShouldBeReturned() { Employee employee = new Employee(123, "Mike"); - employeeNode = new AtomicMarkableReference(employee, false); + AtomicMarkableReference employeeNode = new AtomicMarkableReference(employee, false); - Assertions.assertEquals(employeeNode.getReference(), employee); + Assertions.assertEquals(employee, employeeNode.getReference()); } @Test void whenUsingGetMethod_thenCurrentReferenceAndMarkShouldBeReturned() { Employee employee = new Employee(123, "Mike"); - employeeNode = new AtomicMarkableReference(employee, true); + AtomicMarkableReference employeeNode = new AtomicMarkableReference(employee, true); boolean[] markHolder = new boolean[1]; Employee currentEmployee = employeeNode.get(markHolder); - Assertions.assertEquals(currentEmployee, employee); + Assertions.assertEquals(employee, currentEmployee); Assertions.assertTrue(markHolder[0]); } @Test void givenNewReferenceAndMark_whenUsingSetMethod_thenCurrentReferenceAndMarkShouldBeUpdated() { Employee employee = new Employee(123, "Mike"); - employeeNode = new AtomicMarkableReference(employee, true); + AtomicMarkableReference employeeNode = new AtomicMarkableReference(employee, true); Employee newEmployee = new Employee(124, "John"); employeeNode.set(newEmployee, false); - Assertions.assertEquals(employeeNode.getReference(), newEmployee); + Assertions.assertEquals(newEmployee, employeeNode.getReference()); Assertions.assertFalse(employeeNode.isMarked()); } @Test void givenTheSameObjectReference_whenUsingAttemptMarkMethod_thenMarkShouldBeUpdated() { Employee employee = new Employee(123, "Mike"); - employeeNode = new AtomicMarkableReference(employee, true); + AtomicMarkableReference employeeNode = new AtomicMarkableReference(employee, true); Assertions.assertTrue(employeeNode.attemptMark(employee, false)); Assertions.assertFalse(employeeNode.isMarked()); @@ -93,7 +91,7 @@ public class AtomicMarkableReferenceUnitTest { void givenDifferentObjectReference_whenUsingAttemptMarkMethod_thenMarkShouldNotBeUpdated() { Employee employee = new Employee(123, "Mike"); Employee expectedEmployee = new Employee(123, "Mike"); - employeeNode = new AtomicMarkableReference(employee, true); + AtomicMarkableReference employeeNode = new AtomicMarkableReference(employee, true); Assertions.assertFalse(employeeNode.attemptMark(expectedEmployee, false)); Assertions.assertTrue(employeeNode.isMarked()); @@ -102,88 +100,88 @@ public class AtomicMarkableReferenceUnitTest { @Test void givenCurrentReferenceAndCurrentMark_whenUsingCompareAndSet_thenReferenceAndMarkShouldBeUpdated() { Employee employee = new Employee(123, "Mike"); - employeeNode = new AtomicMarkableReference(employee, true); + AtomicMarkableReference employeeNode = new AtomicMarkableReference(employee, true); Employee newEmployee = new Employee(124, "John"); Assertions.assertTrue(employeeNode.compareAndSet(employee, newEmployee, true, false)); - Assertions.assertEquals(employeeNode.getReference(), newEmployee); + Assertions.assertEquals(newEmployee, employeeNode.getReference()); Assertions.assertFalse(employeeNode.isMarked()); } @Test void givenNotCurrentReferenceAndCurrentMark_whenUsingCompareAndSet_thenReferenceAndMarkShouldNotBeUpdated() { Employee employee = new Employee(123, "Mike"); - employeeNode = new AtomicMarkableReference(employee, true); + AtomicMarkableReference employeeNode = new AtomicMarkableReference(employee, true); Employee newEmployee = new Employee(124, "John"); Assertions.assertFalse(employeeNode.compareAndSet(new Employee(1234, "Steve"), newEmployee, true, false)); - Assertions.assertEquals(employeeNode.getReference(), employee); + Assertions.assertEquals(employee, employeeNode.getReference()); Assertions.assertTrue(employeeNode.isMarked()); } @Test void givenCurrentReferenceAndNotCurrentMark_whenUsingCompareAndSet_thenReferenceAndMarkShouldNotBeUpdated() { Employee employee = new Employee(123, "Mike"); - employeeNode = new AtomicMarkableReference(employee, true); + AtomicMarkableReference employeeNode = new AtomicMarkableReference(employee, true); Employee newEmployee = new Employee(124, "John"); Assertions.assertFalse(employeeNode.compareAndSet(employee, newEmployee, false, true)); - Assertions.assertEquals(employeeNode.getReference(), employee); + Assertions.assertEquals(employee, employeeNode.getReference()); Assertions.assertTrue(employeeNode.isMarked()); } @Test void givenNotCurrentReferenceAndNotCurrentMark_whenUsingCompareAndSet_thenReferenceAndMarkShouldNotBeUpdated() { Employee employee = new Employee(123, "Mike"); - employeeNode = new AtomicMarkableReference(employee, true); + AtomicMarkableReference employeeNode = new AtomicMarkableReference(employee, true); Employee newEmployee = new Employee(124, "John"); Assertions.assertFalse(employeeNode.compareAndSet(new Employee(1234, "Steve"), newEmployee, false, true)); - Assertions.assertEquals(employeeNode.getReference(), employee); + Assertions.assertEquals(employee, employeeNode.getReference()); Assertions.assertTrue(employeeNode.isMarked()); } @Test void givenCurrentReferenceAndCurrentMark_whenUsingWeakCompareAndSet_thenReferenceAndMarkShouldBeUpdated() { Employee employee = new Employee(123, "Mike"); - employeeNode = new AtomicMarkableReference(employee, true); + AtomicMarkableReference employeeNode = new AtomicMarkableReference(employee, true); Employee newEmployee = new Employee(124, "John"); Assertions.assertTrue(employeeNode.weakCompareAndSet(employee, newEmployee, true, false)); - Assertions.assertEquals(employeeNode.getReference(), newEmployee); + Assertions.assertEquals(newEmployee, employeeNode.getReference()); Assertions.assertFalse(employeeNode.isMarked()); } @Test void givenNotCurrentReferenceAndCurrentMark_whenUsingWeakCompareAndSet_thenReferenceAndMarkShouldNotBeUpdated() { Employee expectedEmployee = new Employee(123, "Mike"); - employeeNode = new AtomicMarkableReference(expectedEmployee, true); + AtomicMarkableReference employeeNode = new AtomicMarkableReference(expectedEmployee, true); Employee newEmployee = new Employee(124, "John"); Assertions.assertFalse(employeeNode.weakCompareAndSet(new Employee(1234, "Steve"), newEmployee, true, false)); - Assertions.assertEquals(employeeNode.getReference(), expectedEmployee); + Assertions.assertEquals(expectedEmployee, employeeNode.getReference()); Assertions.assertTrue(employeeNode.isMarked()); } @Test void givenCurrentReferenceAndNotCurrentMark_whenUsingWeakCompareAndSet_thenReferenceAndMarkShouldNotBeUpdated() { Employee expectedEmployee = new Employee(123, "Mike"); - employeeNode = new AtomicMarkableReference(expectedEmployee, true); + AtomicMarkableReference employeeNode = new AtomicMarkableReference(expectedEmployee, true); Employee newEmployee = new Employee(124, "John"); Assertions.assertFalse(employeeNode.weakCompareAndSet(expectedEmployee, newEmployee, false, true)); - Assertions.assertEquals(employeeNode.getReference(), expectedEmployee); + Assertions.assertEquals(expectedEmployee, employeeNode.getReference()); Assertions.assertTrue(employeeNode.isMarked()); } @Test void givenNotCurrentReferenceAndNotCurrentMark_whenUsingWeakCompareAndSet_thenReferenceAndMarkShouldNotBeUpdated() { Employee employee = new Employee(123, "Mike"); - employeeNode = new AtomicMarkableReference(employee, true); + AtomicMarkableReference employeeNode = new AtomicMarkableReference(employee, true); Employee newEmployee = new Employee(124, "John"); Assertions.assertFalse(employeeNode.weakCompareAndSet(new Employee(1234, "Steve"), newEmployee, false, true)); - Assertions.assertEquals(employeeNode.getReference(), employee); + Assertions.assertEquals(employee, employeeNode.getReference()); Assertions.assertTrue(employeeNode.isMarked()); } } From 3aa7a8f8a2bcf9d17f3c2b503b780fc06d3bed1b Mon Sep 17 00:00:00 2001 From: Florin Hriscu Date: Mon, 16 Mar 2020 01:42:29 +0200 Subject: [PATCH 4/4] BAEL-3859 Changes after review. --- .../AtomicMarkableReferenceUnitTest.java | 24 ++++++++++--------- 1 file changed, 13 insertions(+), 11 deletions(-) diff --git a/core-java-modules/core-java-concurrency-basic-2/src/test/java/com/baeldung/concurrent/atomic/AtomicMarkableReferenceUnitTest.java b/core-java-modules/core-java-concurrency-basic-2/src/test/java/com/baeldung/concurrent/atomic/AtomicMarkableReferenceUnitTest.java index d83146c6e8..5f526344be 100644 --- a/core-java-modules/core-java-concurrency-basic-2/src/test/java/com/baeldung/concurrent/atomic/AtomicMarkableReferenceUnitTest.java +++ b/core-java-modules/core-java-concurrency-basic-2/src/test/java/com/baeldung/concurrent/atomic/AtomicMarkableReferenceUnitTest.java @@ -34,14 +34,16 @@ public class AtomicMarkableReferenceUnitTest { @Test void givenMarkValueAsTrue_whenUsingIsMarkedMethod_thenMarkValueShouldBeTrue() { - AtomicMarkableReference employeeNode = new AtomicMarkableReference(new Employee(123, "Mike"), true); + Employee employee = new Employee(123, "Mike"); + AtomicMarkableReference employeeNode = new AtomicMarkableReference(employee, true); Assertions.assertTrue(employeeNode.isMarked()); } @Test void givenMarkValueAsFalse_whenUsingIsMarkedMethod_thenMarkValueShouldBeFalse() { - AtomicMarkableReference employeeNode = new AtomicMarkableReference(new Employee(123, "Mike"), false); + Employee employee = new Employee(123, "Mike"); + AtomicMarkableReference employeeNode = new AtomicMarkableReference(employee, false); Assertions.assertFalse(employeeNode.isMarked()); } @@ -49,7 +51,7 @@ public class AtomicMarkableReferenceUnitTest { @Test void whenUsingGetReferenceMethod_thenCurrentReferenceShouldBeReturned() { Employee employee = new Employee(123, "Mike"); - AtomicMarkableReference employeeNode = new AtomicMarkableReference(employee, false); + AtomicMarkableReference employeeNode = new AtomicMarkableReference(employee, true); Assertions.assertEquals(employee, employeeNode.getReference()); } @@ -90,8 +92,8 @@ public class AtomicMarkableReferenceUnitTest { @Test void givenDifferentObjectReference_whenUsingAttemptMarkMethod_thenMarkShouldNotBeUpdated() { Employee employee = new Employee(123, "Mike"); - Employee expectedEmployee = new Employee(123, "Mike"); AtomicMarkableReference employeeNode = new AtomicMarkableReference(employee, true); + Employee expectedEmployee = new Employee(123, "Mike"); Assertions.assertFalse(employeeNode.attemptMark(expectedEmployee, false)); Assertions.assertTrue(employeeNode.isMarked()); @@ -154,23 +156,23 @@ public class AtomicMarkableReferenceUnitTest { @Test void givenNotCurrentReferenceAndCurrentMark_whenUsingWeakCompareAndSet_thenReferenceAndMarkShouldNotBeUpdated() { - Employee expectedEmployee = new Employee(123, "Mike"); - AtomicMarkableReference employeeNode = new AtomicMarkableReference(expectedEmployee, true); + Employee employee = new Employee(123, "Mike"); + AtomicMarkableReference employeeNode = new AtomicMarkableReference(employee, true); Employee newEmployee = new Employee(124, "John"); Assertions.assertFalse(employeeNode.weakCompareAndSet(new Employee(1234, "Steve"), newEmployee, true, false)); - Assertions.assertEquals(expectedEmployee, employeeNode.getReference()); + Assertions.assertEquals(employee, employeeNode.getReference()); Assertions.assertTrue(employeeNode.isMarked()); } @Test void givenCurrentReferenceAndNotCurrentMark_whenUsingWeakCompareAndSet_thenReferenceAndMarkShouldNotBeUpdated() { - Employee expectedEmployee = new Employee(123, "Mike"); - AtomicMarkableReference employeeNode = new AtomicMarkableReference(expectedEmployee, true); + Employee employee = new Employee(123, "Mike"); + AtomicMarkableReference employeeNode = new AtomicMarkableReference(employee, true); Employee newEmployee = new Employee(124, "John"); - Assertions.assertFalse(employeeNode.weakCompareAndSet(expectedEmployee, newEmployee, false, true)); - Assertions.assertEquals(expectedEmployee, employeeNode.getReference()); + Assertions.assertFalse(employeeNode.weakCompareAndSet(employee, newEmployee, false, true)); + Assertions.assertEquals(employee, employeeNode.getReference()); Assertions.assertTrue(employeeNode.isMarked()); }