BAEL-3859 Add type to employeeNode and fix order of parameters in assertEquals method calls.

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<Employee> 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<Employee>(new Employee(123, "Mike"), true);
+        AtomicMarkableReference<Employee> employeeNode = new AtomicMarkableReference<Employee>(new Employee(123, "Mike"), true);
 
         Assertions.assertTrue(employeeNode.isMarked());
     }
 
     @Test
     void givenMarkValueAsFalse_whenUsingIsMarkedMethod_thenMarkValueShouldBeFalse() {
-        employeeNode = new AtomicMarkableReference<Employee>(new Employee(123, "Mike"), false);
+        AtomicMarkableReference<Employee> employeeNode = new AtomicMarkableReference<Employee>(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>(employee, false);
+        AtomicMarkableReference<Employee> employeeNode = new AtomicMarkableReference<Employee>(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>(employee, true);
+        AtomicMarkableReference<Employee> employeeNode = new AtomicMarkableReference<Employee>(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>(employee, true);
+        AtomicMarkableReference<Employee> employeeNode = new AtomicMarkableReference<Employee>(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>(employee, true);
+        AtomicMarkableReference<Employee> employeeNode = new AtomicMarkableReference<Employee>(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>(employee, true);
+        AtomicMarkableReference<Employee> employeeNode = new AtomicMarkableReference<Employee>(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>(employee, true);
+        AtomicMarkableReference<Employee> employeeNode = new AtomicMarkableReference<Employee>(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>(employee, true);
+        AtomicMarkableReference<Employee> employeeNode = new AtomicMarkableReference<Employee>(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>(employee, true);
+        AtomicMarkableReference<Employee> employeeNode = new AtomicMarkableReference<Employee>(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>(employee, true);
+        AtomicMarkableReference<Employee> employeeNode = new AtomicMarkableReference<Employee>(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>(employee, true);
+        AtomicMarkableReference<Employee> employeeNode = new AtomicMarkableReference<Employee>(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<Employee>(expectedEmployee, true);
+        AtomicMarkableReference<Employee> employeeNode = new AtomicMarkableReference<Employee>(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<Employee>(expectedEmployee, true);
+        AtomicMarkableReference<Employee> employeeNode = new AtomicMarkableReference<Employee>(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>(employee, true);
+        AtomicMarkableReference<Employee> employeeNode = new AtomicMarkableReference<Employee>(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());
     }
 }