rename files for consistent

Signed-off-by: Roman Dmytrenko <rdmytrenko@gmail.com>

Author: erka

README.md

@@ -335,7 +335,7 @@ client.Boolean(tCtx, ....)
 ### Multi-Provider Implementation
 
 Included with this SDK is an _experimental_ multi-provider that can be used to query multiple feature flag providers simultaneously.
-More information can be found in the [multi package's README](openfeature/multi/README.md).
+More information can be found in the [multi package's README](providers/multi/README.md).
 
 ## Extending
 
@@ -449,72 +449,8 @@ func (h MyHook) Error(context context.Context, hookContext openfeature.HookConte
 ## Testing
 
 The SDK provides a `testing.NewProvider` which allows you to set flags for the scope of a test.
-The `TestProvider` is thread-safe and can be used in tests that run in parallel.
-
-Call `testProvider.UsingFlags(t, tt.flags)` to set flags for a test, and clean them up with `testProvider.Cleanup()`
-
-```go
-import (
-  "go.openfeature.dev/openfeature/v2"
-  "go.openfeature.dev/openfeature/v2/providers/inmemory"
-  "go.openfeature.dev/openfeature/v2/providers/testing"
-)
-
-testProvider := testing.NewProvider()
-err := openfeature.SetProviderAndWait(t.Context(), testProvider)
-if err != nil {
-  t.Errorf("unable to set provider")
-}
-
-// configure flags for this test suite
-tests := map[string]struct {
-  flags map[string]inmemory.InMemoryFlag
-  want  bool
-}{
-  "test when flag is true": {
-    flags: map[string]inmemory.InMemoryFlag{
-      "my_flag": {
-        State:          inmemory.Enabled,
-        DefaultVariant: "on",
-        Variants: map[string]any{
-          "on": true,
-        },
-      },
-    },
-    want: true,
-  },
-  "test when flag is false": {
-    flags: map[string]inmemory.InMemoryFlag{
-      "my_flag": {
-        State:          inmemory.Enabled,
-        DefaultVariant: "off",
-        Variants: map[string]any{
-          "off": false,
-        },
-      },
-    },
-    want: false,
-  },
-}
-
-for name, tt := range tests {
-  tt := tt
-  name := name
-  t.Run(name, func(t *testing.T) {
-
-    // be sure to clean up your flags
-    defer testProvider.Cleanup()
-    testProvider.UsingFlags(t, tt.flags)
-
-    // your code under test
-    got := functionUnderTest()
-
-    if got != tt.want {
-      t.Fatalf("uh oh, value is not as expected: got %v, want %v", got, tt.want)
-    }
-  })
-}
-```
+The `TestProvider` has proper isolation and can be used in tests that run in parallel.
+More information can be found in the [testing package's README](providers/testing/README.md).
 
 ### Mocks
 

providers/inmemory/in_memory_provider.go providers/inmemory/inmemory_provider.goproviders/inmemory/in_memory_provider.go renamed to providers/inmemory/inmemory_provider.go

@@ -1,5 +1,5 @@
-// Package memprovider provides an in-memory feature flag provider for OpenFeature.
-package memprovider
+// Package inmemory provides an in-memory feature flag provider for OpenFeature.
+package inmemory
 
 import (
 	"context"

…ders/inmemory/in_memory_provider_test.go …iders/inmemory/inmemory_provider_test.goproviders/inmemory/in_memory_provider_test.go renamed to providers/inmemory/inmemory_provider_test.go providers/inmemory/in_memory_provider_test.go renamed to providers/inmemory/inmemory_provider_test.go

@@ -1,4 +1,4 @@
-package memprovider
+package inmemory
 
 import (
 	"math"

providers/multi/multiprovider.go providers/multi/multi_provider.goproviders/multi/multiprovider.go renamed to providers/multi/multi_provider.go

@@ -0,0 +1,36 @@
+# Testing provider
+
+`TestProvider` is an OpenFeature compliant provider implementation designed for testing applications with feature flags.
+
+The testing provider allows you to define feature flag values scoped to individual tests, ensuring test isolation and preventing flag state from leaking between tests. It uses the `InMemoryProvider` internally with per-test flag storage.
+
+# Usage
+
+```go
+import (
+ "testing"
+
+ "go.openfeature.dev/openfeature/v2"
+ "go.openfeature.dev/openfeature/v2/providers/inmemory"
+ "go.openfeature.dev/openfeature/v2/providers/testing"
+)
+
+testProvider := testing.NewProvider()
+err := openfeature.SetProviderAndWait(t.Context(), testProvider)
+if err != nil {
+ t.Fatal(err)
+}
+
+ctx := testProvider.UsingFlags(t, map[string]memprovider.InMemoryFlag{
+ "my_feature": {
+  State:          memprovider.Enabled,
+  DefaultVariant: "on",
+  Variants:       map[string]any{"on": true},
+ },
+})
+
+client := openfeature.NewClient()
+result := client.Boolean(ctx, "my_feature", false, openfeature.EvaluationContext{})
+```
+
+The testing provider supports parallel test execution with proper isolation.

providers/multi/multiprovider_test.go providers/multi/multi_provider_test.goproviders/multi/multiprovider_test.go renamed to providers/multi/multi_provider_test.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"runtime"
 	"sync"
+	"testing"
 
 	"go.openfeature.dev/openfeature/v2"
 	memprovider "go.openfeature.dev/openfeature/v2/providers/inmemory"
@@ -43,6 +44,14 @@ func (tp TestProvider) UsingFlags(test TestFramework, flags map[string]memprovid
 	if ctx == nil {
 		ctx = context.Background()
 	}
+
+	// if test is testing.TB add the auto Cleanup
+	if t, ok := test.(testing.TB); ok {
+		t.Cleanup(func() {
+			tp.Cleanup(ctx)
+		})
+	}
+
 	return context.WithValue(ctx, testNameKey, test.Name())
 }