fix reading json with naming policy

src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Value/EnumConverter.cs

@@ -24,6 +24,9 @@ internal class EnumConverter<T> : JsonConverter<T>
         private readonly JsonNamingPolicy? _namingPolicy;
 
         private readonly ConcurrentDictionary<ulong, JsonEncodedText> _nameCache;
+        private readonly ConcurrentDictionary<JsonEncodedText, string> _sourceNameCache;
+        private readonly bool _needRestoreSourceName;
+        private readonly JsonSerializerOptions _serializerOptions;
 
         // This is used to prevent flooding the cache due to exponential bitwise combinations of flags.
         // Since multiple threads can add to the cache, a few more values might be added.
@@ -43,7 +46,9 @@ public EnumConverter(EnumConverterOptions converterOptions, JsonNamingPolicy? na
         {
             _converterOptions = converterOptions;
             _namingPolicy = namingPolicy;
+            _serializerOptions = serializerOptions;
             _nameCache = new ConcurrentDictionary<ulong, JsonEncodedText>();
+            _sourceNameCache = new ConcurrentDictionary<JsonEncodedText, string>();
 
             string[] names = Enum.GetNames(TypeToConvert);
             Array values = Enum.GetValues(TypeToConvert);
@@ -67,7 +72,12 @@ public EnumConverter(EnumConverterOptions converterOptions, JsonNamingPolicy? na
                     namingPolicy == null
                         ? JsonEncodedText.Encode(name, encoder)
                         : FormatEnumValue(name, encoder));
+
+                if (namingPolicy != null)
+                    _sourceNameCache.TryAdd(FormatEnumValue(name, encoder), name);
             }
+
+            _needRestoreSourceName = namingPolicy != null;
         }
 
         public override T Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
@@ -313,6 +323,9 @@ internal override T ReadWithQuotes(ref Utf8JsonReader reader)
         {
             string? enumString = reader.GetString();
 
+            if (_needRestoreSourceName && enumString != null)
+                _sourceNameCache.TryGetValue(FormatEnumValue(enumString, _serializerOptions.Encoder), out enumString);
+
             // Try parsing case sensitive first
             if (!Enum.TryParse(enumString, out T value)
                 && !Enum.TryParse(enumString, ignoreCase: true, out value))

src/libraries/System.Text.Json/tests/Serialization/EnumConverterWithNamingPolicyTests.cs

@@ -0,0 +1,96 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace System.Text.Json.Serialization.Tests
+{
+   public class EnumConverterWithNamingPolicyTests
+    {
+        private readonly ITestOutputHelper _outputHelper;
+
+        public EnumConverterWithNamingPolicyTests(ITestOutputHelper outputHelper)
+        {
+            _outputHelper = outputHelper;
+        }
+
+        public class SnakeCaseNamingPolicy : JsonNamingPolicy
+        {
+            public override string ConvertName(string name)
+            {
+                if (name == null)
+                {
+                    throw new ArgumentNullException(nameof(name));
+                }
+                var result = new StringBuilder();
+                for (var i = 0; i < name.Length; i++)
+                {
+                    var c = name[i];
+                    if (i == 0)
+                    {
+                        result.Append(char.ToLower(c));
+                    }
+                    else
+                    {
+                        if (char.IsUpper(c))
+                        {
+                            result.Append('_');
+                            result.Append(char.ToLower(c));
+                        }
+                        else
+                        {
+                            result.Append(c);
+                        }
+                    }
+                }
+                return result.ToString();
+            }
+
+        }
+        public enum TestType
+        {
+            None,
+            ValueOne,
+            ValueTwo,
+        }
+
+        public class ObjectWithEnumProperty
+        {
+            public TestType TestType { get; set; }
+        }
+
+        [Fact]
+        public void TestEnumCase()
+        {
+            var namingPolicy = new SnakeCaseNamingPolicy();
+
+            var opts = new JsonSerializerOptions()
+            {
+                PropertyNamingPolicy = namingPolicy,
+                DictionaryKeyPolicy = namingPolicy,
+                Converters =
+                {
+                    new JsonStringEnumConverter(namingPolicy)
+                }
+            };
+
+            var enumValues = Enum.GetValues(typeof(TestType)).Cast<TestType>();
+            foreach (var v in enumValues)
+            {
+                var sourceObject = new ObjectWithEnumProperty()
+                {
+                    TestType = v
+                };
+
+                var json = JsonSerializer.Serialize(sourceObject, opts);
+                _outputHelper.WriteLine(json);
+                var deserializedObject = JsonSerializer.Deserialize<ObjectWithEnumProperty>(json, opts);
+                Assert.Equal(sourceObject.TestType, deserializedObject.TestType);
+            }
+        }
+    }
+}

src/libraries/System.Text.Json/tests/System.Text.Json.Tests.csproj

@@ -88,6 +88,7 @@
     <Compile Include="Serialization\CyclicTests.cs" />
     <Compile Include="Serialization\DeserializationWrapper.cs" />
     <Compile Include="Serialization\EnumConverterTests.cs" />
+    <Compile Include="Serialization\EnumConverterWithNamingPolicyTests.cs" />
     <Compile Include="Serialization\EnumTests.cs" />
     <Compile Include="Serialization\ExceptionTests.cs" />
     <Compile Include="Serialization\ExtensionDataTests.cs" />