Datasets:

CrossSWE
/

CrossSWE-Bench

diff --git a/src/test/java/dev/openfeature/sdk/DomainAwareTestProvider.java b/src/test/java/dev/openfeature/sdk/DomainAwareTestProvider.java
new file mode 100644
index 0000000..57ba93e
--- /dev/null
+++ b/src/test/java/dev/openfeature/sdk/DomainAwareTestProvider.java
@@ -0,0 +1,13 @@
+package dev.openfeature.sdk;
+
+/** Lets Mockito observe the domain-aware call even when the base API lacks it. */
+public interface DomainAwareTestProvider extends FeatureProvider {
+    /** Keep old-base lifecycle stubbing working while exposing the new call shape. */
+    default void initialize(EvaluationContext context, String domain) throws Exception {
+        initialize(context);
+    }
+
+    default boolean isDomainScoped() {
+        return false;
+    }
+}
diff --git a/src/test/java/dev/openfeature/sdk/DomainInitializeTestSupport.java b/src/test/java/dev/openfeature/sdk/DomainInitializeTestSupport.java
new file mode 100644
index 0000000..088573a
--- /dev/null
+++ b/src/test/java/dev/openfeature/sdk/DomainInitializeTestSupport.java
@@ -0,0 +1,46 @@
+package dev.openfeature.sdk;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+/** Test adapter for exercising the same assertions against both public APIs. */
+public final class DomainInitializeTestSupport {
+    private DomainInitializeTestSupport() {}
+
+    public static void initialize(Object provider, EvaluationContext context, String domain) throws Exception {
+        Method method;
+        Object[] arguments;
+        try {
+            method = provider.getClass().getMethod("initialize", EvaluationContext.class, String.class);
+            arguments = new Object[] {context, domain};
+        } catch (NoSuchMethodException legacyApi) {
+            method = provider.getClass().getMethod("initialize", EvaluationContext.class);
+            arguments = new Object[] {context};
+        }
+        method.setAccessible(true);
+        try {
+            method.invoke(provider, arguments);
+        } catch (InvocationTargetException invocation) {
+            Throwable cause = invocation.getCause();
+            if (cause instanceof Exception) {
+                throw (Exception) cause;
+            }
+            if (cause instanceof Error) {
+                throw (Error) cause;
+            }
+            throw new AssertionError(cause);
+        }
+    }
+
+    public static boolean isDomainScoped(Object provider) {
+        try {
+            Method method = provider.getClass().getMethod("isDomainScoped");
+            method.setAccessible(true);
+            return (Boolean) method.invoke(provider);
+        } catch (NoSuchMethodException legacyApi) {
+            return false;
+        } catch (ReflectiveOperationException failure) {
+            throw new AssertionError(failure);
+        }
+    }
+}
diff --git a/src/test/java/dev/openfeature/sdk/DomainScopedProviderSpecTest.java b/src/test/java/dev/openfeature/sdk/DomainScopedProviderSpecTest.java
new file mode 100644
index 0000000..27c5866
--- /dev/null
+++ b/src/test/java/dev/openfeature/sdk/DomainScopedProviderSpecTest.java
@@ -0,0 +1,259 @@
+package dev.openfeature.sdk;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatCode;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.awaitility.Awaitility.await;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.timeout;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
+import java.time.Duration;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+class DomainScopedProviderSpecTest {
+
+    private static final String DOMAIN_A = "domain-a";
+    private static final String DOMAIN_B = "domain-b";
+    private OpenFeatureAPI api;
+
+    @BeforeEach
+    void setupTest() {
+        api = new OpenFeatureAPI();
+        api.setProvider(new NoOpProvider());
+    }
+
+    @AfterEach
+    void tearDown() {
+        api.shutdown();
+    }
+
+    @Specification(
+            number = "1.1.8.1",
+            text = "The `provider mutator` MUST NOT bind a `domain-scoped` provider instance to more than one "
+                    + "`domain`, rejecting any attempt to bind an already-bound instance to an additional `domain`.")
+    @Test
+    @DisplayName("rejects binding a domain-scoped provider to a second named domain")
+    void rejectsBindingDomainScopedProviderToSecondNamedDomain() throws Exception {
+        DomainScopedTestProvider provider = new DomainScopedTestProvider();
+
+        api.setProviderAndWait(DOMAIN_A, provider);
+
+        assertThatThrownBy(() -> api.setProvider(DOMAIN_B, provider))
+                .isInstanceOf(RuntimeException.class);
+        assertThat(api.getProvider(DOMAIN_A)).isSameAs(provider);
+        assertThat(api.getProvider(DOMAIN_B)).isNotSameAs(provider);
+        assertThat(provider.initCount()).isOne();
+    }
+
+    @Specification(
+            number = "1.1.8.1",
+            text = "The `provider mutator` MUST NOT bind a `domain-scoped` provider instance to more than one "
+                    + "`domain`, rejecting any attempt to bind an already-bound instance to an additional `domain`.")
+    @Test
+    @DisplayName("rejects binding a domain-scoped named provider as the default provider")
+    void rejectsBindingDomainScopedNamedProviderAsDefault() throws Exception {
+        DomainScopedTestProvider provider = new DomainScopedTestProvider();
+
+        api.setProviderAndWait(DOMAIN_A, provider);
+
+        assertThatThrownBy(() -> api.setProvider(provider))
+                .isInstanceOf(RuntimeException.class);
+        assertThat(api.getProvider(DOMAIN_A)).isSameAs(provider);
+        assertThat(api.getProvider()).isNotSameAs(provider);
+        assertThat(provider.initCount()).isOne();
+    }
+
+    @Specification(
+            number = "1.1.8.1",
+            text = "The `provider mutator` MUST NOT bind a `domain-scoped` provider instance to more than one "
+                    + "`domain`, rejecting any attempt to bind an already-bound instance to an additional `domain`.")
+    @Test
+    @DisplayName("rejects binding a domain-scoped default provider to a named domain")
+    void rejectsBindingDomainScopedDefaultProviderToNamedDomain() throws Exception {
+        DomainScopedTestProvider provider = new DomainScopedTestProvider();
+
+        api.setProviderAndWait(provider);
+
+        assertThatThrownBy(() -> api.setProvider(DOMAIN_A, provider))
+                .isInstanceOf(RuntimeException.class);
+        assertThat(api.getProvider()).isSameAs(provider);
+        assertThat(api.getProvider(DOMAIN_A)).isSameAs(provider);
+        NoOpProvider replacement = new NoOpProvider();
+        api.setProviderAndWait(replacement);
+        assertThat(api.getProvider(DOMAIN_A)).isSameAs(replacement);
+        assertThat(provider.initCount()).isOne();
+    }
+
+    @Test
+    @DisplayName("allows rebinding a domain-scoped provider to the same named domain")
+    void allowsRebindingDomainScopedProviderToSameNamedDomain() throws Exception {
+        DomainScopedTestProvider provider = new DomainScopedTestProvider();
+        FeatureProvider replacement = mock(dev.openfeature.sdk.DomainAwareTestProvider.class, org.mockito.Answers.CALLS_REAL_METHODS);
+        doReturn(ProviderState.NOT_READY).when(replacement).getState();
+        ((dev.openfeature.sdk.DomainAwareTestProvider) doReturn(true).when(replacement)).isDomainScoped();
+
+        api.setProvider(DOMAIN_A, provider);
+
+        assertThatCode(() -> api.setProvider(DOMAIN_A, replacement)).doesNotThrowAnyException();
+        ((dev.openfeature.sdk.DomainAwareTestProvider) verify(replacement, timeout(1000))).initialize(any(), eq(DOMAIN_A));
+    }
+
+    @Test
+    @DisplayName("allows rebinding the same domain-scoped provider instance to the same named domain")
+    void allowsRebindingSameDomainScopedInstanceToSameNamedDomain() throws Exception {
+        DomainScopedTestProvider provider = new DomainScopedTestProvider();
+
+        api.setProviderAndWait(DOMAIN_A, provider);
+        api.setProviderAndWait(DOMAIN_A, provider);
+
+        assertThat(provider.initCount()).isOne();
+        assertThat(provider.initDomain.get()).isEqualTo(DOMAIN_A);
+    }
+
+    @Test
+    @DisplayName("allows rebinding the same domain-scoped provider instance as the default provider")
+    void allowsRebindingSameDomainScopedInstanceAsDefault() throws Exception {
+        DomainScopedTestProvider provider = new DomainScopedTestProvider();
+
+        api.setProviderAndWait(provider);
+        api.setProviderAndWait(provider);
+
+        assertThat(provider.initCount()).isOne();
+        assertThat(provider.initDomain.get()).isNull();
+    }
+
+    @Test
+    @DisplayName("allows equal-but-distinct domain-scoped instances on separate domains")
+    void allowsEqualDistinctDomainScopedInstancesOnSeparateDomains() throws Exception {
+        EqualDomainScopedProvider providerA = new EqualDomainScopedProvider("shared-key");
+        EqualDomainScopedProvider providerB = new EqualDomainScopedProvider("shared-key");
+
+        assertThat(providerA).isEqualTo(providerB);
+        assertThat(providerA).isNotSameAs(providerB);
+
+        api.setProviderAndWait(DOMAIN_A, providerA);
+
+        assertThatCode(() -> api.setProviderAndWait(DOMAIN_B, providerB)).doesNotThrowAnyException();
+        assertThat(api.getProvider(DOMAIN_A)).isSameAs(providerA);
+        assertThat(api.getProvider(DOMAIN_B)).isSameAs(providerB);
+    }
+
+    @Test
+    @DisplayName("allows binding a non-domain-scoped provider to multiple domains")
+    void allowsBindingNonDomainScopedProviderToMultipleDomains() throws Exception {
+        FeatureProvider provider = mock(dev.openfeature.sdk.DomainAwareTestProvider.class, org.mockito.Answers.CALLS_REAL_METHODS);
+        doReturn(ProviderState.NOT_READY).when(provider).getState();
+        Metadata metadata = mock(Metadata.class);
+        doReturn("shared-provider").when(metadata).getName();
+        doReturn(metadata).when(provider).getMetadata();
+
+        api.setProviderAndWait(DOMAIN_A, provider);
+        api.setProviderAndWait(DOMAIN_B, provider);
+
+        assertThat(api.getProvider(DOMAIN_A)).isSameAs(provider);
+        assertThat(api.getProvider(DOMAIN_B)).isSameAs(provider);
+        ((dev.openfeature.sdk.DomainAwareTestProvider) verify(provider, times(1))).initialize(any(), eq(DOMAIN_A));
+    }
+
+    @Specification(
+            number = "2.4.3",
+            text =
+                    "The `provider` MAY declare that it is `domain-scoped`, indicating that it maintains state "
+                            + "specific to a single `domain`, such as a persistent cache, that cannot be shared across `domains`.")
+    @Test
+    @DisplayName("domain-scoped provider receives bound domain at initialization")
+    void domainScopedProviderReceivesBoundDomainAtInitialization() {
+        DomainScopedTestProvider provider = new DomainScopedTestProvider();
+
+        api.setProvider(DOMAIN_A, provider);
+
+        await().atMost(Duration.ofSeconds(5))
+                .untilAsserted(() -> assertThat(provider.initDomain.get()).isEqualTo(DOMAIN_A));
+    }
+
+    private static class DomainScopedTestProvider extends EventProvider {
+
+        private final AtomicReference<String> initDomain = new AtomicReference<>();
+        private final AtomicInteger initializeCount = new AtomicInteger();
+
+        @Override
+        public Metadata getMetadata() {
+            return () -> "domain-scoped-test";
+        }
+
+        
+        public boolean isDomainScoped() {
+            return true;
+        }
+
+        
+        public void initialize(EvaluationContext evaluationContext, String domain) {
+            initializeCount.incrementAndGet();
+            initDomain.set(domain);
+        }
+
+        @Override
+        public ProviderEvaluation<Boolean> getBooleanEvaluation(
+                String key, Boolean defaultValue, EvaluationContext ctx) {
+            return ProviderEvaluation.<Boolean>builder().value(defaultValue).build();
+        }
+
+        @Override
+        public ProviderEvaluation<String> getStringEvaluation(String key, String defaultValue, EvaluationContext ctx) {
+            return ProviderEvaluation.<String>builder().value(defaultValue).build();
+        }
+
+        @Override
+        public ProviderEvaluation<Integer> getIntegerEvaluation(
+                String key, Integer defaultValue, EvaluationContext ctx) {
+            return ProviderEvaluation.<Integer>builder().value(defaultValue).build();
+        }
+
+        @Override
+        public ProviderEvaluation<Double> getDoubleEvaluation(String key, Double defaultValue, EvaluationContext ctx) {
+            return ProviderEvaluation.<Double>builder().value(defaultValue).build();
+        }
+
+        @Override
+        public ProviderEvaluation<Value> getObjectEvaluation(String key, Value defaultValue, EvaluationContext ctx) {
+            return ProviderEvaluation.<Value>builder().value(defaultValue).build();
+        }
+
+        int initCount() {
+            return initializeCount.get();
+        }
+    }
+
+    private static final class EqualDomainScopedProvider extends DomainScopedTestProvider {
+
+        private final String key;
+
+        EqualDomainScopedProvider(String key) {
+            this.key = key;
+        }
+
+        @Override
+        public boolean equals(Object obj) {
+            if (!(obj instanceof EqualDomainScopedProvider)) {
+                return false;
+            }
+            EqualDomainScopedProvider other = (EqualDomainScopedProvider) obj;
+            return key.equals(other.key);
+        }
+
+        @Override
+        public int hashCode() {
+            return key.hashCode();
+        }
+    }
+}
diff --git a/src/test/java/dev/openfeature/sdk/InitializeBehaviorSpecTest.java b/src/test/java/dev/openfeature/sdk/InitializeBehaviorSpecTest.java
index 4bcd731..fe9dba0 100644
--- a/src/test/java/dev/openfeature/sdk/InitializeBehaviorSpecTest.java
+++ b/src/test/java/dev/openfeature/sdk/InitializeBehaviorSpecTest.java
@@ -1,7 +1,9 @@
 package dev.openfeature.sdk;
 
 import static org.assertj.core.api.Assertions.assertThatCode;
