test clang format

Author: itakurah

src/main/java/com/thealgorithms/datastructures/crdt/LWWElementSet.java

@@ -14,94 +14,94 @@
  *
  * @param <T> The type of the elements in the LWWElementSet.
  * @author <a href="https://github.com/itakurah">itakurah (GitHub)</a>, <a
- *     href="https://www.linkedin.com/in/niklashoefflin/">Niklas Hoefflin (LinkedIn)</a>
+ * href="https://www.linkedin.com/in/niklashoefflin/">Niklas Hoefflin (LinkedIn)</a>
  * @see <a href="https://en.wikipedia.org/wiki/Conflict-free_replicated_data_type">Conflict free
- *     replicated data type (Wikipedia)</a>
+ * replicated data type (Wikipedia)</a>
  * @see <a href="https://inria.hal.science/inria-00555588v1/document">A comprehensive study of
- *     Convergent and Commutative Replicated Data Types</a>
+ * Convergent and Commutative Replicated Data Types</a>
  */
 class LWWElementSet<T> {
-  final Map<T, Element<T>> addSet;
-  final Map<T, Element<T>> removeSet;
+    final Map<T, Element<T>> addSet;
+    final Map<T, Element<T>> removeSet;
 
-  /**
-   * Constructs an empty LWWElementSet. This constructor initializes the addSet and removeSet as
-   * empty HashMaps. The addSet stores elements that are added, and the removeSet stores elements
-   * that are removed.
-   */
-  LWWElementSet() {
-    this.addSet = new HashMap<>();
-    this.removeSet = new HashMap<>();
-  }
-
-  /**
-   * Adds an element to the addSet with the current timestamp. This method stores the element in the
-   * addSet, ensuring that the element is added to the set with an associated timestamp that
-   * represents the time of the addition.
-   *
-   * @param key The key of the element to be added.
-   */
-  public void add(T key) {
-    addSet.put(key, new Element<>(key, Instant.now()));
-  }
+    /**
+     * Constructs an empty LWWElementSet. This constructor initializes the addSet and removeSet as
+     * empty HashMaps. The addSet stores elements that are added, and the removeSet stores elements
+     * that are removed.
+     */
+    LWWElementSet() {
+        this.addSet = new HashMap<>();
+        this.removeSet = new HashMap<>();
+    }
 
-  /**
-   * Removes an element by adding it to the removeSet with the current timestamp. This method adds
-   * the element to the removeSet, marking it as removed with the current timestamp.
-   *
-   * @param key The key of the element to be removed.
-   */
-  public void remove(T key) {
-    removeSet.put(key, new Element<>(key, Instant.now()));
-  }
+    /**
+     * Adds an element to the addSet with the current timestamp. This method stores the element in the
+     * addSet, ensuring that the element is added to the set with an associated timestamp that
+     * represents the time of the addition.
+     *
+     * @param key The key of the element to be added.
+     */
+    public void add(T key) {
+        addSet.put(key, new Element<>(key, Instant.now()));
+    }
 
-  /**
-   * Checks if an element is in the LWWElementSet. An element is considered present if it exists in
-   * the addSet and either does not exist in the removeSet, or its add timestamp is later than any
-   * corresponding remove timestamp.
-   *
-   * @param key The key of the element to be checked.
-   * @return {@code true} if the element is present in the set (i.e., its add timestamp is later
-   *     than its remove timestamp, or it is not in the remove set), {@code false} otherwise (i.e.,
-   *     the element has been removed or its remove timestamp is later than its add timestamp).
-   */
-  public boolean lookup(T key) {
-    Element<T> inAddSet = addSet.get(key);
-    Element<T> inRemoveSet = removeSet.get(key);
+    /**
+     * Removes an element by adding it to the removeSet with the current timestamp. This method adds
+     * the element to the removeSet, marking it as removed with the current timestamp.
+     *
+     * @param key The key of the element to be removed.
+     */
+    public void remove(T key) {
+        removeSet.put(key, new Element<>(key, Instant.now()));
+    }
 
-    return inAddSet != null
-        && (inRemoveSet == null || inAddSet.timestamp.isAfter(inRemoveSet.timestamp));
-  }
+    /**
+     * Checks if an element is in the LWWElementSet. An element is considered present if it exists in
+     * the addSet and either does not exist in the removeSet, or its add timestamp is later than any
+     * corresponding remove timestamp.
+     *
+     * @param key The key of the element to be checked.
+     * @return {@code true} if the element is present in the set (i.e., its add timestamp is later
+     * than its remove timestamp, or it is not in the remove set), {@code false} otherwise (i.e.,
+     * the element has been removed or its remove timestamp is later than its add timestamp).
+     */
+    public boolean lookup(T key) {
+        Element<T> inAddSet = addSet.get(key);
+        Element<T> inRemoveSet = removeSet.get(key);
 
-  /**
-   * Merges another LWWElementSet into this set. This method takes the union of both the add-sets
-   * and remove-sets from the two sets, resolving conflicts by keeping the element with the latest
-   * timestamp. If an element appears in both the add-set and remove-set of both sets, the one with
-   * the later timestamp will be retained.
-   *
-   * @param other The LWWElementSet to merge with the current set.
-   */
-  public void merge(LWWElementSet<T> other) {
-    for (Map.Entry<T, Element<T>> entry : other.addSet.entrySet()) {
-      addSet.merge(entry.getKey(), entry.getValue(), this::resolveConflict);
+        return inAddSet != null
+                && (inRemoveSet == null || inAddSet.timestamp.isAfter(inRemoveSet.timestamp));
     }
-    for (Map.Entry<T, Element<T>> entry : other.removeSet.entrySet()) {
-      removeSet.merge(entry.getKey(), entry.getValue(), this::resolveConflict);
+
+    /**
+     * Merges another LWWElementSet into this set. This method takes the union of both the add-sets
+     * and remove-sets from the two sets, resolving conflicts by keeping the element with the latest
+     * timestamp. If an element appears in both the add-set and remove-set of both sets, the one with
+     * the later timestamp will be retained.
+     *
+     * @param other The LWWElementSet to merge with the current set.
+     */
+    public void merge(LWWElementSet<T> other) {
+        for (Map.Entry<T, Element<T>> entry : other.addSet.entrySet()) {
+            addSet.merge(entry.getKey(), entry.getValue(), this::resolveConflict);
+        }
+        for (Map.Entry<T, Element<T>> entry : other.removeSet.entrySet()) {
+            removeSet.merge(entry.getKey(), entry.getValue(), this::resolveConflict);
+        }
     }
-  }
 
-  /**
-   * Resolves conflicts between two elements by selecting the one with the later timestamp. This
-   * method is used when merging two LWWElementSets to ensure that the most recent operation (based
-   * on timestamps) is kept.
-   *
-   * @param e1 The first element.
-   * @param e2 The second element.
-   * @return The element with the later timestamp.
-   */
-  private Element<T> resolveConflict(Element<T> e1, Element<T> e2) {
-    return e1.timestamp.isAfter(e2.timestamp) ? e1 : e2;
-  }
+    /**
+     * Resolves conflicts between two elements by selecting the one with the later timestamp. This
+     * method is used when merging two LWWElementSets to ensure that the most recent operation (based
+     * on timestamps) is kept.
+     *
+     * @param e1 The first element.
+     * @param e2 The second element.
+     * @return The element with the later timestamp.
+     */
+    private Element<T> resolveConflict(Element<T> e1, Element<T> e2) {
+        return e1.timestamp.isAfter(e2.timestamp) ? e1 : e2;
+    }
 }
 
 /**
@@ -111,17 +111,17 @@ private Element<T> resolveConflict(Element<T> e1, Element<T> e2) {
  * @param <T> The type of the key associated with the element.
  */
 class Element<T> {
-  T key;
-  Instant timestamp;
+    T key;
+    Instant timestamp;
 
-  /**
-   * Constructs a new Element with the specified key and timestamp.
-   *
-   * @param key The key of the element.
-   * @param timestamp The timestamp associated with the element.
-   */
-  Element(T key, Instant timestamp) {
-    this.key = key;
-    this.timestamp = timestamp;
-  }
+    /**
+     * Constructs a new Element with the specified key and timestamp.
+     *
+     * @param key       The key of the element.
+     * @param timestamp The timestamp associated with the element.
+     */
+    Element(T key, Instant timestamp) {
+        this.key = key;
+        this.timestamp = timestamp;
+    }
 }

src/test/java/com/thealgorithms/datastructures/crdt/LWWElementSetTest.java

@@ -1,97 +1,99 @@
 package com.thealgorithms.datastructures.crdt;
 
-import static org.junit.jupiter.api.Assertions.*;
+import org.junit.jupiter.api.Test;
 
 import java.time.Instant;
-import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 class LWWElementSetTest {
 
-  @Test
-  void testAddElement() {
-    LWWElementSet<String> set = new LWWElementSet<>();
-    set.add("A");
-    assertTrue(set.lookup("A"));
-  }
-
-  @Test
-  void testRemoveElement() {
-    LWWElementSet<String> set = new LWWElementSet<>();
-    set.add("A");
-    set.remove("A");
-    assertFalse(set.lookup("A"));
-  }
-
-  @Test
-  void testLookupWithoutAdding() {
-    LWWElementSet<String> set = new LWWElementSet<>();
-    assertFalse(set.lookup("A"));
-  }
-
-  @Test
-  void testLookupLaterTimestampsFalse() {
-    LWWElementSet<String> set = new LWWElementSet<>();
-
-    set.addSet.put("A", new Element<>("A", Instant.now()));
-    set.removeSet.put("A", new Element<>("A", Instant.now().plusSeconds(10)));
-
-    assertFalse(set.lookup("A"));
-  }
-
-  @Test
-  void testLookupEarlierTimestampsTrue() {
-    LWWElementSet<String> set = new LWWElementSet<>();
-
-    set.addSet.put("A", new Element<>("A", Instant.now()));
-    set.removeSet.put("A", new Element<>("A", Instant.now().minusSeconds(10)));
-
-    assertTrue(set.lookup("A"));
-  }
-
-  @Test
-  void testLookupWithConcurrentTimestamps() {
-    LWWElementSet<String> set = new LWWElementSet<>();
-    Instant now = Instant.now();
-    set.addSet.put("A", new Element<>("A", now));
-    set.removeSet.put("A", new Element<>("A", now));
-    assertFalse(set.lookup("A"));
-  }
-
-  @Test
-  void testMergeTwoSets() {
-    LWWElementSet<String> set1 = new LWWElementSet<>();
-    LWWElementSet<String> set2 = new LWWElementSet<>();
-
-    set1.add("A");
-    set2.add("B");
-    set2.remove("A");
-
-    set1.merge(set2);
-
-    assertFalse(set1.lookup("A"));
-    assertTrue(set1.lookup("B"));
-  }
-
-  @Test
-  void testMergeWithConflictingTimestamps() {
-    LWWElementSet<String> set1 = new LWWElementSet<>();
-    LWWElementSet<String> set2 = new LWWElementSet<>();
-
-    Instant now = Instant.now();
-    set1.addSet.put("A", new Element<>("A", now.minusSeconds(10)));
-    set2.addSet.put("A", new Element<>("A", now));
-
-    set1.merge(set2);
-
-    assertTrue(set1.lookup("A"));
-  }
-
-  @Test
-  void testRemoveOlderThanAdd() {
-    LWWElementSet<String> set = new LWWElementSet<>();
-    Instant now = Instant.now();
-    set.addSet.put("A", new Element<>("A", now));
-    set.removeSet.put("A", new Element<>("A", now.minusSeconds(10)));
-    assertTrue(set.lookup("A"));
-  }
+    @Test
+    void testAddElement() {
+        LWWElementSet<String> set = new LWWElementSet<>();
+        set.add("A");
+        assertTrue(set.lookup("A"));
+    }
+
+    @Test
+    void testRemoveElement() {
+        LWWElementSet<String> set = new LWWElementSet<>();
+        set.add("A");
+        set.remove("A");
+        assertFalse(set.lookup("A"));
+    }
+
+    @Test
+    void testLookupWithoutAdding() {
+        LWWElementSet<String> set = new LWWElementSet<>();
+        assertFalse(set.lookup("A"));
+    }
+
+    @Test
+    void testLookupLaterTimestampsFalse() {
+        LWWElementSet<String> set = new LWWElementSet<>();
+
+        set.addSet.put("A", new Element<>("A", Instant.now()));
+        set.removeSet.put("A", new Element<>("A", Instant.now().plusSeconds(10)));
+
+        assertFalse(set.lookup("A"));
+    }
+
+    @Test
+    void testLookupEarlierTimestampsTrue() {
+        LWWElementSet<String> set = new LWWElementSet<>();
+
+        set.addSet.put("A", new Element<>("A", Instant.now()));
+        set.removeSet.put("A", new Element<>("A", Instant.now().minusSeconds(10)));
+
+        assertTrue(set.lookup("A"));
+    }
+
+    @Test
+    void testLookupWithConcurrentTimestamps() {
+        LWWElementSet<String> set = new LWWElementSet<>();
+        Instant now = Instant.now();
+        set.addSet.put("A", new Element<>("A", now));
+        set.removeSet.put("A", new Element<>("A", now));
+        assertFalse(set.lookup("A"));
+    }
+
+    @Test
+    void testMergeTwoSets() {
+        LWWElementSet<String> set1 = new LWWElementSet<>();
+        LWWElementSet<String> set2 = new LWWElementSet<>();
+
+        set1.add("A");
+        set2.add("B");
+        set2.remove("A");
+
+        set1.merge(set2);
+
+        assertFalse(set1.lookup("A"));
+        assertTrue(set1.lookup("B"));
+    }
+
+    @Test
+    void testMergeWithConflictingTimestamps() {
+        LWWElementSet<String> set1 = new LWWElementSet<>();
+        LWWElementSet<String> set2 = new LWWElementSet<>();
+
+        Instant now = Instant.now();
+        set1.addSet.put("A", new Element<>("A", now.minusSeconds(10)));
+        set2.addSet.put("A", new Element<>("A", now));
+
+        set1.merge(set2);
+
+        assertTrue(set1.lookup("A"));
+    }
+
+    @Test
+    void testRemoveOlderThanAdd() {
+        LWWElementSet<String> set = new LWWElementSet<>();
+        Instant now = Instant.now();
+        set.addSet.put("A", new Element<>("A", now));
+        set.removeSet.put("A", new Element<>("A", now.minusSeconds(10)));
+        assertTrue(set.lookup("A"));
+    }
 }