Issue #1754 Implement equals/hashCode for EvaluationContext and add tests.

Signed-off-by: vishalup29 <vishalupadhyay977@gmail.com>

Author: vishalup29

src/main/java/dev/openfeature/sdk/ImmutableContext.java

@@ -96,6 +96,38 @@ public EvaluationContext merge(EvaluationContext overridingContext) {
         return new ImmutableContext(attributes);
     }
 
+    /**
+     * Equality for EvaluationContext implementations is defined in terms of their resolved
+     * attribute maps. Two contexts are considered equal if their {@link #asMap()} representations
+     * contain the same key/value pairs, regardless of how the context was constructed or layered.
+     *
+     * @param o the object to compare with this context
+     * @return true if the other object is an EvaluationContext whose resolved attributes match
+     */
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (!(o instanceof EvaluationContext)) {
+            return false;
+        }
+        EvaluationContext that = (EvaluationContext) o;
+        return this.asMap().equals(that.asMap());
+    }
+
+    /**
+     * Computes a hash code consistent with {@link #equals(Object)} by delegating to the
+     * hash code of this context's resolved attribute map. This ensures that contexts with
+     * identical effective attributes will have the same hash code.
+     *
+     * @return the hash code derived from this context's attribute map
+     */
+    @Override
+    public int hashCode() {
+        return asMap().hashCode();
+    }
+
     @SuppressWarnings("all")
     private static class DelegateExclusions {
         @ExcludeFromGeneratedCoverageReport

src/main/java/dev/openfeature/sdk/LayeredEvaluationContext.java

@@ -251,6 +251,24 @@ public Map<String, Object> asObjectMap() {
         return map;
     }
 
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (!(o instanceof EvaluationContext)) {
+            return false;
+        }
+
+        EvaluationContext that = (EvaluationContext) o;
+        return this.asMap().equals(that.asMap());
+    }
+
+    @Override
+    public int hashCode() {
+        return asMap().hashCode();
+    }
+
     void putHookContext(EvaluationContext context) {
         if (context == null || context.isEmpty()) {
             return;

src/test/java/dev/openfeature/sdk/ImmutableContextTest.java

@@ -148,6 +148,22 @@ void mergeShouldObtainKeysFromOverridingContextWhenExistingContextIsEmpty() {
         assertEquals(new java.util.HashSet<>(java.util.Arrays.asList("key1", "key2")), merge.keySet());
     }
 
+    @DisplayName("Two ImmutableContext objects with identical attributes are considered equal")
+    @Test
+    void testImmutableContextEquality() {
+        Map<String, Value> map1 = new HashMap<>();
+        map1.put("key", new Value("value"));
+
+        Map<String, Value> map2 = new HashMap<>();
+        map2.put("key", new Value("value"));
+
+        ImmutableContext a = new ImmutableContext(null, map1);
+        ImmutableContext b = new ImmutableContext(null, map2);
+
+        assertEquals(a, b);
+        assertEquals(a.hashCode(), b.hashCode());
+    }
+
     @DisplayName("Two different MutableContext objects with the different contents are not considered equal")
     @Test
     void unequalImmutableContextsAreNotEqual() {

src/test/java/dev/openfeature/sdk/LayeredEvaluationContextTest.java

@@ -397,5 +397,32 @@ void mergesCorrectlyWhenOtherHasNoTargetingKey() {
                     merged.asMap());
             assertEquals(invocationContext.getTargetingKey(), merged.getTargetingKey());
         }
+
+        @Test
+        void testLayeredContextEquality() {
+            Map<String, Value> baseMap = Map.of("k", new Value("v"));
+            Map<String, Value> layerMap = Map.of("x", new Value("y"));
+
+            EvaluationContext base = new MutableContext(null, baseMap);
+            EvaluationContext layer = new MutableContext(null, layerMap);
+
+            LayeredEvaluationContext l1 = new LayeredEvaluationContext(base, layer, null, null);
+            LayeredEvaluationContext l2 = new LayeredEvaluationContext(base, layer, null, null);
+
+            assertEquals(l1, l2);
+            assertEquals(l1.hashCode(), l2.hashCode());
+        }
+
+        @Test
+        void testMixedContextEquality() {
+            Map<String, Value> map = Map.of("foo", new Value("bar"));
+
+            EvaluationContext base = new MutableContext(null, map);
+            LayeredEvaluationContext layered = new LayeredEvaluationContext(null, null, null, base);
+
+            assertEquals(base, layered);
+            assertEquals(layered, base);
+            assertEquals(base.hashCode(), layered.hashCode());
+        }
     }
 }