-import static org.mockito.Mockito.any;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.isNull;
 import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.doThrow;
 import static org.mockito.Mockito.mock;
@@ -36,12 +38,27 @@ class InitializeBehaviorSpecTest {
         @DisplayName("must call initialize function of the newly registered provider before using it for "
                 + "flag evaluation")
         void mustCallInitializeFunctionOfTheNewlyRegisteredProviderBeforeUsingItForFlagEvaluation() throws Exception {
-            FeatureProvider featureProvider = mock(FeatureProvider.class);
+            FeatureProvider featureProvider = mock(dev.openfeature.sdk.DomainAwareTestProvider.class, org.mockito.Answers.CALLS_REAL_METHODS);
             doReturn(ProviderState.NOT_READY).when(featureProvider).getState();
 
             api.setProvider(featureProvider);
 
-            verify(featureProvider, timeout(1000)).initialize(any());
+            ((dev.openfeature.sdk.DomainAwareTestProvider) verify(featureProvider, timeout(1000))).initialize(any(), isNull());
+        }
+
+        @Specification(
+                number = "2.4.1",
+                text = "The `provider` MAY define an initialization function which accepts the global "
+                        + "`evaluation context` and an optional bound `domain`.")
+        @Test
+        @DisplayName("must pass null domain when initializing the default provider")
+        void mustPassNullDomainWhenInitializingTheDefaultProvider() throws Exception {
+            FeatureProvider featureProvider = mock(dev.openfeature.sdk.DomainAwareTestProvider.class, org.mockito.Answers.CALLS_REAL_METHODS);
+            doReturn(ProviderState.NOT_READY).when(featureProvider).getState();
+
+            api.setProvider(featureProvider);
+
+            ((dev.openfeature.sdk.DomainAwareTestProvider) verify(featureProvider, timeout(1000))).initialize(any(), isNull());
         }
 
         @Specification(
@@ -53,13 +70,13 @@ class InitializeBehaviorSpecTest {
         @Test
         @DisplayName("should catch exception thrown by the provider on initialization")
         void shouldCatchExceptionThrownByTheProviderOnInitialization() throws Exception {
-            FeatureProvider featureProvider = mock(FeatureProvider.class);
+            FeatureProvider featureProvider = mock(dev.openfeature.sdk.DomainAwareTestProvider.class, org.mockito.Answers.CALLS_REAL_METHODS);
             doReturn(ProviderState.NOT_READY).when(featureProvider).getState();
-            doThrow(TestException.class).when(featureProvider).initialize(any());
+            ((dev.openfeature.sdk.DomainAwareTestProvider) doThrow(TestException.class).when(featureProvider)).initialize(any(), isNull());
 
             assertThatCode(() -> api.setProvider(featureProvider)).doesNotThrowAnyException();
 
-            verify(featureProvider, timeout(1000)).initialize(any());
+            ((dev.openfeature.sdk.DomainAwareTestProvider) verify(featureProvider, timeout(1000))).initialize(any(), isNull());
         }
     }
 
@@ -75,12 +92,27 @@ class InitializeBehaviorSpecTest {
                 + "for flag evaluation")
         void mustCallInitializeFunctionOfTheNewlyRegisteredNamedProviderBeforeUsingItForFlagEvaluation()
                 throws Exception {
-            FeatureProvider featureProvider = mock(FeatureProvider.class);
+            FeatureProvider featureProvider = mock(dev.openfeature.sdk.DomainAwareTestProvider.class, org.mockito.Answers.CALLS_REAL_METHODS);
+            doReturn(ProviderState.NOT_READY).when(featureProvider).getState();
+
+            api.setProvider(DOMAIN_NAME, featureProvider);
+
+            ((dev.openfeature.sdk.DomainAwareTestProvider) verify(featureProvider, timeout(1000))).initialize(any(), eq(DOMAIN_NAME));
+        }
+
+        @Specification(
+                number = "2.4.1",
+                text = "The `provider` MAY define an initialization function which accepts the global "
+                        + "`evaluation context` and an optional bound `domain`.")
+        @Test
+        @DisplayName("must pass bound domain when initializing a named provider")
+        void mustPassBoundDomainWhenInitializingANamedProvider() throws Exception {
+            FeatureProvider featureProvider = mock(dev.openfeature.sdk.DomainAwareTestProvider.class, org.mockito.Answers.CALLS_REAL_METHODS);
             doReturn(ProviderState.NOT_READY).when(featureProvider).getState();
 
             api.setProvider(DOMAIN_NAME, featureProvider);
 
-            verify(featureProvider, timeout(1000)).initialize(any());
+            ((dev.openfeature.sdk.DomainAwareTestProvider) verify(featureProvider, timeout(1000))).initialize(any(), eq(DOMAIN_NAME));
         }
 
         @Specification(
@@ -92,13 +124,13 @@ class InitializeBehaviorSpecTest {
         @Test
         @DisplayName("should catch exception thrown by the named client provider on initialization")
         void shouldCatchExceptionThrownByTheNamedClientProviderOnInitialization() throws Exception {
-            FeatureProvider featureProvider = mock(FeatureProvider.class);
+            FeatureProvider featureProvider = mock(dev.openfeature.sdk.DomainAwareTestProvider.class, org.mockito.Answers.CALLS_REAL_METHODS);
             doReturn(ProviderState.NOT_READY).when(featureProvider).getState();
-            doThrow(TestException.class).when(featureProvider).initialize(any());
+            ((dev.openfeature.sdk.DomainAwareTestProvider) doThrow(TestException.class).when(featureProvider)).initialize(any(), eq(DOMAIN_NAME));
 
             assertThatCode(() -> api.setProvider(DOMAIN_NAME, featureProvider)).doesNotThrowAnyException();
 
-            verify(featureProvider, timeout(1000)).initialize(any());
+            ((dev.openfeature.sdk.DomainAwareTestProvider) verify(featureProvider, timeout(1000))).initialize(any(), eq(DOMAIN_NAME));
         }
     }
 }
diff --git a/src/test/java/dev/openfeature/sdk/OpenFeatureAPITest.java b/src/test/java/dev/openfeature/sdk/OpenFeatureAPITest.java
index b1f5b6e..ba55b47 100644
--- a/src/test/java/dev/openfeature/sdk/OpenFeatureAPITest.java
+++ b/src/test/java/dev/openfeature/sdk/OpenFeatureAPITest.java
@@ -6,6 +6,7 @@ import static org.assertj.core.api.Assertions.assertThatCode;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.isNull;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.spy;
 import static org.mockito.Mockito.times;
@@ -112,12 +113,12 @@ class OpenFeatureAPITest {
 
     @Test
     void featureProviderTrackIsCalled() throws Exception {
-        FeatureProvider featureProvider = mock(FeatureProvider.class);
+        FeatureProvider featureProvider = mock(dev.openfeature.sdk.DomainAwareTestProvider.class, org.mockito.Answers.CALLS_REAL_METHODS);
         api.setProviderAndWait(featureProvider);
 
         api.getClient().track("track-event", new ImmutableContext(), new MutableTrackingEventDetails(22.2f));
 
-        verify(featureProvider).initialize(any());
+        ((dev.openfeature.sdk.DomainAwareTestProvider) verify(featureProvider)).initialize(any());
         verify(featureProvider, times(2)).getMetadata();
         verify(featureProvider).track(any(), any(), any());
     }
diff --git a/src/test/java/dev/openfeature/sdk/ProviderInitializeBackwardCompatibilityTest.java b/src/test/java/dev/openfeature/sdk/ProviderInitializeBackwardCompatibilityTest.java
new file mode 100644
--- /dev/null
+++ b/src/test/java/dev/openfeature/sdk/ProviderInitializeBackwardCompatibilityTest.java
@@ -0,0 +1,213 @@
+package dev.openfeature.sdk;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.awaitility.Awaitility.await;
+
+import java.time.Duration;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+class ProviderInitializeBackwardCompatibilityTest {
+
+    private static final String DOMAIN = "billing";
+
+    @Nested
+    @DisplayName("FeatureProvider default method delegation")
+    class DefaultMethodDelegation {
+
+        @Test
+        @DisplayName("default isDomainScoped returns false for non-domain-scoped providers")
+        void defaultIsDomainScopedReturnsFalse() {
+            assertThat(dev.openfeature.sdk.DomainInitializeTestSupport.isDomainScoped(new LegacySingleArgInitProvider())).isFalse();
+        }
+
+        @Test
+        @DisplayName("two-arg default delegates to a single-arg override")
+        void twoArgDefaultDelegatesToSingleArgOverride() throws Exception {
+            LegacySingleArgInitProvider provider = new LegacySingleArgInitProvider();
+
+            dev.openfeature.sdk.DomainInitializeTestSupport.initialize(provider, new ImmutableContext(), DOMAIN);
+
+            assertThat(provider.singleArgInitCount()).isOne();
+        }
+
+        @Test
+        @DisplayName("two-arg override is used without invoking single-arg")
+        void twoArgOverrideDoesNotInvokeSingleArg() throws Exception {
+            TwoArgInitProvider provider = new TwoArgInitProvider();
+
+            dev.openfeature.sdk.DomainInitializeTestSupport.initialize(provider, new ImmutableContext(), DOMAIN);
+
+            assertThat(provider.initDomain()).isEqualTo(DOMAIN);
+            assertThat(provider.singleArgInitCount()).isZero();
+        }
+
+        @Test
+        @DisplayName("two-arg-only override receives null domain for default binding")
+        void twoArgOnlyOverrideReceivesNullDomain() throws Exception {
+            TwoArgInitProvider provider = new TwoArgInitProvider();
+
+            dev.openfeature.sdk.DomainInitializeTestSupport.initialize(provider, new ImmutableContext(), null);
+
+            assertThat(provider.initDomain()).isNull();
+            assertThat(provider.singleArgInitCount()).isZero();
+        }
+
+        @Test
+        @DisplayName("single-arg override is only invoked once per initialization")
+        void singleArgOverrideIsOnlyInvokedOnce() throws Exception {
+            LegacySingleArgInitProvider provider = new LegacySingleArgInitProvider();
+
+            dev.openfeature.sdk.DomainInitializeTestSupport.initialize(provider, new ImmutableContext(), DOMAIN);
+            dev.openfeature.sdk.DomainInitializeTestSupport.initialize(provider, new ImmutableContext(), DOMAIN);
+
+            assertThat(provider.singleArgInitCount()).isEqualTo(2);
+        }
+    }
+
+    @Nested
+    @DisplayName("SDK initialization path")
+    class SdkIntegration {
+
+        private OpenFeatureAPI api;
+
+        @BeforeEach
+        void setupTest() {
+            api = new OpenFeatureAPI();
+            api.setProvider(new NoOpProvider());
+        }
+
+        @Test
+        @DisplayName("legacy single-arg provider is initialized when registered to a named domain")
+        void legacySingleArgProviderInitializedForNamedDomain() {
+            LegacySingleArgInitProvider provider = new LegacySingleArgInitProvider();
+
+            api.setProvider(DOMAIN, provider);
+
+            await().atMost(Duration.ofSeconds(5)).untilAsserted(() -> assertThat(provider.singleArgInitCount())
+                    .isOne());
+        }
+
+        @Test
+        @DisplayName("legacy single-arg provider is initialized when registered as the default provider")
+        void legacySingleArgProviderInitializedAsDefault() {
+            LegacySingleArgInitProvider provider = new LegacySingleArgInitProvider();
+
+            api.setProvider(provider);
+
+            await().atMost(Duration.ofSeconds(5)).untilAsserted(() -> assertThat(provider.singleArgInitCount())
+                    .isOne());
+        }
+
+        @Test
+        @DisplayName("two-arg-only provider receives the bound domain from the SDK")
+        void twoArgOnlyProviderReceivesBoundDomainFromSdk() {
+            TwoArgInitProvider provider = new TwoArgInitProvider();
+
+            api.setProvider(DOMAIN, provider);
+
+            await().atMost(Duration.ofSeconds(5)).untilAsserted(() -> {
+                assertThat(provider.initDomain()).isEqualTo(DOMAIN);
+                assertThat(provider.singleArgInitCount()).isZero();
+            });
+        }
+
+        @Test
+        @DisplayName("two-arg-only default provider receives null domain from the SDK")
+        void twoArgOnlyDefaultProviderReceivesNullDomainFromSdk() {
+            TwoArgInitProvider provider = new TwoArgInitProvider();
+
+            api.setProvider(provider);
+
+            await().atMost(Duration.ofSeconds(5)).untilAsserted(() -> {
+                assertThat(provider.initDomain()).isNull();
+                assertThat(provider.singleArgInitCount()).isZero();
+            });
+        }
+    }
+
+    /**
+     * Legacy provider that only overrides single-arg {@link FeatureProvider#initialize(EvaluationContext)}.
+     */
+    private static final class LegacySingleArgInitProvider extends StubProvider {
+
+        private final AtomicInteger singleArgInitCount = new AtomicInteger();
+
+        @Override
+        public void initialize(EvaluationContext evaluationContext) {
+            singleArgInitCount.incrementAndGet();
+        }
+
+        int singleArgInitCount() {
+            return singleArgInitCount.get();
+        }
+    }
+
+    /**
+     * Domain-aware provider that only overrides two-arg
+     * {@link FeatureProvider#initialize(EvaluationContext, String)}. Single-arg is overridden solely to detect
+     * accidental delegation.
+     */
+    private static final class TwoArgInitProvider extends StubProvider {
+
+        private final AtomicInteger singleArgInitCount = new AtomicInteger();
+        private final AtomicReference<String> initDomain = new AtomicReference<>();
+
+        
+        public void initialize(EvaluationContext evaluationContext, String domain) {
+            initDomain.set(domain);
+        }
+
+        @Override
+        public void initialize(EvaluationContext evaluationContext) {
+            singleArgInitCount.incrementAndGet();
+        }
+
+        int singleArgInitCount() {
+            return singleArgInitCount.get();
+        }
+
+        String initDomain() {
+            return initDomain.get();
+        }
+    }
+
+    private abstract static class StubProvider extends EventProvider {
+
+        @Override
+        public Metadata getMetadata() {
+            return () -> "initialize-backward-compat-test";
+        }
+
+        @Override
+        public ProviderEvaluation<Boolean> getBooleanEvaluation(
+                String key, Boolean defaultValue, EvaluationContext ctx) {
+            return ProviderEvaluation.<Boolean>builder().value(defaultValue).build();
+        }
+
+        @Override
+        public ProviderEvaluation<String> getStringEvaluation(String key, String defaultValue, EvaluationContext ctx) {
+            return ProviderEvaluation.<String>builder().value(defaultValue).build();
+        }
+
+        @Override
+        public ProviderEvaluation<Integer> getIntegerEvaluation(
+                String key, Integer defaultValue, EvaluationContext ctx) {
+            return ProviderEvaluation.<Integer>builder().value(defaultValue).build();
+        }
+
+        @Override
+        public ProviderEvaluation<Double> getDoubleEvaluation(String key, Double defaultValue, EvaluationContext ctx) {
+            return ProviderEvaluation.<Double>builder().value(defaultValue).build();
+        }
+
+        @Override
+        public ProviderEvaluation<Value> getObjectEvaluation(String key, Value defaultValue, EvaluationContext ctx) {
+            return ProviderEvaluation.<Value>builder().value(defaultValue).build();
+        }
+    }
+}
diff --git a/src/test/java/dev/openfeature/sdk/ProviderRepositoryTest.java b/src/test/java/dev/openfeature/sdk/ProviderRepositoryTest.java
index c9d69ad..c775908 100644
--- a/src/test/java/dev/openfeature/sdk/ProviderRepositoryTest.java
+++ b/src/test/java/dev/openfeature/sdk/ProviderRepositoryTest.java
@@ -8,6 +8,7 @@ import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.awaitility.Awaitility.await;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.isNull;
 import static org.mockito.Mockito.*;
 
 import dev.openfeature.sdk.exceptions.OpenFeatureError;
@@ -64,7 +65,7 @@ class ProviderRepositoryTest {
             @DisplayName("should immediately return when calling the provider mutator")
             void shouldImmediatelyReturnWhenCallingTheProviderMutator() throws Exception {
                 FeatureProvider featureProvider = createMockedProvider();
-                doDelayResponse(Duration.ofSeconds(10)).when(featureProvider).initialize(new ImmutableContext());
+                ((dev.openfeature.sdk.DomainAwareTestProvider) doDelayResponse(Duration.ofSeconds(10)).when(featureProvider)).initialize(any());
 
                 await().alias("wait for provider mutator to return")
                         .pollDelay(Duration.ofMillis(1))
@@ -77,11 +78,11 @@ class ProviderRepositoryTest {
                                     mockAfterShutdown(),
                                     mockAfterError(),
                                     false);
-                            verify(featureProvider, timeout(TIMEOUT)).initialize(any());
+                            ((dev.openfeature.sdk.DomainAwareTestProvider) verify(featureProvider, timeout(TIMEOUT))).initialize(any());
                             return true;
                         });
 
-                verify(featureProvider, timeout(TIMEOUT)).initialize(any());
+                ((dev.openfeature.sdk.DomainAwareTestProvider) verify(featureProvider, timeout(TIMEOUT))).initialize(any());
             }
         }
 
@@ -121,7 +122,7 @@ class ProviderRepositoryTest {
             @DisplayName("should immediately return when calling the domain provider mutator")
             void shouldImmediatelyReturnWhenCallingTheDomainProviderMutator() throws Exception {
                 FeatureProvider featureProvider = createMockedProvider();
-                doDelayResponse(Duration.ofSeconds(10)).when(featureProvider).initialize(any());
+                ((dev.openfeature.sdk.DomainAwareTestProvider) doDelayResponse(Duration.ofSeconds(10)).when(featureProvider)).initialize(any());
 
                 await().alias("wait for provider mutator to return")
                         .pollDelay(Duration.ofMillis(1))
@@ -135,7 +136,7 @@ class ProviderRepositoryTest {
                                     mockAfterShutdown(),
                                     mockAfterError(),
                                     false);
-                            verify(featureProvider, timeout(TIMEOUT)).initialize(any());
+                            ((dev.openfeature.sdk.DomainAwareTestProvider) verify(featureProvider, timeout(TIMEOUT))).initialize(any());
                             return true;
                         });
             }
