Additional tests for System.Text.Json

src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonConverterOfT.cs

@@ -290,45 +290,27 @@ internal bool TryWriteDataExtensionProperty(Utf8JsonWriter writer, T value, Json
             bool success;
             JsonDictionaryConverter<T> dictionaryConverter = (JsonDictionaryConverter<T>)this;
 
-            if (ClassType == ClassType.Value)
-            {
-                Debug.Assert(!state.IsContinuation);
-
-                int originalPropertyDepth = writer.CurrentDepth;
+            bool isContinuation = state.IsContinuation;
 
-                // Ignore the naming policy for extension data.
-                state.Current.IgnoreDictionaryKeyPolicy = true;
+            state.Push();
 
-                success = dictionaryConverter.OnWriteResume(writer, value, options, ref state);
-                if (success)
-                {
-                    VerifyWrite(originalPropertyDepth, writer);
-                }
-            }
-            else
+            if (!isContinuation)
             {
-                bool isContinuation = state.IsContinuation;
-
-                state.Push();
-
-                if (!isContinuation)
-                {
-                    Debug.Assert(state.Current.OriginalDepth == 0);
-                    state.Current.OriginalDepth = writer.CurrentDepth;
-                }
+                Debug.Assert(state.Current.OriginalDepth == 0);
+                state.Current.OriginalDepth = writer.CurrentDepth;
+            }
 
-                // Ignore the naming policy for extension data.
-                state.Current.IgnoreDictionaryKeyPolicy = true;
+            // Ignore the naming policy for extension data.
+            state.Current.IgnoreDictionaryKeyPolicy = true;
 
-                success = dictionaryConverter.OnWriteResume(writer, value, options, ref state);
-                if (success)
-                {
-                    VerifyWrite(state.Current.OriginalDepth, writer);
-                }
-
-                state.Pop(success);
+            success = dictionaryConverter.OnWriteResume(writer, value, options, ref state);
+            if (success)
+            {
+                VerifyWrite(state.Current.OriginalDepth, writer);
             }
 
+            state.Pop(success);
+
             return success;
         }
 

src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonDictionaryConverter.cs

@@ -9,7 +9,7 @@ namespace System.Text.Json.Serialization
     /// </summary>
     internal abstract class JsonDictionaryConverter<T> : JsonResumableConverter<T>
     {
-        internal override ClassType ClassType => ClassType.Dictionary;
+        internal sealed override ClassType ClassType => ClassType.Dictionary;
         protected internal abstract bool OnWriteResume(Utf8JsonWriter writer, T dictionary, JsonSerializerOptions options, ref WriteStack state);
     }
 }

src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonSerializer.Write.Stream.cs

@@ -21,6 +21,9 @@ public static partial class JsonSerializer
         /// <param name="cancellationToken">The <see cref="System.Threading.CancellationToken"/> which may be used to cancel the write operation.</param>
         public static Task SerializeAsync<TValue>(Stream utf8Json, TValue value, JsonSerializerOptions? options = null, CancellationToken cancellationToken = default)
         {
+            if (utf8Json == null)
+                throw new ArgumentNullException(nameof(utf8Json));
+
             return WriteAsyncCore(utf8Json, value, typeof(TValue), options, cancellationToken);
         }
 
@@ -65,11 +68,6 @@ private static async Task WriteAsyncCore(Stream utf8Json, object? value, Type in
                     return;
                 }
 
-                if (inputType == null)
-                {
-                    inputType = value.GetType();
-                }
-
                 WriteStack state = default;
                 state.InitializeRoot(inputType, options, supportContinuation: true);
 

src/libraries/System.Text.Json/tests/Serialization/Stream.ReadTests.cs

@@ -12,9 +12,10 @@ namespace System.Text.Json.Serialization.Tests
     public static partial class StreamTests
     {
         [Fact]
-        public static async Task NullArgumentFail()
+        public static async Task ReadNullArgumentFail()
         {
             await Assert.ThrowsAsync<ArgumentNullException>(async () => await JsonSerializer.DeserializeAsync<string>((Stream)null));
+            await Assert.ThrowsAsync<ArgumentNullException>(async () => await JsonSerializer.DeserializeAsync((Stream)null, (Type)null));
             await Assert.ThrowsAsync<ArgumentNullException>(async () => await JsonSerializer.DeserializeAsync(new MemoryStream(), (Type)null));
         }
 

src/libraries/System.Text.Json/tests/Serialization/Stream.WriteTests.cs

@@ -12,6 +12,13 @@ namespace System.Text.Json.Serialization.Tests
 {
     public static partial class StreamTests
     {
+        [Fact]
+        public static async Task WriteNullArgumentFail()
+        {
+            await Assert.ThrowsAsync<ArgumentNullException>(async () => await JsonSerializer.SerializeAsync((Stream)null, 1));
+            await Assert.ThrowsAsync<ArgumentNullException>(async () => await JsonSerializer.SerializeAsync((Stream)null, 1, typeof(int)));
+        }
+
         [Fact]
         public static async Task VerifyValueFail()
         {

src/libraries/System.Text.Json/tests/Utf8JsonReaderTests.MultiSegment.cs

@@ -899,6 +899,60 @@ public static void TestSingleStringsMultiSegment()
             }
         }
 
+        [Fact]
+        public static void TestMultiSegmentStringConversionToDateTime()
+        {
+            string jsonString = "\"1997-07-16\"";
+            string expectedString = "1997-07-16";
+
+            byte[] dataUtf8 = Encoding.UTF8.GetBytes(jsonString);
+
+            ReadOnlySequence<byte> sequence = JsonTestHelper.CreateSegments(dataUtf8);
+
+            var json = new Utf8JsonReader(sequence, isFinalBlock: false, state: default);
+            while (json.Read())
+            {
+                if (json.TokenType == JsonTokenType.String)
+                {
+                    DateTime expected = DateTime.Parse(expectedString);
+
+                    Assert.True(json.TryGetDateTime(out DateTime actual));
+                    Assert.Equal(expected, actual);
+
+                    Assert.Equal(expected, json.GetDateTime());
+                }
+            }
+
+            Assert.Equal(dataUtf8.Length, json.BytesConsumed);
+        }
+
+        [Fact]
+        public static void TestMultiSegmentStringConversionToDateTimeOffset()
+        {
+            string jsonString = "\"1997-07-16\"";
+            string expectedString = "1997-07-16";
+
+            byte[] dataUtf8 = Encoding.UTF8.GetBytes(jsonString);
+
+            ReadOnlySequence<byte> sequence = JsonTestHelper.CreateSegments(dataUtf8);
+
+            var json = new Utf8JsonReader(sequence, isFinalBlock: false, state: default);
+            while (json.Read())
+            {
+                if (json.TokenType == JsonTokenType.String)
+                {
+                    DateTimeOffset expected = DateTimeOffset.Parse(expectedString);
+
+                    Assert.True(json.TryGetDateTimeOffset(out DateTimeOffset actual));
+                    Assert.Equal(expected, actual);
+
+                    Assert.Equal(expected, json.GetDateTimeOffset());
+                }
+            }
+
+            Assert.Equal(dataUtf8.Length, json.BytesConsumed);
+        }
+
         private static void SpanSequenceStatesAreEqualInvalidJson(byte[] dataUtf8, ReadOnlySequence<byte> sequence, int maxDepth, JsonCommentHandling commentHandling)
         {
             var stateSpan = new JsonReaderState(new JsonReaderOptions { CommentHandling = commentHandling, MaxDepth = maxDepth });