@@ -152,7 +153,7 @@ class ProviderRepositoryTest {
             @DisplayName("should immediately return when calling the provider mutator")
             void shouldImmediatelyReturnWhenCallingTheProviderMutator() throws Exception {
                 FeatureProvider newProvider = createMockedProvider();
-                doDelayResponse(Duration.ofSeconds(10)).when(newProvider).initialize(any());
+                ((dev.openfeature.sdk.DomainAwareTestProvider) doDelayResponse(Duration.ofSeconds(10)).when(newProvider)).initialize(any());
 
                 await().alias("wait for provider mutator to return")
                         .pollDelay(Duration.ofMillis(1))
@@ -165,11 +166,11 @@ class ProviderRepositoryTest {
                                     mockAfterShutdown(),
                                     mockAfterError(),
                                     false);
-                            verify(newProvider, timeout(TIMEOUT)).initialize(any());
+                            ((dev.openfeature.sdk.DomainAwareTestProvider) verify(newProvider, timeout(TIMEOUT))).initialize(any());
                             return true;
                         });
 
-                verify(newProvider, timeout(TIMEOUT)).initialize(any());
+                ((dev.openfeature.sdk.DomainAwareTestProvider) verify(newProvider, timeout(TIMEOUT))).initialize(any());
             }
 
             @Test
@@ -193,7 +194,7 @@ class ProviderRepositoryTest {
             @DisplayName("should immediately return when calling the provider mutator")
             void shouldImmediatelyReturnWhenCallingTheProviderMutator() throws Exception {
                 FeatureProvider newProvider = createMockedProvider();
-                doDelayResponse(Duration.ofSeconds(10)).when(newProvider).initialize(any());
+                ((dev.openfeature.sdk.DomainAwareTestProvider) doDelayResponse(Duration.ofSeconds(10)).when(newProvider)).initialize(any());
 
                 Future<?> providerMutation = executorService.submit(() -> providerRepository.setProvider(
                         DOMAIN_NAME,
@@ -357,7 +358,7 @@ class ProviderRepositoryTest {
                 FeatureProvider slowInitProvider = createMockedProvider();
                 AtomicBoolean shutdownCalled = new AtomicBoolean(false);
 
-                doDelayResponse(Duration.ofMillis(500)).when(slowInitProvider).initialize(any());
+                ((dev.openfeature.sdk.DomainAwareTestProvider) doDelayResponse(Duration.ofMillis(500)).when(slowInitProvider)).initialize(any());
 
                 doAnswer(invocation -> {
                             shutdownCalled.set(true);
@@ -448,15 +449,14 @@ class ProviderRepositoryTest {
                 AtomicBoolean proceedWithInit = new AtomicBoolean(false);
 
                 // Make oldProvider's initialization block until we signal
-                doAnswer(invocation -> {
+                ((dev.openfeature.sdk.DomainAwareTestProvider) doAnswer(invocation -> {
                             initializationStarted.set(true);
                             while (!proceedWithInit.get()) {
                                 Thread.sleep(10);
                             }
                             return null;
                         })
-                        .when(oldProvider)
-                        .initialize(any());
+                        .when(oldProvider)).initialize(any());
 
                 // Start async initialization (will block)
                 providerRepository.setProvider(
diff --git a/src/test/java/dev/openfeature/sdk/e2e/steps/ProviderSteps.java b/src/test/java/dev/openfeature/sdk/e2e/steps/ProviderSteps.java
index f22a081..4f20c2b 100644
--- a/src/test/java/dev/openfeature/sdk/e2e/steps/ProviderSteps.java
+++ b/src/test/java/dev/openfeature/sdk/e2e/steps/ProviderSteps.java
@@ -4,6 +4,7 @@ import static dev.openfeature.sdk.testutils.TestFlagsUtils.buildFlags;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.doThrow;
 import static org.mockito.Mockito.spy;
@@ -90,14 +91,13 @@ public class ProviderSteps {
 
         switch (providerState) {
             case NOT_READY:
-                doAnswer(invocationOnMock -> {
+                ((dev.openfeature.sdk.DomainAwareTestProvider) doAnswer(invocationOnMock -> {
                             while (true) {}
                         })
-                        .when(mockProvider)
-                        .initialize(any());
+                        .when(mockProvider)).initialize(any(), eq(providerState.name()));
                 break;
             case FATAL:
-                doThrow(new FatalError(errorMessage)).when(mockProvider).initialize(any());
+                ((dev.openfeature.sdk.DomainAwareTestProvider) doThrow(new FatalError(errorMessage)).when(mockProvider)).initialize(any(), eq(providerState.name()));
                 break;
         }
         // Configure all evaluation methods with a single helper
diff --git a/src/test/java/dev/openfeature/sdk/fixtures/ProviderFixture.java b/src/test/java/dev/openfeature/sdk/fixtures/ProviderFixture.java
index b9c6bc1..494a6dd 100644
--- a/src/test/java/dev/openfeature/sdk/fixtures/ProviderFixture.java
+++ b/src/test/java/dev/openfeature/sdk/fixtures/ProviderFixture.java
@@ -1,65 +1,35 @@
 package dev.openfeature.sdk.fixtures;
 
-import static dev.openfeature.sdk.testutils.stubbing.ConditionStubber.doBlock;
 import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Mockito.doAnswer;
+import static org.mockito.ArgumentMatchers.nullable;
 import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.doThrow;
 import static org.mockito.Mockito.mock;
 
 import dev.openfeature.sdk.FeatureProvider;
-import dev.openfeature.sdk.ImmutableContext;
 import dev.openfeature.sdk.ProviderState;
 import java.io.FileNotFoundException;
-import java.util.concurrent.CountDownLatch;
 import lombok.experimental.UtilityClass;
-import org.mockito.stubbing.Answer;
 
 @UtilityClass
 public class ProviderFixture {
 
     public static FeatureProvider createMockedProvider() {
-        FeatureProvider provider = mock(FeatureProvider.class);
+        FeatureProvider provider = mock(dev.openfeature.sdk.DomainAwareTestProvider.class, org.mockito.Answers.CALLS_REAL_METHODS);
         doReturn(ProviderState.NOT_READY).when(provider).getState();
         return provider;
     }
 
     public static FeatureProvider createMockedReadyProvider() {
-        FeatureProvider provider = mock(FeatureProvider.class);
+        FeatureProvider provider = mock(dev.openfeature.sdk.DomainAwareTestProvider.class, org.mockito.Answers.CALLS_REAL_METHODS);
         doReturn(ProviderState.READY).when(provider).getState();
         return provider;
     }
 
     public static FeatureProvider createMockedErrorProvider() throws Exception {
-        FeatureProvider provider = mock(FeatureProvider.class);
+        FeatureProvider provider = mock(dev.openfeature.sdk.DomainAwareTestProvider.class, org.mockito.Answers.CALLS_REAL_METHODS);
         doReturn(ProviderState.NOT_READY).when(provider).getState();
-        doThrow(FileNotFoundException.class).when(provider).initialize(any());
-        return provider;
-    }
-
-    public static FeatureProvider createBlockedProvider(CountDownLatch latch, Runnable onAnswer) throws Exception {
-        FeatureProvider provider = createMockedProvider();
-        doBlock(latch, createAnswerExecutingCode(onAnswer)).when(provider).initialize(new ImmutableContext());
-        doReturn("blockedProvider").when(provider).toString();
-        return provider;
-    }
-
-    private static Answer<?> createAnswerExecutingCode(Runnable onAnswer) {
-        return invocation -> {
-            onAnswer.run();
-            return null;
-        };
-    }
-
-    public static FeatureProvider createUnblockingProvider(CountDownLatch latch) throws Exception {
-        FeatureProvider provider = createMockedProvider();
-        doAnswer(invocation -> {
-                    latch.countDown();
-                    return null;
-                })
-                .when(provider)
-                .initialize(new ImmutableContext());
-        doReturn("unblockingProvider").when(provider).toString();
+        ((dev.openfeature.sdk.DomainAwareTestProvider) doThrow(FileNotFoundException.class).when(provider)).initialize(any());
         return provider;
     }
 }
diff --git a/src/test/java/dev/openfeature/sdk/multiprovider/MultiProviderTest.java b/src/test/java/dev/openfeature/sdk/multiprovider/MultiProviderTest.java
index d69cd82..f0781d8 100644
--- a/src/test/java/dev/openfeature/sdk/multiprovider/MultiProviderTest.java
+++ b/src/test/java/dev/openfeature/sdk/multiprovider/MultiProviderTest.java
@@ -5,8 +5,13 @@ import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.isNull;
+import static org.mockito.ArgumentMatchers.same;
 import static org.mockito.Mockito.doThrow;
 import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
 import dev.openfeature.sdk.ErrorCode;
@@ -15,8 +20,10 @@ import dev.openfeature.sdk.FeatureProvider;
 import dev.openfeature.sdk.Metadata;
 import dev.openfeature.sdk.MutableContext;
 import dev.openfeature.sdk.ProviderEvaluation;
+import dev.openfeature.sdk.ProviderState;
 import dev.openfeature.sdk.Value;
 import dev.openfeature.sdk.exceptions.GeneralError;
+import dev.openfeature.sdk.providers.memory.InMemoryProvider;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
@@ -27,6 +34,15 @@ import org.junit.jupiter.api.Test;
 
 class MultiProviderTest extends BaseStrategyTest {
 
+    @Override
+    protected void setupMockProviders() {
+        super.setupMockProviders();
+        mockProvider1 = mock(dev.openfeature.sdk.DomainAwareTestProvider.class);
+        mockProvider2 = mock(dev.openfeature.sdk.DomainAwareTestProvider.class);
+        when(mockProvider1.getMetadata()).thenReturn(mockMetaData1);
+        when(mockProvider2.getMetadata()).thenReturn(mockMetaData2);
+    }
+
     @Test
     void shouldInitializeWithEmptyProvidersList() {
         MultiProvider multiProvider = new MultiProvider(new ArrayList<>());
@@ -52,10 +68,63 @@ class MultiProviderTest extends BaseStrategyTest {
         assertEquals("multiprovider", multiProvider.getMetadata().getName());
     }
 
+    @SneakyThrows
+    @Test
+    void singleArgInitializeForwardsNullDomainToChildren() {
+        List<FeatureProvider> providers = new ArrayList<>(2);
+        providers.add(mockProvider1);
+        providers.add(mockProvider2);
+        MultiProvider multiProvider = new MultiProvider(providers);
+
+        multiProvider.initialize(null);
+
+        ((dev.openfeature.sdk.DomainAwareTestProvider) verify(mockProvider1)).initialize(isNull(), isNull());
+        ((dev.openfeature.sdk.DomainAwareTestProvider) verify(mockProvider2)).initialize(isNull(), isNull());
+    }
+
+    @SneakyThrows
+    @Test
+    void forwardsDomainToChildProviderInitialize() {
+        List<FeatureProvider> providers = new ArrayList<>(2);
+        providers.add(mockProvider1);
+        providers.add(mockProvider2);
+        MultiProvider multiProvider = new MultiProvider(providers);
+        EvaluationContext context = new MutableContext().add("targetingKey", "user");
+
+        dev.openfeature.sdk.DomainInitializeTestSupport.initialize(multiProvider, context, "my-domain");
+
+        ((dev.openfeature.sdk.DomainAwareTestProvider) verify(mockProvider1)).initialize(same(context), eq("my-domain"));
+        ((dev.openfeature.sdk.DomainAwareTestProvider) verify(mockProvider2)).initialize(same(context), eq("my-domain"));
+    }
+
+    @SneakyThrows
+    @Test
+    void forwardsDomainToLegacySingleArgChildProvidersWithoutError() {
+        InMemoryProvider legacyProvider1 = new InMemoryProvider(Map.of()) {
+            @Override
+            public Metadata getMetadata() {
+                return () -> "legacy-provider-1";
+            }
+        };
+        InMemoryProvider legacyProvider2 = new InMemoryProvider(Map.of()) {
+            @Override
+            public Metadata getMetadata() {
+                return () -> "legacy-provider-2";
+            }
+        };
+        MultiProvider multiProvider = new MultiProvider(List.of(legacyProvider1, legacyProvider2));
+        EvaluationContext context = new MutableContext().add("targetingKey", "user");
+
+        dev.openfeature.sdk.DomainInitializeTestSupport.initialize(multiProvider, context, "my-domain");
+
+        assertEquals(ProviderState.READY, legacyProvider1.getState());
+        assertEquals(ProviderState.READY, legacyProvider2.getState());
+    }
+
     @SneakyThrows
     @Test
     void shouldHandleInitializationFailure() {
-        doThrow(new GeneralError()).when(mockProvider1).initialize(any());
+        ((dev.openfeature.sdk.DomainAwareTestProvider) doThrow(new GeneralError()).when(mockProvider1)).initialize(any(), isNull());
         doThrow(new GeneralError()).when(mockProvider1).shutdown();
         List<FeatureProvider> providers = new ArrayList<>(2);
         providers.add(mockProvider1);
@@ -66,6 +135,18 @@ class MultiProviderTest extends BaseStrategyTest {
         assertDoesNotThrow(multiProvider::shutdown);
     }
 
+    @SneakyThrows
+    @Test
+    void continuesWhenShutdownFailsAfterInitializeFailure() {
+        ((dev.openfeature.sdk.DomainAwareTestProvider) doThrow(new GeneralError()).when(mockProvider1)).initialize(any(), isNull());
+        MultiProvider multiProvider = spy(new MultiProvider(List.of(mockProvider1)));
+        doThrow(new RuntimeException("shutdown failed")).when(multiProvider).shutdown();
+
+        assertThrows(ExecutionException.class, () -> multiProvider.initialize(null));
+
+        verify(multiProvider).shutdown();
+    }
+
     @Test
     void shouldHandleDuplicateProviderNames() {
         when(mockProvider1.getMetadata()).thenReturn(() -> "provider");
diff --git a/src/test/java/dev/openfeature/sdk/vmlens/ProviderRepositoryCT.java b/src/test/java/dev/openfeature/sdk/vmlens/ProviderRepositoryCT.java
index 2d88f69..8358cf9 100644
--- a/src/test/java/dev/openfeature/sdk/vmlens/ProviderRepositoryCT.java
+++ b/src/test/java/dev/openfeature/sdk/vmlens/ProviderRepositoryCT.java
@@ -2,6 +2,7 @@ package dev.openfeature.sdk.vmlens;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.isNull;
 import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
@@ -24,7 +25,7 @@ import org.junit.jupiter.api.Test;
 class ProviderRepositoryCT {
 
     private FeatureProvider createMockedProvider(String name, AtomicInteger shutdownCounter) throws Exception {
-        FeatureProvider provider = mock(FeatureProvider.class);
+        FeatureProvider provider = mock(dev.openfeature.sdk.DomainAwareTestProvider.class, org.mockito.Answers.CALLS_REAL_METHODS);
         when(provider.getMetadata()).thenReturn(() -> name);
         doAnswer(invocation -> {
                     shutdownCounter.incrementAndGet();
@@ -32,7 +33,7 @@ class ProviderRepositoryCT {
                 })
                 .when(provider)
                 .shutdown();
-        doAnswer(invocation -> null).when(provider).initialize(any());
+        ((dev.openfeature.sdk.DomainAwareTestProvider) doAnswer(invocation -> null).when(provider)).initialize(any());
         return provider;
     }
 
@@ -155,4 +156,35 @@ class ProviderRepositoryCT {
             }
         }
     }
+
+    @Test
+    void concurrentRegistrationToSameDomain_exactlyOneBoundAndLoserShutDown() throws Exception {
+        final String domain = "domain-1";
+        try (AllInterleavings allInterleavings = new AllInterleavings("Concurrent registration to the same domain")) {
+            while (allInterleavings.hasNext()) {
+                AtomicInteger provider1ShutdownCount = new AtomicInteger(0);
+                AtomicInteger provider2ShutdownCount = new AtomicInteger(0);
+                FeatureProvider provider1 = createMockedProvider("provider-1", provider1ShutdownCount);
+                FeatureProvider provider2 = createMockedProvider("provider-2", provider2ShutdownCount);
+                OpenFeatureAPI api = OpenFeatureAPITestUtil.createAPI();
+
+                // two different providers race to bind to the same domain
+                Runner.runParallel(
+                        () -> api.setProviderAndWait(domain, provider1),
+                        () -> api.setProviderAndWait(domain, provider2));
+
+                // the domain resolves to exactly one of the two providers
+                FeatureProvider bound = api.getProvider(domain);
+                assertThat(bound).isIn(provider1, provider2);
+
+                // the provider that lost the race is shut down exactly once; the winner is left running
+                AtomicInteger winner = bound == provider1 ? provider1ShutdownCount : provider2ShutdownCount;
+                AtomicInteger loser = bound == provider1 ? provider2ShutdownCount : provider1ShutdownCount;
+                assertThat(loser.get())
+                        .as("Losing provider shut down exactly once")
+                        .isEqualTo(1);
+                assertThat(winner.get()).as("Winning provider not shut down").isZero();
+            }
+        }
+    }
 }