From dd7b82c18d2ed633cf160bec7f99fec954cde1d1 Mon Sep 17 00:00:00 2001
From: Martin Machacek <machacek@edhouse.cz>
Date: Tue, 16 Jul 2024 14:57:23 +0200
Subject: [PATCH 1/7] Use invariant culture for (de)serialization

---
 src/abstractions/Time.cs                      |  26 +-
 src/serialization/form/FormParseNode.cs       |  19 +-
 .../form/FormSerializationWriter.cs           |   3 +-
 src/serialization/json/JsonParseNode.cs       |   7 +-
 src/serialization/text/TextParseNode.cs       |  19 +-
 .../text/TextSerializationWriter.cs           |  17 +-
 .../serialization/form/FormParseNodeTests.cs  | 218 ++++++++++-
 .../form/FormSerializationWriterTests.cs      | 346 +++++++++++++++++-
 .../serialization/json/JsonParseNodeTests.cs  |   6 +
 .../json/JsonSerializationWriterTests.cs      | 313 ++++++++++++++++
 ...soft.Kiota.Serialization.Text.Tests.csproj |   1 +
 tests/serialization/text/Mocks/TestEntity.cs  |  12 +
 tests/serialization/text/Mocks/TestEnum.cs    |   4 +-
 .../text/TextParseNodeFactoryTests.cs         |  82 +++++
 .../serialization/text/TextParseNodeTests.cs  | 213 ++++++++++-
 .../TextSerializationWriterFactoryTests.cs    |  36 ++
 .../text/TextSerializationWriterTests.cs      | 321 ++++++++++++++++
 tests/serialization/text/UnitTest1.cs         |  12 -
 18 files changed, 1602 insertions(+), 53 deletions(-)
 create mode 100644 tests/serialization/text/Mocks/TestEntity.cs
 create mode 100644 tests/serialization/text/TextParseNodeFactoryTests.cs
 create mode 100644 tests/serialization/text/TextSerializationWriterFactoryTests.cs
 delete mode 100644 tests/serialization/text/UnitTest1.cs

diff --git a/src/abstractions/Time.cs b/src/abstractions/Time.cs
index fc534f5d..ffbdeb44 100644
--- a/src/abstractions/Time.cs
+++ b/src/abstractions/Time.cs
@@ -3,13 +3,14 @@
 // ------------------------------------------------------------------------------
 
 using System;
+using System.Security;
 
 namespace Microsoft.Kiota.Abstractions
 {
     /// <summary>
     /// Model to represent only the date component of a DateTime
     /// </summary>
-    public struct Time
+    public struct Time:IEquatable<Time>
     {
 #if NET6_0_OR_GREATER
         /// <summary>
@@ -26,6 +27,29 @@ public struct Time
         /// <returns>A new <see cref="TimeOnly"/> structure whose hours, minutes, seconds and milliseconds are equal to those of the supplied time.</returns>
         public static implicit operator TimeOnly(Time time) => new(time.DateTime.Hour, time.DateTime.Minute, time.DateTime.Second, time.DateTime.Millisecond);
 #endif
+        /// <summary>
+        /// Indicates whether the current object is equal to another object of the same type.
+        /// </summary>
+        /// <param name="other">An object to compare with this object.</param>
+        /// <returns>true if the current object is equal to the other parameter; otherwise, false.</returns>
+        public bool Equals(Time other) => (Hour, Minute, Second) == (other.Hour, other.Minute, other.Second);
+
+        /// <inheritdoc />
+        public override bool Equals(object? o) => (o is Time other) && Equals(other);
+
+        /// <inheritdoc />
+        public override int GetHashCode()
+        {
+#if NET6_0_OR_GREATER
+            return HashCode.Combine(Hour, Minute, Second);
+#else
+            int hash = 17;
+            hash = hash * 23 + Hour.GetHashCode();
+            hash = hash * 23 + Minute.GetHashCode();
+            hash = hash * 23 + Second.GetHashCode();
+            return hash;
+#endif
+        }
         /// <summary>
         /// Create a new Time from hours, minutes, and seconds.
         /// </summary>
diff --git a/src/serialization/form/FormParseNode.cs b/src/serialization/form/FormParseNode.cs
index d6cd966f..09461b82 100644
--- a/src/serialization/form/FormParseNode.cs
+++ b/src/serialization/form/FormParseNode.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Globalization;
 using System.Reflection;
 using System.Xml;
 using Microsoft.Kiota.Abstractions;
@@ -143,21 +144,21 @@ public IEnumerable<T> GetCollectionOfPrimitiveValues<T>()
         }
     }
     /// <inheritdoc/>
-    public DateTimeOffset? GetDateTimeOffsetValue() => DateTimeOffset.TryParse(DecodedValue, out var result) ? result : null;
+    public DateTimeOffset? GetDateTimeOffsetValue() => DateTimeOffset.TryParse(DecodedValue, CultureInfo.InvariantCulture, DateTimeStyles.None, out var result) ? result : null;
     /// <inheritdoc/>
-    public Date? GetDateValue() => DateTime.TryParse(DecodedValue, out var result) ? new Date(result) : null;
+    public Date? GetDateValue() => DateTime.TryParse(DecodedValue, CultureInfo.InvariantCulture, DateTimeStyles.None, out var result) ? new Date(result) : null;
     /// <inheritdoc/>
-    public decimal? GetDecimalValue() => decimal.TryParse(DecodedValue, out var result) ? result : null;
+    public decimal? GetDecimalValue() => decimal.TryParse(DecodedValue, NumberStyles.Number, CultureInfo.InvariantCulture, out var result) ? result : null;
     /// <inheritdoc/>
-    public double? GetDoubleValue() => double.TryParse(DecodedValue, out var result) ? result : null;
+    public double? GetDoubleValue() => double.TryParse(DecodedValue, NumberStyles.Number, CultureInfo.InvariantCulture, out var result) ? result : null;
     /// <inheritdoc/>
-    public float? GetFloatValue() => float.TryParse(DecodedValue, out var result) ? result : null;
+    public float? GetFloatValue() => float.TryParse(DecodedValue, NumberStyles.Number, CultureInfo.InvariantCulture, out var result) ? result : null;
     /// <inheritdoc/>
     public Guid? GetGuidValue() => Guid.TryParse(DecodedValue, out var result) ? result : null;
     /// <inheritdoc/>
-    public int? GetIntValue() => int.TryParse(DecodedValue, out var result) ? result : null;
+    public int? GetIntValue() => int.TryParse(DecodedValue, NumberStyles.Number, CultureInfo.InvariantCulture, out var result) ? result : null;
     /// <inheritdoc/>
-    public long? GetLongValue() => long.TryParse(DecodedValue, out var result) ? result : null;
+    public long? GetLongValue() => long.TryParse(DecodedValue, NumberStyles.Number, CultureInfo.InvariantCulture, out var result) ? result : null;
     /// <inheritdoc/>
     public T GetObjectValue<T>(ParsableFactory<T> factory) where T : IParsable
     {
@@ -205,7 +206,7 @@ private void AssignFieldValues<T>(T item) where T : IParsable
     }
 
     /// <inheritdoc/>
-    public sbyte? GetSbyteValue() => sbyte.TryParse(DecodedValue, out var result) ? result : null;
+    public sbyte? GetSbyteValue() => sbyte.TryParse(DecodedValue, NumberStyles.Number, CultureInfo.InvariantCulture, out var result) ? result : null;
 
     /// <inheritdoc/>
     public string GetStringValue() => DecodedValue;
@@ -222,7 +223,7 @@ private void AssignFieldValues<T>(T item) where T : IParsable
     }
 
     /// <inheritdoc/>
-    public Time? GetTimeValue() => DateTime.TryParse(DecodedValue, out var result) ? new Time(result) : null;
+    public Time? GetTimeValue() => DateTime.TryParse(DecodedValue, CultureInfo.InvariantCulture, DateTimeStyles.None, out var result) ? new Time(result) : null;
 
 #if NET5_0_OR_GREATER
     IEnumerable<T?> IParseNode.GetCollectionOfEnumValues<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicFields)] T>()
diff --git a/src/serialization/form/FormSerializationWriter.cs b/src/serialization/form/FormSerializationWriter.cs
index c1b75804..137d5d35 100644
--- a/src/serialization/form/FormSerializationWriter.cs
+++ b/src/serialization/form/FormSerializationWriter.cs
@@ -91,7 +91,6 @@ private void WriteAnyValue(string? key, object value)
             default:
                 WriteStringValue(key, value.ToString());// works for Date and String types
                 break;
-
         }
     }
 
@@ -134,7 +133,7 @@ public void WriteCollectionOfPrimitiveValues<T>(string? key, IEnumerable<T>? val
     public void WriteDateTimeOffsetValue(string? key, DateTimeOffset? value)
     {
         if(value.HasValue)
-            WriteStringValue(key, value.Value.ToString("o"));
+            WriteStringValue(key, value.Value.ToString("o", CultureInfo.InvariantCulture));
     }
     /// <inheritdoc/>
     public void WriteDateValue(string? key, Date? value)
diff --git a/src/serialization/json/JsonParseNode.cs b/src/serialization/json/JsonParseNode.cs
index b7a9d39b..51c87128 100644
--- a/src/serialization/json/JsonParseNode.cs
+++ b/src/serialization/json/JsonParseNode.cs
@@ -5,6 +5,7 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Globalization;
 using System.Reflection;
 using System.Runtime.Serialization;
 using System.Text.Json;
@@ -155,7 +156,7 @@ public JsonParseNode(JsonElement node, KiotaJsonSerializationContext jsonSeriali
             if(string.IsNullOrEmpty(dateTimeOffsetStr))
                 return null;
 
-            if(DateTimeOffset.TryParse(dateTimeOffsetStr, out dateTimeOffset))
+            if(DateTimeOffset.TryParse(dateTimeOffsetStr, CultureInfo.InvariantCulture, DateTimeStyles.None, out dateTimeOffset))
                 return dateTimeOffset;
 
             return _jsonNode.Deserialize(_jsonSerializerContext.DateTimeOffset);
@@ -185,7 +186,7 @@ public JsonParseNode(JsonElement node, KiotaJsonSerializationContext jsonSeriali
             if(string.IsNullOrEmpty(dateString))
                 return null;
 
-            if(DateTime.TryParse(dateString, out var result))
+            if(DateTime.TryParse(dateString, CultureInfo.InvariantCulture, DateTimeStyles.None, out var result))
                 return new Date(result);
 
             return _jsonNode.Deserialize(_jsonSerializerContext.Date);
@@ -201,7 +202,7 @@ public JsonParseNode(JsonElement node, KiotaJsonSerializationContext jsonSeriali
             if(string.IsNullOrEmpty(dateString))
                 return null;
 
-            if(DateTime.TryParse(dateString, out var result))
+            if(DateTime.TryParse(dateString, CultureInfo.InvariantCulture, DateTimeStyles.None, out var result))
                 return new Time(result);
 
             return _jsonNode.Deserialize(_jsonSerializerContext.Time);
diff --git a/src/serialization/text/TextParseNode.cs b/src/serialization/text/TextParseNode.cs
index 4af865d9..505df103 100644
--- a/src/serialization/text/TextParseNode.cs
+++ b/src/serialization/text/TextParseNode.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Globalization;
 using System.Xml;
 using Microsoft.Kiota.Abstractions;
 using Microsoft.Kiota.Abstractions.Helpers;
@@ -45,31 +46,31 @@ public TextParseNode(string? text)
     public IEnumerable<T> GetCollectionOfPrimitiveValues<T>() => throw new InvalidOperationException(NoStructuredDataMessage);
 #endif
     /// <inheritdoc />
-    public DateTimeOffset? GetDateTimeOffsetValue() => DateTimeOffset.TryParse(Text, out var result) ? result : null;
+    public DateTimeOffset? GetDateTimeOffsetValue() => DateTimeOffset.TryParse(Text, CultureInfo.InvariantCulture, DateTimeStyles.None, out var result) ? result : null;
     /// <inheritdoc />
-    public Date? GetDateValue() => DateTime.TryParse(Text, out var result) ? new Date(result) : null;
+    public Date? GetDateValue() => DateTime.TryParse(Text, CultureInfo.InvariantCulture, DateTimeStyles.None, out var result) ? new Date(result) : null;
     /// <inheritdoc />
-    public decimal? GetDecimalValue() => decimal.TryParse(Text, out var result) ? result : null;
+    public decimal? GetDecimalValue() => decimal.TryParse(Text, NumberStyles.Number, CultureInfo.InvariantCulture, out var result) ? result : null;
     /// <inheritdoc />
-    public double? GetDoubleValue() => double.TryParse(Text, out var result) ? result : null;
+    public double? GetDoubleValue() => double.TryParse(Text, NumberStyles.Number, CultureInfo.InvariantCulture, out var result) ? result : null;
     /// <inheritdoc />
-    public float? GetFloatValue() => float.TryParse(Text, out var result) ? result : null;
+    public float? GetFloatValue() => float.TryParse(Text, NumberStyles.Number, CultureInfo.InvariantCulture, out var result) ? result : null;
     /// <inheritdoc />
     public Guid? GetGuidValue() => Guid.TryParse(Text, out var result) ? result : null;
     /// <inheritdoc />
-    public int? GetIntValue() => int.TryParse(Text, out var result) ? result : null;
+    public int? GetIntValue() => int.TryParse(Text, NumberStyles.Number, CultureInfo.InvariantCulture, out var result) ? result : null;
     /// <inheritdoc />
-    public long? GetLongValue() => long.TryParse(Text, out var result) ? result : null;
+    public long? GetLongValue() => long.TryParse(Text, NumberStyles.Number, CultureInfo.InvariantCulture, out var result) ? result : null;
     /// <inheritdoc />
     public T GetObjectValue<T>(ParsableFactory<T> factory) where T : IParsable => throw new InvalidOperationException(NoStructuredDataMessage);
     /// <inheritdoc />
-    public sbyte? GetSbyteValue() => sbyte.TryParse(Text, out var result) ? result : null;
+    public sbyte? GetSbyteValue() => sbyte.TryParse(Text, NumberStyles.Number, CultureInfo.InvariantCulture, out var result) ? result : null;
     /// <inheritdoc />
     public string? GetStringValue() => Text;
     /// <inheritdoc />
     public TimeSpan? GetTimeSpanValue() => string.IsNullOrEmpty(Text) ? null : XmlConvert.ToTimeSpan(Text);
     /// <inheritdoc />
-    public Time? GetTimeValue() => DateTime.TryParse(Text, out var result) ? new Time(result) : null;
+    public Time? GetTimeValue() => DateTime.TryParse(Text, CultureInfo.InvariantCulture, DateTimeStyles.None, out var result) ? new Time(result) : null;
     /// <inheritdoc />
 #if NET5_0_OR_GREATER
     public IEnumerable<T?> GetCollectionOfEnumValues<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicFields)] T>() where T : struct, Enum
diff --git a/src/serialization/text/TextSerializationWriter.cs b/src/serialization/text/TextSerializationWriter.cs
index 1f6ead0b..15d600c1 100644
--- a/src/serialization/text/TextSerializationWriter.cs
+++ b/src/serialization/text/TextSerializationWriter.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Globalization;
 using System.IO;
 using System.Xml;
 using Microsoft.Kiota.Abstractions;
@@ -59,33 +60,33 @@ public Stream GetSerializedContent()
     /// <inheritdoc />
     public void WriteByteArrayValue(string? key, byte[]? value) => WriteStringValue(key, value?.Length > 0 ? Convert.ToBase64String(value) : string.Empty);
     /// <inheritdoc />
-    public void WriteByteValue(string? key, byte? value) => WriteStringValue(key, value?.ToString());
+    public void WriteByteValue(string? key, byte? value) => WriteStringValue(key, value?.ToString(CultureInfo.InvariantCulture));
     /// <inheritdoc />
     public void WriteCollectionOfObjectValues<T>(string? key, IEnumerable<T>? values) where T : IParsable => throw new InvalidOperationException(TextParseNode.NoStructuredDataMessage);
     /// <inheritdoc />
     public void WriteCollectionOfPrimitiveValues<T>(string? key, IEnumerable<T>? values) => throw new InvalidOperationException(TextParseNode.NoStructuredDataMessage);
     /// <inheritdoc />
-    public void WriteDateTimeOffsetValue(string? key, DateTimeOffset? value) => WriteStringValue(key, value.HasValue ? value.Value.ToString() : null);
+    public void WriteDateTimeOffsetValue(string? key, DateTimeOffset? value) => WriteStringValue(key, value.HasValue ? value.Value.ToString("o", CultureInfo.InvariantCulture) : null);
     /// <inheritdoc />
     public void WriteDateValue(string? key, Date? value) => WriteStringValue(key, value?.ToString());
     /// <inheritdoc />
-    public void WriteDecimalValue(string? key, decimal? value) => WriteStringValue(key, value?.ToString());
+    public void WriteDecimalValue(string? key, decimal? value) => WriteStringValue(key, value?.ToString(CultureInfo.InvariantCulture));
     /// <inheritdoc />
-    public void WriteDoubleValue(string? key, double? value) => WriteStringValue(key, value?.ToString());
+    public void WriteDoubleValue(string? key, double? value) => WriteStringValue(key, value?.ToString(CultureInfo.InvariantCulture));
     /// <inheritdoc />
-    public void WriteFloatValue(string? key, float? value) => WriteStringValue(key, value?.ToString());
+    public void WriteFloatValue(string? key, float? value) => WriteStringValue(key, value?.ToString(CultureInfo.InvariantCulture));
     /// <inheritdoc />
     public void WriteGuidValue(string? key, Guid? value) => WriteStringValue(key, value?.ToString());
     /// <inheritdoc />
-    public void WriteIntValue(string? key, int? value) => WriteStringValue(key, value?.ToString());
+    public void WriteIntValue(string? key, int? value) => WriteStringValue(key, value?.ToString(CultureInfo.InvariantCulture));
     /// <inheritdoc />
-    public void WriteLongValue(string? key, long? value) => WriteStringValue(key, value?.ToString());
+    public void WriteLongValue(string? key, long? value) => WriteStringValue(key, value?.ToString(CultureInfo.InvariantCulture));
     /// <inheritdoc />
     public void WriteNullValue(string? key) => WriteStringValue(key, "null");
     /// <inheritdoc />
     public void WriteObjectValue<T>(string? key, T? value, params IParsable?[] additionalValuesToMerge) where T : IParsable => throw new InvalidOperationException(TextParseNode.NoStructuredDataMessage);
     /// <inheritdoc />
-    public void WriteSbyteValue(string? key, sbyte? value) => WriteStringValue(key, value?.ToString());
+    public void WriteSbyteValue(string? key, sbyte? value) => WriteStringValue(key, value?.ToString(CultureInfo.InvariantCulture));
     /// <inheritdoc />
     public void WriteStringValue(string? key, string? value)
     {
diff --git a/tests/serialization/form/FormParseNodeTests.cs b/tests/serialization/form/FormParseNodeTests.cs
index 5616f55c..59325135 100644
--- a/tests/serialization/form/FormParseNodeTests.cs
+++ b/tests/serialization/form/FormParseNodeTests.cs
@@ -1,9 +1,15 @@
-using Microsoft.Kiota.Abstractions;
+using System.Globalization;
+using Microsoft.Kiota.Abstractions;
 using Microsoft.Kiota.Serialization.Form.Tests.Mocks;
 
 namespace Microsoft.Kiota.Serialization.Form.Tests;
 public class FormParseNodeTests
 {
+    public FormParseNodeTests()
+    {
+        Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("cs-CZ");
+    }
+
     private const string TestUserForm = "displayName=Megan+Bowen&" +
                                         "numbers=one,two,thirtytwo&" +
                                         "givenName=Megan&" +
@@ -127,4 +133,214 @@ public void ReturnsDefaultIfChildNodeDoesNotExist()
         // Assert
         Assert.Null(imaginaryNode);
     }
+
+    [Fact]
+    public void FormParseNode_GetBoolValue()
+    {
+        // Arrange
+        var text = "true";
+        var parseNode = new FormParseNode(text);
+
+        // Act
+        var result = parseNode.GetBoolValue();
+
+        // Assert
+        Assert.True(result);
+    }
+
+    [Fact]
+    public void FormParseNode_GetByteArrayValue()
+    {
+        // Arrange
+        var text = "dGV4dA==";
+        var parseNode = new FormParseNode(text);
+
+        // Act
+        var result = parseNode.GetByteArrayValue();
+
+        // Assert
+        Assert.Equal(new byte []{ 0x74, 0x65, 0x78, 0x74 }, result);
+    }
+
+    [Fact]
+    public void FormParseNode_GetByteValue()
+    {
+        // Arrange
+        var text = "1";
+        var parseNode = new FormParseNode(text);
+
+        // Act
+        var result = parseNode.GetByteValue();
+
+        // Assert
+        Assert.Equal((byte)1, result);
+    }
+
+    [Fact]
+    public void FormParseNode_GetDateTimeOffsetValue()
+    {
+        // Arrange
+        var text = "2021-11-30T12:24:36+03:00";
+        var parseNode = new FormParseNode(text);
+
+        // Act
+        var result = parseNode.GetDateTimeOffsetValue();
+
+        // Assert
+        Assert.Equal(new DateTimeOffset(2021, 11, 30, 12, 24, 36, TimeSpan.FromHours(3)), result);
+    }
+
+    [Fact]
+    public void FormParseNode_GetDateValue()
+    {
+        // Arrange
+        var text = "2021-11-30";
+        var parseNode = new FormParseNode(text);
+
+        // Act
+        var result = parseNode.GetDateValue();
+
+        // Assert
+        Assert.Equal(new Date(2021, 11, 30), result);
+    }
+
+    [Fact]
+    public void FormParseNode_GetTimeSpanValue()
+    {
+        // Arrange
+        var text = "P756DT4H6M8.01S";
+        var parseNode = new FormParseNode(text);
+
+        // Act
+        var result = parseNode.GetTimeSpanValue();
+
+        // Assert
+        Assert.Equal(new TimeSpan(756, 4, 6, 8, 10), result);
+    }
+
+    [Fact]
+    public void FormParseNode_GetTimeValue()
+    {
+        // Arrange
+        var text = "12:24:36";
+        var parseNode = new FormParseNode(text);
+
+        // Act
+        var result = parseNode.GetTimeValue();
+
+        // Assert
+        Assert.Equal(new Time(12, 24, 36), result);
+    }
+
+    [Fact]
+    public void FormParseNode_GetGuidValue()
+    {
+        // Arrange
+        var text = "f4b3b8f4-6f4d-4f1f-8f4d-8f4b3b8f4d1f";
+        var parseNode = new FormParseNode(text);
+
+        // Act
+        var result = parseNode.GetGuidValue();
+
+        // Assert
+        Assert.Equal(new Guid("f4b3b8f4-6f4d-4f1f-8f4d-8f4b3b8f4d1f"), result);
+    }
+
+    [Fact]
+    public void FormParseNode_GetIntValue()
+    {
+        // Arrange
+        var text = "1";
+        var parseNode = new FormParseNode(text);
+
+        // Act
+        var result = parseNode.GetIntValue();
+
+        // Assert
+        Assert.Equal(1, result);
+    }
+
+    [Fact]
+    public void FormParseNode_GetLongValue()
+    {
+        // Arrange
+        var text = "1";
+        var parseNode = new FormParseNode(text);
+
+        // Act
+        var result = parseNode.GetLongValue();
+
+        // Assert
+        Assert.Equal(1L, result);
+    }
+
+    [Fact]
+    public void FormParseNode_GetSbyteValue()
+    {
+        // Arrange
+        var text = "1";
+        var parseNode = new FormParseNode(text);
+
+        // Act
+        var result = parseNode.GetSbyteValue();
+
+        // Assert
+        Assert.Equal((sbyte)1, result);
+    }
+
+    [Fact]
+    public void FormParseNode_GetStringValue()
+    {
+        // Arrange
+        var text = "text";
+        var parseNode = new FormParseNode(text);
+
+        // Act
+        var result = parseNode.GetStringValue();
+
+        // Assert
+        Assert.Equal("text", result);
+    }
+
+    [Fact]
+    public void FormParseNode_GetDecimalValue()
+    {
+        // Arrange
+        var text = "1.1";
+        var parseNode = new FormParseNode(text);
+
+        // Act
+        var result = parseNode.GetDecimalValue();
+
+        // Assert
+        Assert.Equal(1.1m, result);
+    }
+
+    [Fact]
+    public void FormParseNode_GetDoubleValue()
+    {
+        // Arrange
+        var text = "1.1";
+        var parseNode = new FormParseNode(text);
+
+        // Act
+        var result = parseNode.GetDoubleValue();
+
+        // Assert
+        Assert.Equal(1.1, result);
+    }
+
+    [Fact]
+    public void FormParseNode_GetFloatValue()
+    {
+        // Arrange
+        var text = "1.1";
+        var parseNode = new FormParseNode(text);
+
+        // Act
+        var result = parseNode.GetFloatValue();
+
+        // Assert
+        Assert.Equal(1.1f, result);
+    }
 }
diff --git a/tests/serialization/form/FormSerializationWriterTests.cs b/tests/serialization/form/FormSerializationWriterTests.cs
index 37ba35ff..ded84356 100644
--- a/tests/serialization/form/FormSerializationWriterTests.cs
+++ b/tests/serialization/form/FormSerializationWriterTests.cs
@@ -1,10 +1,16 @@
-using System.Text;
+using System.Globalization;
+using System.Text;
 using Microsoft.Kiota.Abstractions;
 using Microsoft.Kiota.Serialization.Form.Tests.Mocks;
 
 namespace Microsoft.Kiota.Serialization.Form.Tests;
 public class FormSerializationWriterTests
 {
+    public FormSerializationWriterTests()
+    {
+        Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("cs-CZ");
+    }
+
     [Fact]
     public void WritesSampleObjectValue()
     {
@@ -108,4 +114,342 @@ public void DoesNotWriteNestedObjectValuesInAdditionalData()
         var exception = Assert.Throws<InvalidOperationException>(() => formSerializerWriter.WriteObjectValue(string.Empty, testEntity));
         Assert.Equal("Form serialization does not support nested objects.", exception.Message);
     }
+
+    [Fact]
+    public void WriteBoolValue_IsWrittenCorrectly()
+    {
+        // Arrange
+        var value = true;
+
+        using var formSerializationWriter = new FormSerializationWriter();
+
+        // Act
+        formSerializationWriter.WriteBoolValue("prop1", value);
+        var contentStream = formSerializationWriter.GetSerializedContent();
+        using var reader = new StreamReader(contentStream, Encoding.UTF8);
+        var serializedString = reader.ReadToEnd();
+
+        // Assert
+        Assert.Equal("prop1=true", serializedString);
+    }
+
+    [Fact]
+    public void WriteByteArrayValue_IsWrittenCorrectly()
+    {
+        // Arrange
+        var value = new byte[] { 2, 4, 6 };
+
+        using var formSerializationWriter = new FormSerializationWriter();
+
+        // Act
+        formSerializationWriter.WriteByteArrayValue("prop1", value);
+        var contentStream = formSerializationWriter.GetSerializedContent();
+        using var reader = new StreamReader(contentStream, Encoding.UTF8);
+        var serializedString = reader.ReadToEnd();
+
+        // Assert
+        Assert.Equal("prop1=AgQG", serializedString);
+    }
+
+    [Fact]
+    public void WriteByteValue_IsWrittenCorrectly()
+    {
+        // Arrange
+        byte value = 5;
+
+        using var formSerializationWriter = new FormSerializationWriter();
+
+        // Act
+        formSerializationWriter.WriteByteValue("prop1", value);
+        var contentStream = formSerializationWriter.GetSerializedContent();
+        using var reader = new StreamReader(contentStream, Encoding.UTF8);
+        var serializedString = reader.ReadToEnd();
+
+        // Assert
+        Assert.Equal("prop1=5", serializedString);
+    }
+
+    [Fact]
+    public void WriteDateTimeOffsetValue_IsWrittenCorrectly()
+    {
+        // Arrange
+        var value = new DateTimeOffset(2024, 11, 30, 15, 35, 45, 987, TimeSpan.FromHours(3));
+
+        using var formSerializationWriter = new FormSerializationWriter();
+
+        // Act
+        formSerializationWriter.WriteDateTimeOffsetValue("prop1", value);
+        var contentStream = formSerializationWriter.GetSerializedContent();
+        using var reader = new StreamReader(contentStream, Encoding.UTF8);
+        var serializedString = reader.ReadToEnd();
+
+        // Assert
+        Assert.Equal("prop1=2024-11-30T15%3A35%3A45.9870000%2B03%3A00", serializedString);
+    }
+
+    [Fact]
+    public void WriteDateValue_IsWrittenCorrectly()
+    {
+        // Arrange
+        var value = new Date(2024, 11, 30);
+
+        using var formSerializationWriter = new FormSerializationWriter();
+
+        // Act
+        formSerializationWriter.WriteDateValue("prop1", value);
+        var contentStream = formSerializationWriter.GetSerializedContent();
+        using var reader = new StreamReader(contentStream, Encoding.UTF8);
+        var serializedString = reader.ReadToEnd();
+
+        // Assert
+        Assert.Equal("prop1=2024-11-30", serializedString);
+    }
+
+    [Fact]
+    public void WriteDecimalValue_IsWrittenCorrectly()
+    {
+        // Arrange
+        var value = 36.8m;
+
+        using var formSerializationWriter = new FormSerializationWriter();
+
+        // Act
+        formSerializationWriter.WriteDecimalValue("prop1", value);
+        var contentStream = formSerializationWriter.GetSerializedContent();
+        using var reader = new StreamReader(contentStream, Encoding.UTF8);
+        var serializedString = reader.ReadToEnd();
+
+        // Assert
+        Assert.Equal("prop1=36.8", serializedString);
+    }
+
+    [Fact]
+    public void WriteDoubleValue_IsWrittenCorrectly()
+    {
+        // Arrange
+        var value = 36.8d;
+
+        using var formSerializationWriter = new FormSerializationWriter();
+
+        // Act
+        formSerializationWriter.WriteDoubleValue("prop1", value);
+        var contentStream = formSerializationWriter.GetSerializedContent();
+        using var reader = new StreamReader(contentStream, Encoding.UTF8);
+        var serializedString = reader.ReadToEnd();
+
+        // Assert
+        Assert.Equal("prop1=36.8", serializedString);
+    }
+
+    [Fact]
+    public void WriteFloatValue_IsWrittenCorrectly()
+    {
+        // Arrange
+        var value = 36.8f;
+
+        using var formSerializationWriter = new FormSerializationWriter();
+
+        // Act
+        formSerializationWriter.WriteFloatValue("prop1", value);
+        var contentStream = formSerializationWriter.GetSerializedContent();
+        using var reader = new StreamReader(contentStream, Encoding.UTF8);
+        var serializedString = reader.ReadToEnd();
+
+        // Assert
+        Assert.Equal("prop1=36.8", serializedString);
+    }
+
+    [Fact]
+    public void WriteGuidValue_IsWrittenCorrectly()
+    {
+        // Arrange
+        var value = new Guid("3adeb301-58f1-45c5-b820-ae5f4af13c89");
+
+        using var formSerializationWriter = new FormSerializationWriter();
+
+        // Act
+        formSerializationWriter.WriteGuidValue("prop1", value);
+        var contentStream = formSerializationWriter.GetSerializedContent();
+        using var reader = new StreamReader(contentStream, Encoding.UTF8);
+        var serializedString = reader.ReadToEnd();
+
+        // Assert
+        Assert.Equal("prop1=3adeb301-58f1-45c5-b820-ae5f4af13c89", serializedString);
+    }
+
+    [Fact]
+    public void WriteIntegerValue_IsWrittenCorrectly()
+    {
+        // Arrange
+        var value = 25;
+
+        using var formSerializationWriter = new FormSerializationWriter();
+
+        // Act
+        formSerializationWriter.WriteIntValue("prop1", value);
+        var contentStream = formSerializationWriter.GetSerializedContent();
+        using var reader = new StreamReader(contentStream, Encoding.UTF8);
+        var serializedString = reader.ReadToEnd();
+
+        // Assert
+        Assert.Equal("prop1=25", serializedString);
+    }
+
+    [Fact]
+    public void WriteLongValue_IsWrittenCorrectly()
+    {
+        // Arrange
+        var value = long.MaxValue;
+
+        using var formSerializationWriter = new FormSerializationWriter();
+
+        // Act
+        formSerializationWriter.WriteLongValue("prop1", value);
+        var contentStream = formSerializationWriter.GetSerializedContent();
+        using var reader = new StreamReader(contentStream, Encoding.UTF8);
+        var serializedString = reader.ReadToEnd();
+
+        // Assert
+        Assert.Equal("prop1=9223372036854775807", serializedString);
+    }
+
+    [Fact]
+    public void WriteNullValue_IsWrittenCorrectly()
+    {
+        // Arrange
+        using var formSerializationWriter = new FormSerializationWriter();
+
+        // Act
+        formSerializationWriter.WriteNullValue("prop1");
+        var contentStream = formSerializationWriter.GetSerializedContent();
+        using var reader = new StreamReader(contentStream, Encoding.UTF8);
+        var serializedString = reader.ReadToEnd();
+
+        // Assert
+        Assert.Equal("prop1=null", serializedString);
+    }
+
+    [Fact]
+    public void WriteSByteValue_IsWrittenCorrectly()
+    {
+        // Arrange
+        var value = sbyte.MaxValue;
+
+        using var formSerializationWriter = new FormSerializationWriter();
+
+        // Act
+        formSerializationWriter.WriteSbyteValue("prop1", value);
+        var contentStream = formSerializationWriter.GetSerializedContent();
+        using var reader = new StreamReader(contentStream, Encoding.UTF8);
+        var serializedString = reader.ReadToEnd();
+
+        // Assert
+        Assert.Equal("prop1=127", serializedString);
+    }
+
+    [Fact]
+    public void WriteTimeValue_IsWrittenCorrectly()
+    {
+        // Arrange
+        var value = new Time(23, 46, 59);
+
+        using var formSerializationWriter = new FormSerializationWriter();
+
+        // Act
+        formSerializationWriter.WriteTimeValue("prop1", value);
+        var contentStream = formSerializationWriter.GetSerializedContent();
+        using var reader = new StreamReader(contentStream, Encoding.UTF8);
+        var serializedString = reader.ReadToEnd();
+
+        // Assert
+        Assert.Equal("prop1=23%3A46%3A59", serializedString);
+    }
+
+    [Fact]
+    public void WriteTimeSpanValue_IsWrittenCorrectly()
+    {
+        // Arrange
+        var value = new TimeSpan(756, 4, 6, 8, 10);
+
+        using var formSerializationWriter = new FormSerializationWriter();
+
+        // Act
+        formSerializationWriter.WriteTimeSpanValue("prop1", value);
+        var contentStream = formSerializationWriter.GetSerializedContent();
+        using var reader = new StreamReader(contentStream, Encoding.UTF8);
+        var serializedString = reader.ReadToEnd();
+
+        // Assert
+        Assert.Equal("prop1=P756DT4H6M8.01S", serializedString);
+    }
+
+    [Fact]
+    public void WriteAdditionalData_AreWrittenCorrectly()
+    {
+        // Arrange
+        var additionalData = new Dictionary<string, object>()
+        {
+            { "prop1", "value1" },
+            { "prop2", 2 },
+            { "prop3", true },
+            { "prop4", 2.25d },
+            { "prop5", 3.14f },
+            { "prop6", 4L },
+            { "prop7", 5m },
+            { "prop8", new DateTimeOffset(2024, 11, 30, 15, 35, 45, 987, TimeSpan.FromHours(3)) },
+            { "prop9", new Date(2024, 11, 30) },
+            { "prop10", new Time(23, 46, 59) },
+            { "prop11", new TimeSpan(756, 4, 6, 8, 10) },
+            { "prop12", new byte[] { 2, 4, 6 } },
+            { "prop13", new Guid("3adeb301-58f1-45c5-b820-ae5f4af13c89") },
+            { "prop14", sbyte.MaxValue }
+        };
+
+        using var formSerializationWriter = new FormSerializationWriter();
+
+        // Act and Assert
+        formSerializationWriter.WriteAdditionalData(additionalData);
+        var contentStream = formSerializationWriter.GetSerializedContent();
+        using var reader = new StreamReader(contentStream, Encoding.UTF8);
+        var serializedString = reader.ReadToEnd();
+
+        // Assert
+        Assert.Equal("prop1=value1&prop2=2&prop3=true&prop4=2.25&prop5=3.14&prop6=4&prop7=5&prop8=2024-11-30T15%3A35%3A45.9870000%2B03%3A00&prop9=2024-11-30&prop10=23%3A46%3A59&prop11=P756DT4H6M8.01S&prop12=System.Byte%5B%5D&prop13=3adeb301-58f1-45c5-b820-ae5f4af13c89&prop14=127", serializedString);
+    }
+
+    [Fact]
+    public void WriteEnumValue_IsWrittenCorrectly()
+    {
+        // Arrange
+        var value = TestEnum.Sixteen;
+
+        using var formSerializationWriter = new FormSerializationWriter();
+
+        // Act
+        formSerializationWriter.WriteEnumValue<TestEnum>("prop1", value);
+        var contentStream = formSerializationWriter.GetSerializedContent();
+        using var reader = new StreamReader(contentStream, Encoding.UTF8);
+        var serializedString = reader.ReadToEnd();
+
+        // Assert
+        Assert.Equal("prop1=sixteen", serializedString);
+    }
+
+    [Fact]
+    public void WriteCollectionOfEnumValues_IsWrittenCorrectly()
+    {
+        // Arrange
+        var value = new List<TestEnum?> { TestEnum.Sixteen, TestEnum.Two };
+
+        using var formSerializationWriter = new FormSerializationWriter();
+
+        // Act
+        formSerializationWriter.WriteCollectionOfEnumValues("prop1", value);
+        var contentStream = formSerializationWriter.GetSerializedContent();
+        using var reader = new StreamReader(contentStream, Encoding.UTF8);
+        var serializedString = reader.ReadToEnd();
+
+        // Assert
+        Assert.Equal("prop1=sixteen%2Ctwo", serializedString);
+    }
 }
diff --git a/tests/serialization/json/JsonParseNodeTests.cs b/tests/serialization/json/JsonParseNodeTests.cs
index 84ac1c24..eca6595f 100644
--- a/tests/serialization/json/JsonParseNodeTests.cs
+++ b/tests/serialization/json/JsonParseNodeTests.cs
@@ -1,6 +1,8 @@
 using System;
+using System.Globalization;
 using System.Linq;
 using System.Text.Json;
+using System.Threading;
 using Microsoft.Kiota.Abstractions;
 using Microsoft.Kiota.Abstractions.Serialization;
 using Microsoft.Kiota.Serialization.Json.Tests.Converters;
@@ -11,6 +13,10 @@ namespace Microsoft.Kiota.Serialization.Json.Tests
 {
     public class JsonParseNodeTests
     {
+        public JsonParseNodeTests()
+        {
+            Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("cs-CZ");
+        }
         private const string TestUserJson = "{\r\n" +
                                             "    \"@odata.context\": \"https://graph.microsoft.com/v1.0/$metadata#users/$entity\",\r\n" +
                                             "    \"@odata.id\": \"https://graph.microsoft.com/v2/dcd219dd-bc68-4b9b-bf0b-4a33a796be35/directoryObjects/48d31887-5fad-4d73-a9f5-3c356e68a038/Microsoft.DirectoryServices.User\",\r\n" +
diff --git a/tests/serialization/json/JsonSerializationWriterTests.cs b/tests/serialization/json/JsonSerializationWriterTests.cs
index 4246961d..a577d9a2 100644
--- a/tests/serialization/json/JsonSerializationWriterTests.cs
+++ b/tests/serialization/json/JsonSerializationWriterTests.cs
@@ -1,8 +1,10 @@
 using System;
 using System.Collections.Generic;
+using System.Globalization;
 using System.IO;
 using System.Text;
 using System.Text.Json;
+using System.Threading;
 using Microsoft.Kiota.Abstractions;
 using Microsoft.Kiota.Abstractions.Serialization;
 using Microsoft.Kiota.Serialization.Json.Tests.Converters;
@@ -13,6 +15,11 @@ namespace Microsoft.Kiota.Serialization.Json.Tests
 {
     public class JsonSerializationWriterTests
     {
+        public JsonSerializationWriterTests()
+        {
+            Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("cs-CZ");
+        }
+
         [Fact]
         public void WritesSampleObjectValue()
         {
@@ -323,5 +330,311 @@ public void WritesSampleObjectValueWithUntypedProperties()
                 "\"extra\":{\"createdDateTime\":\"2024-01-15T00:00:00\\u002B00:00\"}}";
             Assert.Equal(expectedString, serializedJsonString);
         }
+
+        [Fact]
+        public void WritesStringValue()
+        {
+            // Arrange
+            var value = "This is a string value";
+
+            using var jsonSerializationWriter = new JsonSerializationWriter();
+
+            // Act
+            jsonSerializationWriter.WriteStringValue(null, value);
+            var contentStream = jsonSerializationWriter.GetSerializedContent();
+            using var reader = new StreamReader(contentStream, Encoding.UTF8);
+            var serializedString = reader.ReadToEnd();
+
+            // Assert
+            Assert.Equal("\"This is a string value\"", serializedString);
+        }
+
+        [Fact]
+        public void StreamIsReadableAfterDispose()
+        {
+            // Arrange
+            var value = "This is a string value";
+
+            using var jsonSerializationWriter = new JsonSerializationWriter();
+
+            // Act
+            jsonSerializationWriter.WriteStringValue(null, value);
+            var contentStream = jsonSerializationWriter.GetSerializedContent();
+            // Dispose the writer
+            jsonSerializationWriter.Dispose();
+            using var reader = new StreamReader(contentStream, Encoding.UTF8);
+            var serializedString = reader.ReadToEnd();
+
+            // Assert
+            Assert.Equal("\"This is a string value\"", serializedString);
+        }
+
+        [Fact]
+        public void WriteBoolValue_IsWrittenCorrectly()
+        {
+            // Arrange
+            var value = true;
+
+            using var jsonSerializationWriter = new JsonSerializationWriter();
+
+            // Act
+            jsonSerializationWriter.WriteBoolValue(null, value);
+            var contentStream = jsonSerializationWriter.GetSerializedContent();
+            using var reader = new StreamReader(contentStream, Encoding.UTF8);
+            var serializedString = reader.ReadToEnd();
+
+            // Assert
+            Assert.Equal("true", serializedString);
+        }
+
+        [Fact]
+        public void WriteByteArrayValue_IsWrittenCorrectly()
+        {
+            // Arrange
+            var value = new byte[] { 2, 4, 6 };
+
+            using var jsonSerializationWriter = new JsonSerializationWriter();
+
+            // Act
+            jsonSerializationWriter.WriteByteArrayValue(null, value);
+            var contentStream = jsonSerializationWriter.GetSerializedContent();
+            using var reader = new StreamReader(contentStream, Encoding.UTF8);
+            var serializedString = reader.ReadToEnd();
+
+            // Assert
+            Assert.Equal("\"AgQG\"", serializedString);
+        }
+
+        [Fact]
+        public void WriteByteValue_IsWrittenCorrectly()
+        {
+            // Arrange
+            byte value = 5;
+
+            using var jsonSerializationWriter = new JsonSerializationWriter();
+
+            // Act
+            jsonSerializationWriter.WriteByteValue(null, value);
+            var contentStream = jsonSerializationWriter.GetSerializedContent();
+            using var reader = new StreamReader(contentStream, Encoding.UTF8);
+            var serializedString = reader.ReadToEnd();
+
+            // Assert
+            Assert.Equal("5", serializedString);
+        }
+
+        [Fact]
+        public void WriteDateTimeOffsetValue_IsWrittenCorrectly()
+        {
+            // Arrange
+            var value = new DateTimeOffset(2024, 11, 30, 15, 35, 45, 987, TimeSpan.FromHours(3));
+
+            using var jsonSerializationWriter = new JsonSerializationWriter();
+
+            // Act
+            jsonSerializationWriter.WriteDateTimeOffsetValue(null, value);
+            var contentStream = jsonSerializationWriter.GetSerializedContent();
+            using var reader = new StreamReader(contentStream, Encoding.UTF8);
+            var serializedString = reader.ReadToEnd();
+
+            // Assert
+            Assert.Equal("\"2024-11-30T15:35:45.987+03:00\"", serializedString);
+        }
+
+        [Fact]
+        public void WriteDateValue_IsWrittenCorrectly()
+        {
+            // Arrange
+            var value = new Date(2024, 11, 30);
+
+            using var jsonSerializationWriter = new JsonSerializationWriter();
+
+            // Act
+            jsonSerializationWriter.WriteDateValue(null, value);
+            var contentStream = jsonSerializationWriter.GetSerializedContent();
+            using var reader = new StreamReader(contentStream, Encoding.UTF8);
+            var serializedString = reader.ReadToEnd();
+
+            // Assert
+            Assert.Equal("\"2024-11-30\"", serializedString);
+        }
+
+        [Fact]
+        public void WriteDecimalValue_IsWrittenCorrectly()
+        {
+            // Arrange
+            var value = 36.8m;
+
+            using var jsonSerializationWriter = new JsonSerializationWriter();
+
+            // Act
+            jsonSerializationWriter.WriteDecimalValue(null, value);
+            var contentStream = jsonSerializationWriter.GetSerializedContent();
+            using var reader = new StreamReader(contentStream, Encoding.UTF8);
+            var serializedString = reader.ReadToEnd();
+
+            // Assert
+            Assert.Equal("36.8", serializedString);
+        }
+
+        [Fact]
+        public void WriteDoubleValue_IsWrittenCorrectly()
+        {
+            // Arrange
+            var value = 36.8d;
+
+            using var jsonSerializationWriter = new JsonSerializationWriter();
+
+            // Act
+            jsonSerializationWriter.WriteDoubleValue(null, value);
+            var contentStream = jsonSerializationWriter.GetSerializedContent();
+            using var reader = new StreamReader(contentStream, Encoding.UTF8);
+            var serializedString = reader.ReadToEnd();
+
+            // Assert
+            Assert.Equal("36.8", serializedString);
+        }
+
+        [Fact]
+        public void WriteFloatValue_IsWrittenCorrectly()
+        {
+            // Arrange
+            var value = 36.8f;
+
+            using var jsonSerializationWriter = new JsonSerializationWriter();
+
+            // Act
+            jsonSerializationWriter.WriteFloatValue(null, value);
+            var contentStream = jsonSerializationWriter.GetSerializedContent();
+            using var reader = new StreamReader(contentStream, Encoding.UTF8);
+            var serializedString = reader.ReadToEnd();
+
+            // Assert
+            Assert.Equal("36.8", serializedString);
+        }
+
+        [Fact]
+        public void WriteGuidValue_IsWrittenCorrectly()
+        {
+            // Arrange
+            var value = new Guid("3adeb301-58f1-45c5-b820-ae5f4af13c89");
+
+            using var jsonSerializationWriter = new JsonSerializationWriter();
+
+            // Act
+            jsonSerializationWriter.WriteGuidValue(null, value);
+            var contentStream = jsonSerializationWriter.GetSerializedContent();
+            using var reader = new StreamReader(contentStream, Encoding.UTF8);
+            var serializedString = reader.ReadToEnd();
+
+            // Assert
+            Assert.Equal("\"3adeb301-58f1-45c5-b820-ae5f4af13c89\"", serializedString);
+        }
+
+        [Fact]
+        public void WriteIntegerValue_IsWrittenCorrectly()
+        {
+            // Arrange
+            var value = 25;
+
+            using var jsonSerializationWriter = new JsonSerializationWriter();
+
+            // Act
+            jsonSerializationWriter.WriteIntValue(null, value);
+            var contentStream = jsonSerializationWriter.GetSerializedContent();
+            using var reader = new StreamReader(contentStream, Encoding.UTF8);
+            var serializedString = reader.ReadToEnd();
+
+            // Assert
+            Assert.Equal("25", serializedString);
+        }
+
+        [Fact]
+        public void WriteLongValue_IsWrittenCorrectly()
+        {
+            // Arrange
+            var value = long.MaxValue;
+
+            using var jsonSerializationWriter = new JsonSerializationWriter();
+
+            // Act
+            jsonSerializationWriter.WriteLongValue(null, value);
+            var contentStream = jsonSerializationWriter.GetSerializedContent();
+            using var reader = new StreamReader(contentStream, Encoding.UTF8);
+            var serializedString = reader.ReadToEnd();
+
+            // Assert
+            Assert.Equal("9223372036854775807", serializedString);
+        }
+
+        [Fact]
+        public void WriteNullValue_IsWrittenCorrectly()
+        {
+            // Arrange
+            using var jsonSerializationWriter = new JsonSerializationWriter();
+
+            // Act
+            jsonSerializationWriter.WriteNullValue(null);
+            var contentStream = jsonSerializationWriter.GetSerializedContent();
+            using var reader = new StreamReader(contentStream, Encoding.UTF8);
+            var serializedString = reader.ReadToEnd();
+
+            // Assert
+            Assert.Equal("null", serializedString);
+        }
+
+        [Fact]
+        public void WriteSByteValue_IsWrittenCorrectly()
+        {
+            // Arrange
+            var value = sbyte.MaxValue;
+
+            using var jsonSerializationWriter = new JsonSerializationWriter();
+
+            // Act
+            jsonSerializationWriter.WriteSbyteValue(null, value);
+            var contentStream = jsonSerializationWriter.GetSerializedContent();
+            using var reader = new StreamReader(contentStream, Encoding.UTF8);
+            var serializedString = reader.ReadToEnd();
+
+            // Assert
+            Assert.Equal("127", serializedString);
+        }
+
+        [Fact]
+        public void WriteTimeValue_IsWrittenCorrectly()
+        {
+            // Arrange
+            var value = new Time(23, 46, 59);
+
+            using var jsonSerializationWriter = new JsonSerializationWriter();
+
+            // Act
+            jsonSerializationWriter.WriteTimeValue(null, value);
+            var contentStream = jsonSerializationWriter.GetSerializedContent();
+            using var reader = new StreamReader(contentStream, Encoding.UTF8);
+            var serializedString = reader.ReadToEnd();
+
+            // Assert
+            Assert.Equal("\"23:46:59\"", serializedString);
+        }
+
+        [Fact]
+        public void WriteTimeSpanValue_IsWrittenCorrectly()
+        {
+            // Arrange
+            var value = new TimeSpan(756, 4, 6, 8, 10);
+
+            using var jsonSerializationWriter = new JsonSerializationWriter();
+
+            // Act
+            jsonSerializationWriter.WriteTimeSpanValue(null, value);
+            var contentStream = jsonSerializationWriter.GetSerializedContent();
+            using var reader = new StreamReader(contentStream, Encoding.UTF8);
+            var serializedString = reader.ReadToEnd();
+
+            // Assert
+            Assert.Equal("\"P756DT4H6M8.01S\"", serializedString);
+        }
     }
 }
diff --git a/tests/serialization/text/Microsoft.Kiota.Serialization.Text.Tests.csproj b/tests/serialization/text/Microsoft.Kiota.Serialization.Text.Tests.csproj
index 9075d22c..42035885 100644
--- a/tests/serialization/text/Microsoft.Kiota.Serialization.Text.Tests.csproj
+++ b/tests/serialization/text/Microsoft.Kiota.Serialization.Text.Tests.csproj
@@ -12,6 +12,7 @@
     </PackageReference>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.10.0" />
     <PackageReference Include="Microsoft.TestPlatform.ObjectModel" Version="17.10.0" />
+    <PackageReference Include="Moq" Version="4.20.70" />
     <PackageReference Include="xunit" Version="2.9.0" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.8.2">
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
diff --git a/tests/serialization/text/Mocks/TestEntity.cs b/tests/serialization/text/Mocks/TestEntity.cs
new file mode 100644
index 00000000..ef551a31
--- /dev/null
+++ b/tests/serialization/text/Mocks/TestEntity.cs
@@ -0,0 +1,12 @@
+using System;
+using System.Collections.Generic;
+using Microsoft.Kiota.Abstractions.Serialization;
+
+namespace Microsoft.Kiota.Serialization.Text.Tests.Mocks
+{
+    public class TestEntity : IParsable
+    {
+        public IDictionary<string, Action<IParseNode>> GetFieldDeserializers() => throw new NotImplementedException();
+        public void Serialize(ISerializationWriter writer) => throw new NotImplementedException();
+    }
+}
diff --git a/tests/serialization/text/Mocks/TestEnum.cs b/tests/serialization/text/Mocks/TestEnum.cs
index 7ad801d7..ce83dd39 100644
--- a/tests/serialization/text/Mocks/TestEnum.cs
+++ b/tests/serialization/text/Mocks/TestEnum.cs
@@ -5,8 +5,8 @@ namespace Microsoft.Kiota.Serialization.Text.Tests.Mocks
     public enum TestEnum
     {
         [EnumMember(Value = "Value_1")]
-        First,
+        FirstItem,
         [EnumMember(Value = "Value_2")]
-        Second,
+        SecondItem,
     }
 }
diff --git a/tests/serialization/text/TextParseNodeFactoryTests.cs b/tests/serialization/text/TextParseNodeFactoryTests.cs
new file mode 100644
index 00000000..e7e45acf
--- /dev/null
+++ b/tests/serialization/text/TextParseNodeFactoryTests.cs
@@ -0,0 +1,82 @@
+using System;
+using System.IO;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace Microsoft.Kiota.Serialization.Text.Tests
+{
+    public class TextParseNodeFactoryTests
+    {
+        [Fact]
+        public void GetRootParseNode_ThrowsArgumentNullException_WhenContentTypeIsNull()
+        {
+            // Arrange
+            var factory = new TextParseNodeFactory();
+            string? contentType = null;
+            using var content = new MemoryStream();
+
+            // Act and Assert
+            Assert.Throws<ArgumentNullException>(() => factory.GetRootParseNode(contentType!, content));
+        }
+
+        [Fact]
+        public void GetRootParseNode_ThrowsArgumentOutOfRangeException_WhenContentTypeIsInvalid()
+        {
+            // Arrange
+            var factory = new TextParseNodeFactory();
+            string contentType = "application/json";
+            using var content = new MemoryStream();
+
+            // Act and Assert
+            Assert.Throws<ArgumentOutOfRangeException>(() => factory.GetRootParseNode(contentType, content));
+        }
+
+        [Fact]
+        public void GetRootParseNode_ThrowsArgumentNullException_WhenContentIsNull()
+        {
+            // Arrange
+            var factory = new TextParseNodeFactory();
+            string contentType = "text/plain";
+            Stream? content = null;
+
+            // Act and Assert
+            Assert.Throws<ArgumentNullException>(() => factory.GetRootParseNode(contentType, content!));
+        }
+
+        [Fact]
+        public async Task GetRootParseNodeAsync_ThrowsArgumentNullException_WhenContentTypeIsNull()
+        {
+            // Arrange
+            var factory = new TextParseNodeFactory();
+            string? contentType = null;
+            using var content = new MemoryStream();
+
+            // Act and Assert
+            await Assert.ThrowsAsync<ArgumentNullException>(() => factory.GetRootParseNodeAsync(contentType!, content));
+        }
+
+        [Fact]
+        public async Task GetRootParseNodeAsync_ThrowsArgumentOutOfRangeException_WhenContentTypeIsInvalid()
+        {
+            // Arrange
+            var factory = new TextParseNodeFactory();
+            string contentType = "application/json";
+            using var content = new MemoryStream();
+
+            // Act and Assert
+            await Assert.ThrowsAsync<ArgumentOutOfRangeException>(() => factory.GetRootParseNodeAsync(contentType, content));
+        }
+
+        [Fact]
+        public async Task GetRootParseNodeAsync_ThrowsArgumentNullException_WhenContentIsNull()
+        {
+            // Arrange
+            var factory = new TextParseNodeFactory();
+            string contentType = "text/plain";
+            Stream? content = null;
+
+            // Act and Assert
+            await Assert.ThrowsAsync<ArgumentNullException>(() => factory.GetRootParseNodeAsync(contentType, content!));
+        }
+    }
+}
diff --git a/tests/serialization/text/TextParseNodeTests.cs b/tests/serialization/text/TextParseNodeTests.cs
index e2edb883..5c0860fe 100644
--- a/tests/serialization/text/TextParseNodeTests.cs
+++ b/tests/serialization/text/TextParseNodeTests.cs
@@ -1,10 +1,21 @@
-using Microsoft.Kiota.Serialization.Text.Tests.Mocks;
+using System;
+using System.Globalization;
+using System.Threading;
+using Microsoft.Kiota.Abstractions;
+using Microsoft.Kiota.Abstractions.Serialization;
+using Microsoft.Kiota.Serialization.Text.Tests.Mocks;
+using Moq;
 using Xunit;
 
 namespace Microsoft.Kiota.Serialization.Text.Tests
 {
     public class TextParseNodeTests
     {
+        public TextParseNodeTests()
+        {
+            Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("cs-CZ");
+        }
+
         [Fact]
         public void TextParseNode_GetEnumFromInteger()
         {
@@ -13,18 +24,18 @@ public void TextParseNode_GetEnumFromInteger()
 
             var result = parseNode.GetEnumValue<TestEnum>();
 
-            Assert.Equal(TestEnum.Second, result);
+            Assert.Equal(TestEnum.SecondItem, result);
         }
 
         [Fact]
         public void TextParseNode_GetEnumFromString()
         {
-            var text = "First";
+            var text = "FirstItem";
             var parseNode = new TextParseNode(text);
 
             var result = parseNode.GetEnumValue<TestEnum>();
 
-            Assert.Equal(TestEnum.First, result);
+            Assert.Equal(TestEnum.FirstItem, result);
         }
 
         [Fact]
@@ -35,7 +46,199 @@ public void TextParseNode_GetEnumFromEnumMember()
 
             var result = parseNode.GetEnumValue<TestEnum>();
 
-            Assert.Equal(TestEnum.Second, result);
+            Assert.Equal(TestEnum.SecondItem, result);
+        }
+
+        [Fact]
+        public void TextParseNode_GetBoolValue()
+        {
+            var text = "true";
+            var parseNode = new TextParseNode(text);
+
+            var result = parseNode.GetBoolValue();
+
+            Assert.True(result);
+        }
+
+        [Fact]
+        public void TextParseNode_GetByteArrayValue()
+        {
+            var text = "dGV4dA==";
+            var parseNode = new TextParseNode(text);
+
+            var result = parseNode.GetByteArrayValue();
+
+            Assert.Equal(new byte[] { 0x74, 0x65, 0x78, 0x74 }, result);
+        }
+
+        [Fact]
+        public void TextParseNode_GetByteValue()
+        {
+            var text = "1";
+            var parseNode = new TextParseNode(text);
+
+            var result = parseNode.GetByteValue();
+            
+            Assert.Equal((byte)1, result);
+        }
+
+        [Fact]
+        public void TextParseNode_GetDateTimeOffsetValue()
+        {
+            var text = "2021-11-30T12:24:36+03:00";
+            var parseNode = new TextParseNode(text);
+
+            var result = parseNode.GetDateTimeOffsetValue();
+
+            Assert.Equal(new DateTimeOffset(2021, 11, 30, 12, 24, 36, TimeSpan.FromHours(3)), result);
+        }
+
+        [Fact]
+        public void TextParseNode_GetDateValue()
+        {
+            var text = "2021-11-30";
+            var parseNode = new TextParseNode(text);
+
+            var result = parseNode.GetDateValue();
+
+            Assert.Equal(new Date(2021, 11, 30), result);
+        }
+
+        [Fact]
+        public void TextParseNode_GetTimeSpanValue()
+        {
+            var text = "P756DT4H6M8.01S";
+            var parseNode = new TextParseNode(text);
+
+            var result = parseNode.GetTimeSpanValue();
+
+            Assert.Equal(new TimeSpan(756, 4, 6, 8, 10), result);
+        }
+
+        [Fact]
+        public void TextParseNode_GetTimeValue()
+        {
+            var text = "12:24:36";
+            var parseNode = new TextParseNode(text);
+
+            var result = parseNode.GetTimeValue();
+
+            Assert.Equal(new Time(12, 24, 36), result);
+        }
+
+        [Fact]
+        public void TextParseNode_GetGuidValue()
+        {
+            var text = "f4b3b8f4-6f4d-4f1f-8f4d-8f4b3b8f4d1f";
+            var parseNode = new TextParseNode(text);
+
+            var result = parseNode.GetGuidValue();
+
+            Assert.Equal(new Guid("f4b3b8f4-6f4d-4f1f-8f4d-8f4b3b8f4d1f"), result);
+        }
+
+        [Fact]
+        public void TextParseNode_GetIntValue()
+        {
+            var text = "1";
+            var parseNode = new TextParseNode(text);
+
+            var result = parseNode.GetIntValue();
+
+            Assert.Equal(1, result);
+        }
+
+        [Fact]
+        public void TextParseNode_GetLongValue()
+        {
+            var text = "1";
+            var parseNode = new TextParseNode(text);
+
+            var result = parseNode.GetLongValue();
+
+            Assert.Equal(1L, result);
+        }
+
+        [Fact]
+        public void TextParseNode_GetSbyteValue()
+        {
+            var text = "1";
+            var parseNode = new TextParseNode(text);
+
+            var result = parseNode.GetSbyteValue();
+
+            Assert.Equal((sbyte)1, result);
+        }
+
+        [Fact]
+        public void TextParseNode_GetStringValue()
+        {
+            var text = "text";
+            var parseNode = new TextParseNode(text);
+
+            var result = parseNode.GetStringValue();
+
+            Assert.Equal("text", result);
+        }
+
+        [Fact]
+        public void TextParseNode_GetDecimalValue()
+        {
+            var text = "1.1";
+            var parseNode = new TextParseNode(text);
+
+            var result = parseNode.GetDecimalValue();
+
+            Assert.Equal(1.1m, result);
+        }
+
+        [Fact]
+        public void TextParseNode_GetDoubleValue()
+        {
+            var text = "1.1";
+            var parseNode = new TextParseNode(text);
+
+            var result = parseNode.GetDoubleValue();
+
+            Assert.Equal(1.1, result);
+        }
+
+        [Fact]
+        public void TextParseNode_GetFloatValue()
+        {
+            var text = "1.1";
+            var parseNode = new TextParseNode(text);
+
+            var result = parseNode.GetFloatValue();
+
+            Assert.Equal(1.1f, result);
+        }
+
+        [Fact]
+        public void TextParseNode_GetCollectionOfPrimitiveValues()
+        {
+            var text = "1,2,3";
+            var parseNode = new TextParseNode(text);
+
+            Assert.Throws<InvalidOperationException>(parseNode.GetCollectionOfPrimitiveValues<int>);
+        }
+
+        [Fact]
+        public void TextParseNode_GetCollectionOfObjectValues()
+        {
+            var text = "xxx";
+            var parseNode = new TextParseNode(text);
+
+            Assert.Throws<InvalidOperationException>(() => parseNode.GetCollectionOfObjectValues(It.IsAny<ParsableFactory<TestEntity>>()));
+        }
+
+        [Fact]
+        public void TextParseNode_GetCollectionOfEnumValues()
+        {
+            var text = "xxx";
+            var parseNode = new TextParseNode(text);
+
+            Assert.Throws<InvalidOperationException>(parseNode.GetCollectionOfEnumValues<TestEnum>);
         }
     }
 }
diff --git a/tests/serialization/text/TextSerializationWriterFactoryTests.cs b/tests/serialization/text/TextSerializationWriterFactoryTests.cs
new file mode 100644
index 00000000..bc2d2de2
--- /dev/null
+++ b/tests/serialization/text/TextSerializationWriterFactoryTests.cs
@@ -0,0 +1,36 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace Microsoft.Kiota.Serialization.Text.Tests
+{
+    public class TextSerializationWriterFactoryTests
+    {
+        [Fact]
+        public void TextSerializationWriterFactory_GetSerializationWriter()
+        {
+            var factory = new TextSerializationWriterFactory();
+            var writer = factory.GetSerializationWriter("text/plain");
+            Assert.NotNull(writer);
+        }
+
+        [Theory]
+        [InlineData("")]
+        [InlineData(null)]
+        public void TextSerializationWriterFactory_GetSerializationWriter_ThrowsOnNullContentType(string? contentType)
+        {
+            var factory = new TextSerializationWriterFactory();
+            Assert.Throws<ArgumentNullException>(() => factory.GetSerializationWriter(contentType!));
+        }
+
+        [Fact]
+        public void TextSerializationWriterFactory_GetSerializationWriter_ThrowsOnInvalidContentType()
+        {
+            var factory = new TextSerializationWriterFactory();
+            Assert.Throws<ArgumentOutOfRangeException>(() => factory.GetSerializationWriter("application/json"));
+        }
+    }
+}
diff --git a/tests/serialization/text/TextSerializationWriterTests.cs b/tests/serialization/text/TextSerializationWriterTests.cs
index 02846b24..480ddaef 100644
--- a/tests/serialization/text/TextSerializationWriterTests.cs
+++ b/tests/serialization/text/TextSerializationWriterTests.cs
@@ -1,11 +1,22 @@
+using Microsoft.Kiota.Abstractions;
+using Microsoft.Kiota.Serialization.Text.Tests.Mocks;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
 using System.IO;
 using System.Text;
+using System.Threading;
 using Xunit;
 
 namespace Microsoft.Kiota.Serialization.Text.Tests;
 
 public class TextSerializationWriterTests
 {
+    public TextSerializationWriterTests()
+    {
+        Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("cs-CZ");
+    }
+
     [Fact]
     public void WritesStringValue()
     {
@@ -43,4 +54,314 @@ public void StreamIsReadableAfterDispose()
         // Assert
         Assert.Equal(value, serializedString);
     }
+
+    [Fact]
+    public void WriteBoolValue_IsWrittenCorrectly()
+    {
+        // Arrange
+        var value = true;
+
+        using var textSerializationWriter = new TextSerializationWriter();
+
+        // Act
+        textSerializationWriter.WriteBoolValue(null, value);
+        var contentStream = textSerializationWriter.GetSerializedContent();
+        using var reader = new StreamReader(contentStream, Encoding.UTF8);
+        var serializedString = reader.ReadToEnd();
+
+        // Assert
+        Assert.Equal("True", serializedString);
+    }
+
+    [Fact]
+    public void WriteByteArrayValue_IsWrittenCorrectly()
+    {
+        // Arrange
+        var value = new byte[] { 2, 4, 6 };
+
+        using var textSerializationWriter = new TextSerializationWriter();
+
+        // Act
+        textSerializationWriter.WriteByteArrayValue(null, value);
+        var contentStream = textSerializationWriter.GetSerializedContent();
+        using var reader = new StreamReader(contentStream, Encoding.UTF8);
+        var serializedString = reader.ReadToEnd();
+
+        // Assert
+        Assert.Equal("AgQG", serializedString);
+    }
+
+    [Fact]
+    public void WriteByteValue_IsWrittenCorrectly()
+    {
+        // Arrange
+        byte value = 5;
+
+        using var textSerializationWriter = new TextSerializationWriter();
+
+        // Act
+        textSerializationWriter.WriteByteValue(null, value);
+        var contentStream = textSerializationWriter.GetSerializedContent();
+        using var reader = new StreamReader(contentStream, Encoding.UTF8);
+        var serializedString = reader.ReadToEnd();
+
+        // Assert
+        Assert.Equal("5", serializedString);
+    }
+
+    [Fact]
+    public void WriteDateTimeOffsetValue_IsWrittenCorrectly()
+    {
+        // Arrange
+        var value = new DateTimeOffset(2024,11,30,15,35,45,987, TimeSpan.FromHours(3));
+
+        using var textSerializationWriter = new TextSerializationWriter();
+
+        // Act
+        textSerializationWriter.WriteDateTimeOffsetValue(null, value);
+        var contentStream = textSerializationWriter.GetSerializedContent();
+        using var reader = new StreamReader(contentStream, Encoding.UTF8);
+        var serializedString = reader.ReadToEnd();
+
+        // Assert
+        Assert.Equal("2024-11-30T15:35:45.9870000+03:00", serializedString);
+    }
+
+    [Fact]
+    public void WriteDateValue_IsWrittenCorrectly()
+    {
+        // Arrange
+        var value = new Date(2024, 11, 30);
+
+        using var textSerializationWriter = new TextSerializationWriter();
+
+        // Act
+        textSerializationWriter.WriteDateValue(null, value);
+        var contentStream = textSerializationWriter.GetSerializedContent();
+        using var reader = new StreamReader(contentStream, Encoding.UTF8);
+        var serializedString = reader.ReadToEnd();
+
+        // Assert
+        Assert.Equal("2024-11-30", serializedString);
+    }
+
+    [Fact]
+    public void WriteDecimalValue_IsWrittenCorrectly()
+    {
+        // Arrange
+        var value = 36.8m;
+
+        using var textSerializationWriter = new TextSerializationWriter();
+
+        // Act
+        textSerializationWriter.WriteDecimalValue(null, value);
+        var contentStream = textSerializationWriter.GetSerializedContent();
+        using var reader = new StreamReader(contentStream, Encoding.UTF8);
+        var serializedString = reader.ReadToEnd();
+
+        // Assert
+        Assert.Equal("36.8", serializedString);
+    }
+
+    [Fact]
+    public void WriteDoubleValue_IsWrittenCorrectly()
+    {
+        // Arrange
+        var value = 36.8d;
+
+        using var textSerializationWriter = new TextSerializationWriter();
+
+        // Act
+        textSerializationWriter.WriteDoubleValue(null, value);
+        var contentStream = textSerializationWriter.GetSerializedContent();
+        using var reader = new StreamReader(contentStream, Encoding.UTF8);
+        var serializedString = reader.ReadToEnd();
+
+        // Assert
+        Assert.Equal("36.8", serializedString);
+    }
+
+    [Fact]
+    public void WriteFloatValue_IsWrittenCorrectly()
+    {
+        // Arrange
+        var value = 36.8f;
+
+        using var textSerializationWriter = new TextSerializationWriter();
+
+        // Act
+        textSerializationWriter.WriteFloatValue(null, value);
+        var contentStream = textSerializationWriter.GetSerializedContent();
+        using var reader = new StreamReader(contentStream, Encoding.UTF8);
+        var serializedString = reader.ReadToEnd();
+
+        // Assert
+        Assert.Equal("36.8", serializedString);
+    }
+
+    [Fact]
+    public void WriteGuidValue_IsWrittenCorrectly()
+    {
+        // Arrange
+        var value = new Guid("3adeb301-58f1-45c5-b820-ae5f4af13c89");
+
+        using var textSerializationWriter = new TextSerializationWriter();
+
+        // Act
+        textSerializationWriter.WriteGuidValue(null, value);
+        var contentStream = textSerializationWriter.GetSerializedContent();
+        using var reader = new StreamReader(contentStream, Encoding.UTF8);
+        var serializedString = reader.ReadToEnd();
+
+        // Assert
+        Assert.Equal("3adeb301-58f1-45c5-b820-ae5f4af13c89", serializedString);
+    }
+
+    [Fact]
+    public void WriteIntegerValue_IsWrittenCorrectly()
+    {
+        // Arrange
+        var value = 25;
+
+        using var textSerializationWriter = new TextSerializationWriter();
+
+        // Act
+        textSerializationWriter.WriteIntValue(null, value);
+        var contentStream = textSerializationWriter.GetSerializedContent();
+        using var reader = new StreamReader(contentStream, Encoding.UTF8);
+        var serializedString = reader.ReadToEnd();
+
+        // Assert
+        Assert.Equal("25", serializedString);
+    }
+
+    [Fact]
+    public void WriteLongValue_IsWrittenCorrectly()
+    {
+        // Arrange
+        var value = long.MaxValue;
+
+        using var textSerializationWriter = new TextSerializationWriter();
+
+        // Act
+        textSerializationWriter.WriteLongValue(null, value);
+        var contentStream = textSerializationWriter.GetSerializedContent();
+        using var reader = new StreamReader(contentStream, Encoding.UTF8);
+        var serializedString = reader.ReadToEnd();
+
+        // Assert
+        Assert.Equal("9223372036854775807", serializedString);
+    }
+
+    [Fact]
+    public void WriteNullValue_IsWrittenCorrectly()
+    {
+        // Arrange
+        using var textSerializationWriter = new TextSerializationWriter();
+
+        // Act
+        textSerializationWriter.WriteNullValue(null);
+        var contentStream = textSerializationWriter.GetSerializedContent();
+        using var reader = new StreamReader(contentStream, Encoding.UTF8);
+        var serializedString = reader.ReadToEnd();
+
+        // Assert
+        Assert.Equal("null", serializedString);
+    }
+
+    [Fact]
+    public void WriteSByteValue_IsWrittenCorrectly()
+    {
+        // Arrange
+        var value = sbyte.MaxValue;
+
+        using var textSerializationWriter = new TextSerializationWriter();
+
+        // Act
+        textSerializationWriter.WriteSbyteValue(null, value);
+        var contentStream = textSerializationWriter.GetSerializedContent();
+        using var reader = new StreamReader(contentStream, Encoding.UTF8);
+        var serializedString = reader.ReadToEnd();
+
+        // Assert
+        Assert.Equal("127", serializedString);
+    }
+
+    [Fact]
+    public void WriteTimeValue_IsWrittenCorrectly()
+    {
+        // Arrange
+        var value = new Time(23, 46, 59);
+
+        using var textSerializationWriter = new TextSerializationWriter();
+
+        // Act
+        textSerializationWriter.WriteTimeValue(null, value);
+        var contentStream = textSerializationWriter.GetSerializedContent();
+        using var reader = new StreamReader(contentStream, Encoding.UTF8);
+        var serializedString = reader.ReadToEnd();
+
+        // Assert
+        Assert.Equal("23:46:59", serializedString);
+    }
+
+    [Fact]
+    public void WriteTimeSpanValue_IsWrittenCorrectly()
+    {
+        // Arrange
+        var value = new TimeSpan(756, 4, 6, 8, 10);
+
+        using var textSerializationWriter = new TextSerializationWriter();
+
+        // Act
+        textSerializationWriter.WriteTimeSpanValue(null, value);
+        var contentStream = textSerializationWriter.GetSerializedContent();
+        using var reader = new StreamReader(contentStream, Encoding.UTF8);
+        var serializedString = reader.ReadToEnd();
+
+        // Assert
+        Assert.Equal("P756DT4H6M8.01S", serializedString);
+    }
+
+    [Fact]
+    public void WriteAdditionalData_ThrowsInvalidOperationException()
+    {
+        // Arrange
+        var additionalData = new Dictionary<string, object>();
+
+        using var textSerializationWriter = new TextSerializationWriter();
+
+        // Act and Assert
+        Assert.Throws<InvalidOperationException>(() => textSerializationWriter.WriteAdditionalData(additionalData));
+    }
+
+    [Fact]
+    public void WriteEnumValue_IsWrittenCorrectly()
+    {
+        // Arrange
+        var value = TestEnum.FirstItem;
+
+        using var textSerializationWriter = new TextSerializationWriter();
+
+        // Act
+        textSerializationWriter.WriteEnumValue<TestEnum>(null, value);
+        var contentStream = textSerializationWriter.GetSerializedContent();
+        using var reader = new StreamReader(contentStream, Encoding.UTF8);
+        var serializedString = reader.ReadToEnd();
+
+        // Assert
+        Assert.Equal("firstItem", serializedString);
+    }
+
+    [Fact]
+    public void WriteCollectionOfEnumValues_ThrowsInvalidOperationException()
+    {
+        // Arrange
+        var value = new List<TestEnum?> { TestEnum.FirstItem, TestEnum.SecondItem };
+
+        using var textSerializationWriter = new TextSerializationWriter();
+
+        // Act and Assert
+        Assert.Throws<InvalidOperationException>(() => textSerializationWriter.WriteCollectionOfEnumValues(null, value));
+    }
 }
diff --git a/tests/serialization/text/UnitTest1.cs b/tests/serialization/text/UnitTest1.cs
deleted file mode 100644
index af7f54cc..00000000
--- a/tests/serialization/text/UnitTest1.cs
+++ /dev/null
@@ -1,12 +0,0 @@
-using Xunit;
-
-namespace Microsoft.Kiota.Serialization.Text.Tests;
-
-public class UnitTest1
-{
-    [Fact]
-    public void Test1()
-    {
-
-    }
-}
\ No newline at end of file

From cc8c81330e5565cade4e13f04cc0b54ee6bc9c6c Mon Sep 17 00:00:00 2001
From: Martin Machacek <machacek@edhouse.cz>
Date: Tue, 16 Jul 2024 16:04:49 +0200
Subject: [PATCH 2/7] Use invariant culture for (de)serialization

---
 src/serialization/json/JsonParseNode.cs       | 29 ++++++++++++-------
 .../serialization/json/JsonParseNodeTests.cs  |  4 +--
 2 files changed, 21 insertions(+), 12 deletions(-)

diff --git a/src/serialization/json/JsonParseNode.cs b/src/serialization/json/JsonParseNode.cs
index 51c87128..118b4d4d 100644
--- a/src/serialization/json/JsonParseNode.cs
+++ b/src/serialization/json/JsonParseNode.cs
@@ -14,6 +14,7 @@
 using Microsoft.Kiota.Abstractions.Extensions;
 using Microsoft.Kiota.Abstractions.Helpers;
 using Microsoft.Kiota.Abstractions.Serialization;
+using System.Text.Json.Serialization.Metadata;
 
 #if NET5_0_OR_GREATER
 using System.Diagnostics.CodeAnalysis;
@@ -149,17 +150,11 @@ public JsonParseNode(JsonElement node, KiotaJsonSerializationContext jsonSeriali
             if(_jsonNode.ValueKind != JsonValueKind.String)
                 return null;
 
-            if(_jsonNode.TryGetDateTimeOffset(out var dateTimeOffset))
+            if(TryGetUsingTypeInfo(_jsonNode, _jsonSerializerContext.DateTimeOffset, out var dateTimeOffset))
                 return dateTimeOffset;
-
-            var dateTimeOffsetStr = _jsonNode.GetString();
-            if(string.IsNullOrEmpty(dateTimeOffsetStr))
-                return null;
-
-            if(DateTimeOffset.TryParse(dateTimeOffsetStr, CultureInfo.InvariantCulture, DateTimeStyles.None, out dateTimeOffset))
-                return dateTimeOffset;
-
-            return _jsonNode.Deserialize(_jsonSerializerContext.DateTimeOffset);
+            else if(DateTimeOffset.TryParse(_jsonNode.GetString(), CultureInfo.InvariantCulture, DateTimeStyles.None, out var dto))
+                return dto;
+            else return null;
         }
 
         /// <summary>
@@ -582,5 +577,19 @@ private static string ToEnumRawName<T>(string value) where T : struct, Enum
 
             return value;
         }
+
+        private static bool TryGetUsingTypeInfo<T>(JsonElement currentElement, JsonTypeInfo<T>? typeInfo, out T? deserializedValue)
+        {
+            try
+            {
+                deserializedValue = currentElement.Deserialize(typeInfo!);
+                return true;
+            }
+            catch(Exception)
+            {
+                deserializedValue = default;
+                return false;
+            }
+        }
     }
 }
diff --git a/tests/serialization/json/JsonParseNodeTests.cs b/tests/serialization/json/JsonParseNodeTests.cs
index eca6595f..f8abae52 100644
--- a/tests/serialization/json/JsonParseNodeTests.cs
+++ b/tests/serialization/json/JsonParseNodeTests.cs
@@ -28,7 +28,7 @@ public JsonParseNodeTests()
                                             "    \"testNamingEnum\":\"Item2:SubItem1\"," +
                                             "    \"givenName\": \"Megan\",\r\n" +
                                             "    \"accountEnabled\": true,\r\n" +
-                                            "    \"createdDateTime\": \"2017 -07-29T03:07:25Z\",\r\n" +
+                                            "    \"createdDateTime\": \"2017-07-29T03:07:25Z\",\r\n" +
                                             "    \"jobTitle\": \"Auditor\",\r\n" +
                                             "    \"mail\": \"MeganB@M365x214355.onmicrosoft.com\",\r\n" +
                                             "    \"mobilePhone\": null,\r\n" +
@@ -54,7 +54,7 @@ public JsonParseNodeTests()
                                             "    \"testNamingEnum\":\"Item2:SubItem1\"," +
                                             "    \"givenName\": \"Megan\",\r\n" +
                                             "    \"accountEnabled\": true,\r\n" +
-                                            "    \"createdDateTime\": \"2017 -07-29T03:07:25Z\",\r\n" +
+                                            "    \"createdDateTime\": \"2017-07-29T03:07:25Z\",\r\n" +
                                             "    \"jobTitle\": \"Auditor\",\r\n" +
                                             "    \"mail\": \"MeganB@M365x214355.onmicrosoft.com\",\r\n" +
                                             "    \"mobilePhone\": null,\r\n" +

From 8421930dfc59eef2aee2e02cdfc7ee3b427cc85e Mon Sep 17 00:00:00 2001
From: Martin Machacek <machacek@edhouse.cz>
Date: Wed, 17 Jul 2024 09:22:46 +0200
Subject: [PATCH 3/7] Use invariant culture for (de)serialization

---
 src/abstractions/Time.cs                      |   5 +-
 src/serialization/form/FormParseNode.cs       |  17 +-
 src/serialization/json/JsonParseNode.cs       |   8 +-
 src/serialization/text/TextParseNode.cs       |   6 +-
 .../serialization/form/FormParseNodeTests.cs  |  59 +-
 .../serialization/text/TextParseNodeTests.cs  |   2 +-
 .../text/TextSerializationWriterTests.cs      | 711 +++++++++---------
 7 files changed, 432 insertions(+), 376 deletions(-)

diff --git a/src/abstractions/Time.cs b/src/abstractions/Time.cs
index ffbdeb44..a508bff0 100644
--- a/src/abstractions/Time.cs
+++ b/src/abstractions/Time.cs
@@ -3,14 +3,13 @@
 // ------------------------------------------------------------------------------
 
 using System;
-using System.Security;
 
 namespace Microsoft.Kiota.Abstractions
 {
     /// <summary>
     /// Model to represent only the date component of a DateTime
     /// </summary>
-    public struct Time:IEquatable<Time>
+    public struct Time : IEquatable<Time>
     {
 #if NET6_0_OR_GREATER
         /// <summary>
@@ -32,7 +31,7 @@ public struct Time:IEquatable<Time>
         /// </summary>
         /// <param name="other">An object to compare with this object.</param>
         /// <returns>true if the current object is equal to the other parameter; otherwise, false.</returns>
-        public bool Equals(Time other) => (Hour, Minute, Second) == (other.Hour, other.Minute, other.Second);
+        public bool Equals(Time other) => Hour == other.Hour && Minute == other.Minute && Second == other.Second;
 
         /// <inheritdoc />
         public override bool Equals(object? o) => (o is Time other) && Equals(other);
diff --git a/src/serialization/form/FormParseNode.cs b/src/serialization/form/FormParseNode.cs
index 09461b82..cc08f20c 100644
--- a/src/serialization/form/FormParseNode.cs
+++ b/src/serialization/form/FormParseNode.cs
@@ -2,7 +2,6 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Globalization;
-using System.Reflection;
 using System.Xml;
 using Microsoft.Kiota.Abstractions;
 using Microsoft.Kiota.Abstractions.Extensions;
@@ -144,9 +143,9 @@ public IEnumerable<T> GetCollectionOfPrimitiveValues<T>()
         }
     }
     /// <inheritdoc/>
-    public DateTimeOffset? GetDateTimeOffsetValue() => DateTimeOffset.TryParse(DecodedValue, CultureInfo.InvariantCulture, DateTimeStyles.None, out var result) ? result : null;
+    public DateTimeOffset? GetDateTimeOffsetValue() => DateTimeOffset.TryParse(DecodedValue, CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind, out var result) ? result : null;
     /// <inheritdoc/>
-    public Date? GetDateValue() => DateTime.TryParse(DecodedValue, CultureInfo.InvariantCulture, DateTimeStyles.None, out var result) ? new Date(result) : null;
+    public Date? GetDateValue() => DateTime.TryParse(DecodedValue, CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind, out var result) ? new Date(result) : null;
     /// <inheritdoc/>
     public decimal? GetDecimalValue() => decimal.TryParse(DecodedValue, NumberStyles.Number, CultureInfo.InvariantCulture, out var result) ? result : null;
     /// <inheritdoc/>
@@ -223,22 +222,24 @@ private void AssignFieldValues<T>(T item) where T : IParsable
     }
 
     /// <inheritdoc/>
-    public Time? GetTimeValue() => DateTime.TryParse(DecodedValue, CultureInfo.InvariantCulture, DateTimeStyles.None, out var result) ? new Time(result) : null;
+    public Time? GetTimeValue() => DateTime.TryParse(DecodedValue, CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind, out var result) ? new Time(result) : null;
 
+    /// <inheritdoc/>
 #if NET5_0_OR_GREATER
-    IEnumerable<T?> IParseNode.GetCollectionOfEnumValues<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicFields)] T>()
+    public IEnumerable<T?> GetCollectionOfEnumValues<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicFields)] T>() where T : struct, Enum
 #else
-    IEnumerable<T?> IParseNode.GetCollectionOfEnumValues<T>()
+    public IEnumerable<T?> GetCollectionOfEnumValues<T>() where T : struct, Enum
 #endif
     {
         foreach(var v in DecodedValue.Split(ComaSeparator, StringSplitOptions.RemoveEmptyEntries))
             yield return EnumHelpers.GetEnumValue<T>(v);
     }
 
+    /// <inheritdoc/>
 #if NET5_0_OR_GREATER
-    T? IParseNode.GetEnumValue<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicFields)] T>()
+    public T? GetEnumValue<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicFields)] T>() where T : struct, Enum
 #else
-    T? IParseNode.GetEnumValue<T>()
+    public T? GetEnumValue<T>() where T : struct, Enum
 #endif
     {
         return EnumHelpers.GetEnumValue<T>(DecodedValue);
diff --git a/src/serialization/json/JsonParseNode.cs b/src/serialization/json/JsonParseNode.cs
index 118b4d4d..3b400150 100644
--- a/src/serialization/json/JsonParseNode.cs
+++ b/src/serialization/json/JsonParseNode.cs
@@ -9,12 +9,12 @@
 using System.Reflection;
 using System.Runtime.Serialization;
 using System.Text.Json;
+using System.Text.Json.Serialization.Metadata;
 using System.Xml;
 using Microsoft.Kiota.Abstractions;
 using Microsoft.Kiota.Abstractions.Extensions;
 using Microsoft.Kiota.Abstractions.Helpers;
 using Microsoft.Kiota.Abstractions.Serialization;
-using System.Text.Json.Serialization.Metadata;
 
 #if NET5_0_OR_GREATER
 using System.Diagnostics.CodeAnalysis;
@@ -152,7 +152,7 @@ public JsonParseNode(JsonElement node, KiotaJsonSerializationContext jsonSeriali
 
             if(TryGetUsingTypeInfo(_jsonNode, _jsonSerializerContext.DateTimeOffset, out var dateTimeOffset))
                 return dateTimeOffset;
-            else if(DateTimeOffset.TryParse(_jsonNode.GetString(), CultureInfo.InvariantCulture, DateTimeStyles.None, out var dto))
+            else if(DateTimeOffset.TryParse(_jsonNode.GetString(), CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind, out var dto))
                 return dto;
             else return null;
         }
@@ -181,7 +181,7 @@ public JsonParseNode(JsonElement node, KiotaJsonSerializationContext jsonSeriali
             if(string.IsNullOrEmpty(dateString))
                 return null;
 
-            if(DateTime.TryParse(dateString, CultureInfo.InvariantCulture, DateTimeStyles.None, out var result))
+            if(DateTime.TryParse(dateString, CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind, out var result))
                 return new Date(result);
 
             return _jsonNode.Deserialize(_jsonSerializerContext.Date);
@@ -197,7 +197,7 @@ public JsonParseNode(JsonElement node, KiotaJsonSerializationContext jsonSeriali
             if(string.IsNullOrEmpty(dateString))
                 return null;
 
-            if(DateTime.TryParse(dateString, CultureInfo.InvariantCulture, DateTimeStyles.None, out var result))
+            if(DateTime.TryParse(dateString, CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind, out var result))
                 return new Time(result);
 
             return _jsonNode.Deserialize(_jsonSerializerContext.Time);
diff --git a/src/serialization/text/TextParseNode.cs b/src/serialization/text/TextParseNode.cs
index 505df103..9cc4bfe6 100644
--- a/src/serialization/text/TextParseNode.cs
+++ b/src/serialization/text/TextParseNode.cs
@@ -46,9 +46,9 @@ public TextParseNode(string? text)
     public IEnumerable<T> GetCollectionOfPrimitiveValues<T>() => throw new InvalidOperationException(NoStructuredDataMessage);
 #endif
     /// <inheritdoc />
-    public DateTimeOffset? GetDateTimeOffsetValue() => DateTimeOffset.TryParse(Text, CultureInfo.InvariantCulture, DateTimeStyles.None, out var result) ? result : null;
+    public DateTimeOffset? GetDateTimeOffsetValue() => DateTimeOffset.TryParse(Text, CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind, out var result) ? result : null;
     /// <inheritdoc />
-    public Date? GetDateValue() => DateTime.TryParse(Text, CultureInfo.InvariantCulture, DateTimeStyles.None, out var result) ? new Date(result) : null;
+    public Date? GetDateValue() => DateTime.TryParse(Text, CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind, out var result) ? new Date(result) : null;
     /// <inheritdoc />
     public decimal? GetDecimalValue() => decimal.TryParse(Text, NumberStyles.Number, CultureInfo.InvariantCulture, out var result) ? result : null;
     /// <inheritdoc />
@@ -70,7 +70,7 @@ public TextParseNode(string? text)
     /// <inheritdoc />
     public TimeSpan? GetTimeSpanValue() => string.IsNullOrEmpty(Text) ? null : XmlConvert.ToTimeSpan(Text);
     /// <inheritdoc />
-    public Time? GetTimeValue() => DateTime.TryParse(Text, CultureInfo.InvariantCulture, DateTimeStyles.None, out var result) ? new Time(result) : null;
+    public Time? GetTimeValue() => DateTime.TryParse(Text, CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind, out var result) ? new Time(result) : null;
     /// <inheritdoc />
 #if NET5_0_OR_GREATER
     public IEnumerable<T?> GetCollectionOfEnumValues<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicFields)] T>() where T : struct, Enum
diff --git a/tests/serialization/form/FormParseNodeTests.cs b/tests/serialization/form/FormParseNodeTests.cs
index 59325135..2bdefd72 100644
--- a/tests/serialization/form/FormParseNodeTests.cs
+++ b/tests/serialization/form/FormParseNodeTests.cs
@@ -157,9 +157,8 @@ public void FormParseNode_GetByteArrayValue()
 
         // Act
         var result = parseNode.GetByteArrayValue();
-
         // Assert
-        Assert.Equal(new byte []{ 0x74, 0x65, 0x78, 0x74 }, result);
+        Assert.Equal([0x74, 0x65, 0x78, 0x74], result);
     }
 
     [Fact]
@@ -343,4 +342,60 @@ public void FormParseNode_GetFloatValue()
         // Assert
         Assert.Equal(1.1f, result);
     }
+
+    [Fact]
+    public void FormParseNode_GetEnumFromInteger()
+    {
+        // Arange
+        var text = "8";
+        var parseNode = new FormParseNode(text);
+
+        // Act
+        var result = parseNode.GetEnumValue<TestEnum>();
+
+        // Assert
+        Assert.Equal(TestEnum.Eight, result);
+    }
+
+    [Fact]
+    public void FormParseNode_GetEnumFromString()
+    {
+        // Arange
+        var text = "Sixteen";
+        var parseNode = new FormParseNode(text);
+
+        // Act
+        var result = parseNode.GetEnumValue<TestEnum>();
+
+        // Assert
+        Assert.Equal(TestEnum.Sixteen, result);
+    }
+
+    [Fact]
+    public void FormParseNode_GetEnumsFromInteger()
+    {
+        // Arange
+        var text = "8,16";
+        var parseNode = new FormParseNode(text);
+
+        // Act
+        var result = parseNode.GetCollectionOfEnumValues<TestEnum>();
+
+        // Assert
+        Assert.Equal([TestEnum.Eight, TestEnum.Sixteen], result);
+    }
+
+    [Fact]
+    public void FormParseNode_GetEnumsFromString()
+    {
+        // Arange
+        var text = "Sixteen,Eight";
+        var parseNode = new FormParseNode(text);
+
+        // Act
+        var result = parseNode.GetCollectionOfEnumValues<TestEnum>();
+
+        // Assert
+        Assert.Equal([TestEnum.Sixteen, TestEnum.Eight], result);
+    }
 }
diff --git a/tests/serialization/text/TextParseNodeTests.cs b/tests/serialization/text/TextParseNodeTests.cs
index 5c0860fe..4ac1dbae 100644
--- a/tests/serialization/text/TextParseNodeTests.cs
+++ b/tests/serialization/text/TextParseNodeTests.cs
@@ -78,7 +78,7 @@ public void TextParseNode_GetByteValue()
             var parseNode = new TextParseNode(text);
 
             var result = parseNode.GetByteValue();
-            
+
             Assert.Equal((byte)1, result);
         }
 
diff --git a/tests/serialization/text/TextSerializationWriterTests.cs b/tests/serialization/text/TextSerializationWriterTests.cs
index 480ddaef..2a309712 100644
--- a/tests/serialization/text/TextSerializationWriterTests.cs
+++ b/tests/serialization/text/TextSerializationWriterTests.cs
@@ -1,367 +1,368 @@
-using Microsoft.Kiota.Abstractions;
-using Microsoft.Kiota.Serialization.Text.Tests.Mocks;
 using System;
 using System.Collections.Generic;
 using System.Globalization;
 using System.IO;
 using System.Text;
 using System.Threading;
+using Microsoft.Kiota.Abstractions;
+using Microsoft.Kiota.Serialization.Text.Tests.Mocks;
 using Xunit;
 
-namespace Microsoft.Kiota.Serialization.Text.Tests;
-
-public class TextSerializationWriterTests
+namespace Microsoft.Kiota.Serialization.Text.Tests
 {
-    public TextSerializationWriterTests()
-    {
-        Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("cs-CZ");
-    }
-
-    [Fact]
-    public void WritesStringValue()
-    {
-        // Arrange
-        var value = "This is a string value";
-
-        using var textSerializationWriter = new TextSerializationWriter();
-
-        // Act
-        textSerializationWriter.WriteStringValue(null, value);
-        var contentStream = textSerializationWriter.GetSerializedContent();
-        using var reader = new StreamReader(contentStream, Encoding.UTF8);
-        var serializedString = reader.ReadToEnd();
-
-        // Assert
-        Assert.Equal(value, serializedString);
-    }
-
-    [Fact]
-    public void StreamIsReadableAfterDispose()
-    {
-        // Arrange
-        var value = "This is a string value";
-
-        using var textSerializationWriter = new TextSerializationWriter();
-
-        // Act
-        textSerializationWriter.WriteStringValue(null, value);
-        var contentStream = textSerializationWriter.GetSerializedContent();
-        // Dispose the writer
-        textSerializationWriter.Dispose();
-        using var reader = new StreamReader(contentStream, Encoding.UTF8);
-        var serializedString = reader.ReadToEnd();
-
-        // Assert
-        Assert.Equal(value, serializedString);
-    }
-
-    [Fact]
-    public void WriteBoolValue_IsWrittenCorrectly()
-    {
-        // Arrange
-        var value = true;
-
-        using var textSerializationWriter = new TextSerializationWriter();
-
-        // Act
-        textSerializationWriter.WriteBoolValue(null, value);
-        var contentStream = textSerializationWriter.GetSerializedContent();
-        using var reader = new StreamReader(contentStream, Encoding.UTF8);
-        var serializedString = reader.ReadToEnd();
-
-        // Assert
-        Assert.Equal("True", serializedString);
-    }
-
-    [Fact]
-    public void WriteByteArrayValue_IsWrittenCorrectly()
-    {
-        // Arrange
-        var value = new byte[] { 2, 4, 6 };
-
-        using var textSerializationWriter = new TextSerializationWriter();
-
-        // Act
-        textSerializationWriter.WriteByteArrayValue(null, value);
-        var contentStream = textSerializationWriter.GetSerializedContent();
-        using var reader = new StreamReader(contentStream, Encoding.UTF8);
-        var serializedString = reader.ReadToEnd();
-
-        // Assert
-        Assert.Equal("AgQG", serializedString);
-    }
-
-    [Fact]
-    public void WriteByteValue_IsWrittenCorrectly()
-    {
-        // Arrange
-        byte value = 5;
-
-        using var textSerializationWriter = new TextSerializationWriter();
-
-        // Act
-        textSerializationWriter.WriteByteValue(null, value);
-        var contentStream = textSerializationWriter.GetSerializedContent();
-        using var reader = new StreamReader(contentStream, Encoding.UTF8);
-        var serializedString = reader.ReadToEnd();
-
-        // Assert
-        Assert.Equal("5", serializedString);
-    }
-
-    [Fact]
-    public void WriteDateTimeOffsetValue_IsWrittenCorrectly()
-    {
-        // Arrange
-        var value = new DateTimeOffset(2024,11,30,15,35,45,987, TimeSpan.FromHours(3));
-
-        using var textSerializationWriter = new TextSerializationWriter();
-
-        // Act
-        textSerializationWriter.WriteDateTimeOffsetValue(null, value);
-        var contentStream = textSerializationWriter.GetSerializedContent();
-        using var reader = new StreamReader(contentStream, Encoding.UTF8);
-        var serializedString = reader.ReadToEnd();
-
-        // Assert
-        Assert.Equal("2024-11-30T15:35:45.9870000+03:00", serializedString);
-    }
-
-    [Fact]
-    public void WriteDateValue_IsWrittenCorrectly()
-    {
-        // Arrange
-        var value = new Date(2024, 11, 30);
-
-        using var textSerializationWriter = new TextSerializationWriter();
-
-        // Act
-        textSerializationWriter.WriteDateValue(null, value);
-        var contentStream = textSerializationWriter.GetSerializedContent();
-        using var reader = new StreamReader(contentStream, Encoding.UTF8);
-        var serializedString = reader.ReadToEnd();
-
-        // Assert
-        Assert.Equal("2024-11-30", serializedString);
-    }
-
-    [Fact]
-    public void WriteDecimalValue_IsWrittenCorrectly()
-    {
-        // Arrange
-        var value = 36.8m;
-
-        using var textSerializationWriter = new TextSerializationWriter();
-
-        // Act
-        textSerializationWriter.WriteDecimalValue(null, value);
-        var contentStream = textSerializationWriter.GetSerializedContent();
-        using var reader = new StreamReader(contentStream, Encoding.UTF8);
-        var serializedString = reader.ReadToEnd();
-
-        // Assert
-        Assert.Equal("36.8", serializedString);
-    }
-
-    [Fact]
-    public void WriteDoubleValue_IsWrittenCorrectly()
-    {
-        // Arrange
-        var value = 36.8d;
-
-        using var textSerializationWriter = new TextSerializationWriter();
-
-        // Act
-        textSerializationWriter.WriteDoubleValue(null, value);
-        var contentStream = textSerializationWriter.GetSerializedContent();
-        using var reader = new StreamReader(contentStream, Encoding.UTF8);
-        var serializedString = reader.ReadToEnd();
-
-        // Assert
-        Assert.Equal("36.8", serializedString);
-    }
-
-    [Fact]
-    public void WriteFloatValue_IsWrittenCorrectly()
-    {
-        // Arrange
-        var value = 36.8f;
-
-        using var textSerializationWriter = new TextSerializationWriter();
-
-        // Act
-        textSerializationWriter.WriteFloatValue(null, value);
-        var contentStream = textSerializationWriter.GetSerializedContent();
-        using var reader = new StreamReader(contentStream, Encoding.UTF8);
-        var serializedString = reader.ReadToEnd();
-
-        // Assert
-        Assert.Equal("36.8", serializedString);
-    }
-
-    [Fact]
-    public void WriteGuidValue_IsWrittenCorrectly()
-    {
-        // Arrange
-        var value = new Guid("3adeb301-58f1-45c5-b820-ae5f4af13c89");
-
-        using var textSerializationWriter = new TextSerializationWriter();
-
-        // Act
-        textSerializationWriter.WriteGuidValue(null, value);
-        var contentStream = textSerializationWriter.GetSerializedContent();
-        using var reader = new StreamReader(contentStream, Encoding.UTF8);
-        var serializedString = reader.ReadToEnd();
-
-        // Assert
-        Assert.Equal("3adeb301-58f1-45c5-b820-ae5f4af13c89", serializedString);
-    }
-
-    [Fact]
-    public void WriteIntegerValue_IsWrittenCorrectly()
+    public class TextSerializationWriterTests
     {
-        // Arrange
-        var value = 25;
-
-        using var textSerializationWriter = new TextSerializationWriter();
-
-        // Act
-        textSerializationWriter.WriteIntValue(null, value);
-        var contentStream = textSerializationWriter.GetSerializedContent();
-        using var reader = new StreamReader(contentStream, Encoding.UTF8);
-        var serializedString = reader.ReadToEnd();
-
-        // Assert
-        Assert.Equal("25", serializedString);
-    }
-
-    [Fact]
-    public void WriteLongValue_IsWrittenCorrectly()
-    {
-        // Arrange
-        var value = long.MaxValue;
-
-        using var textSerializationWriter = new TextSerializationWriter();
-
-        // Act
-        textSerializationWriter.WriteLongValue(null, value);
-        var contentStream = textSerializationWriter.GetSerializedContent();
-        using var reader = new StreamReader(contentStream, Encoding.UTF8);
-        var serializedString = reader.ReadToEnd();
-
-        // Assert
-        Assert.Equal("9223372036854775807", serializedString);
-    }
-
-    [Fact]
-    public void WriteNullValue_IsWrittenCorrectly()
-    {
-        // Arrange
-        using var textSerializationWriter = new TextSerializationWriter();
-
-        // Act
-        textSerializationWriter.WriteNullValue(null);
-        var contentStream = textSerializationWriter.GetSerializedContent();
-        using var reader = new StreamReader(contentStream, Encoding.UTF8);
-        var serializedString = reader.ReadToEnd();
-
-        // Assert
-        Assert.Equal("null", serializedString);
-    }
-
-    [Fact]
-    public void WriteSByteValue_IsWrittenCorrectly()
-    {
-        // Arrange
-        var value = sbyte.MaxValue;
-
-        using var textSerializationWriter = new TextSerializationWriter();
-
-        // Act
-        textSerializationWriter.WriteSbyteValue(null, value);
-        var contentStream = textSerializationWriter.GetSerializedContent();
-        using var reader = new StreamReader(contentStream, Encoding.UTF8);
-        var serializedString = reader.ReadToEnd();
-
-        // Assert
-        Assert.Equal("127", serializedString);
-    }
-
-    [Fact]
-    public void WriteTimeValue_IsWrittenCorrectly()
-    {
-        // Arrange
-        var value = new Time(23, 46, 59);
-
-        using var textSerializationWriter = new TextSerializationWriter();
-
-        // Act
-        textSerializationWriter.WriteTimeValue(null, value);
-        var contentStream = textSerializationWriter.GetSerializedContent();
-        using var reader = new StreamReader(contentStream, Encoding.UTF8);
-        var serializedString = reader.ReadToEnd();
-
-        // Assert
-        Assert.Equal("23:46:59", serializedString);
-    }
-
-    [Fact]
-    public void WriteTimeSpanValue_IsWrittenCorrectly()
-    {
-        // Arrange
-        var value = new TimeSpan(756, 4, 6, 8, 10);
-
-        using var textSerializationWriter = new TextSerializationWriter();
-
-        // Act
-        textSerializationWriter.WriteTimeSpanValue(null, value);
-        var contentStream = textSerializationWriter.GetSerializedContent();
-        using var reader = new StreamReader(contentStream, Encoding.UTF8);
-        var serializedString = reader.ReadToEnd();
-
-        // Assert
-        Assert.Equal("P756DT4H6M8.01S", serializedString);
-    }
-
-    [Fact]
-    public void WriteAdditionalData_ThrowsInvalidOperationException()
-    {
-        // Arrange
-        var additionalData = new Dictionary<string, object>();
-
-        using var textSerializationWriter = new TextSerializationWriter();
-
-        // Act and Assert
-        Assert.Throws<InvalidOperationException>(() => textSerializationWriter.WriteAdditionalData(additionalData));
-    }
-
-    [Fact]
-    public void WriteEnumValue_IsWrittenCorrectly()
-    {
-        // Arrange
-        var value = TestEnum.FirstItem;
-
-        using var textSerializationWriter = new TextSerializationWriter();
-
-        // Act
-        textSerializationWriter.WriteEnumValue<TestEnum>(null, value);
-        var contentStream = textSerializationWriter.GetSerializedContent();
-        using var reader = new StreamReader(contentStream, Encoding.UTF8);
-        var serializedString = reader.ReadToEnd();
-
-        // Assert
-        Assert.Equal("firstItem", serializedString);
-    }
-
-    [Fact]
-    public void WriteCollectionOfEnumValues_ThrowsInvalidOperationException()
-    {
-        // Arrange
-        var value = new List<TestEnum?> { TestEnum.FirstItem, TestEnum.SecondItem };
-
-        using var textSerializationWriter = new TextSerializationWriter();
-
-        // Act and Assert
-        Assert.Throws<InvalidOperationException>(() => textSerializationWriter.WriteCollectionOfEnumValues(null, value));
+        public TextSerializationWriterTests()
+        {
+            Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("cs-CZ");
+        }
+
+        [Fact]
+        public void WritesStringValue()
+        {
+            // Arrange
+            var value = "This is a string value";
+
+            using var textSerializationWriter = new TextSerializationWriter();
+
+            // Act
+            textSerializationWriter.WriteStringValue(null, value);
+            var contentStream = textSerializationWriter.GetSerializedContent();
+            using var reader = new StreamReader(contentStream, Encoding.UTF8);
+            var serializedString = reader.ReadToEnd();
+
+            // Assert
+            Assert.Equal(value, serializedString);
+        }
+
+        [Fact]
+        public void StreamIsReadableAfterDispose()
+        {
+            // Arrange
+            var value = "This is a string value";
+
+            using var textSerializationWriter = new TextSerializationWriter();
+
+            // Act
+            textSerializationWriter.WriteStringValue(null, value);
+            var contentStream = textSerializationWriter.GetSerializedContent();
+            // Dispose the writer
+            textSerializationWriter.Dispose();
+            using var reader = new StreamReader(contentStream, Encoding.UTF8);
+            var serializedString = reader.ReadToEnd();
+
+            // Assert
+            Assert.Equal(value, serializedString);
+        }
+
+        [Fact]
+        public void WriteBoolValue_IsWrittenCorrectly()
+        {
+            // Arrange
+            var value = true;
+
+            using var textSerializationWriter = new TextSerializationWriter();
+
+            // Act
+            textSerializationWriter.WriteBoolValue(null, value);
+            var contentStream = textSerializationWriter.GetSerializedContent();
+            using var reader = new StreamReader(contentStream, Encoding.UTF8);
+            var serializedString = reader.ReadToEnd();
+
+            // Assert
+            Assert.Equal("True", serializedString);
+        }
+
+        [Fact]
+        public void WriteByteArrayValue_IsWrittenCorrectly()
+        {
+            // Arrange
+            var value = new byte[] { 2, 4, 6 };
+
+            using var textSerializationWriter = new TextSerializationWriter();
+
+            // Act
+            textSerializationWriter.WriteByteArrayValue(null, value);
+            var contentStream = textSerializationWriter.GetSerializedContent();
+            using var reader = new StreamReader(contentStream, Encoding.UTF8);
+            var serializedString = reader.ReadToEnd();
+
+            // Assert
+            Assert.Equal("AgQG", serializedString);
+        }
+
+        [Fact]
+        public void WriteByteValue_IsWrittenCorrectly()
+        {
+            // Arrange
+            byte value = 5;
+
+            using var textSerializationWriter = new TextSerializationWriter();
+
+            // Act
+            textSerializationWriter.WriteByteValue(null, value);
+            var contentStream = textSerializationWriter.GetSerializedContent();
+            using var reader = new StreamReader(contentStream, Encoding.UTF8);
+            var serializedString = reader.ReadToEnd();
+
+            // Assert
+            Assert.Equal("5", serializedString);
+        }
+
+        [Fact]
+        public void WriteDateTimeOffsetValue_IsWrittenCorrectly()
+        {
+            // Arrange
+            var value = new DateTimeOffset(2024, 11, 30, 15, 35, 45, 987, TimeSpan.FromHours(3));
+
+            using var textSerializationWriter = new TextSerializationWriter();
+
+            // Act
+            textSerializationWriter.WriteDateTimeOffsetValue(null, value);
+            var contentStream = textSerializationWriter.GetSerializedContent();
+            using var reader = new StreamReader(contentStream, Encoding.UTF8);
+            var serializedString = reader.ReadToEnd();
+
+            // Assert
+            Assert.Equal("2024-11-30T15:35:45.9870000+03:00", serializedString);
+        }
+
+        [Fact]
+        public void WriteDateValue_IsWrittenCorrectly()
+        {
+            // Arrange
+            var value = new Date(2024, 11, 30);
+
+            using var textSerializationWriter = new TextSerializationWriter();
+
+            // Act
+            textSerializationWriter.WriteDateValue(null, value);
+            var contentStream = textSerializationWriter.GetSerializedContent();
+            using var reader = new StreamReader(contentStream, Encoding.UTF8);
+            var serializedString = reader.ReadToEnd();
+
+            // Assert
+            Assert.Equal("2024-11-30", serializedString);
+        }
+
+        [Fact]
+        public void WriteDecimalValue_IsWrittenCorrectly()
+        {
+            // Arrange
+            var value = 36.8m;
+
+            using var textSerializationWriter = new TextSerializationWriter();
+
+            // Act
+            textSerializationWriter.WriteDecimalValue(null, value);
+            var contentStream = textSerializationWriter.GetSerializedContent();
+            using var reader = new StreamReader(contentStream, Encoding.UTF8);
+            var serializedString = reader.ReadToEnd();
+
+            // Assert
+            Assert.Equal("36.8", serializedString);
+        }
+
+        [Fact]
+        public void WriteDoubleValue_IsWrittenCorrectly()
+        {
+            // Arrange
+            var value = 36.8d;
+
+            using var textSerializationWriter = new TextSerializationWriter();
+
+            // Act
+            textSerializationWriter.WriteDoubleValue(null, value);
+            var contentStream = textSerializationWriter.GetSerializedContent();
+            using var reader = new StreamReader(contentStream, Encoding.UTF8);
+            var serializedString = reader.ReadToEnd();
+
+            // Assert
+            Assert.Equal("36.8", serializedString);
+        }
+
+        [Fact]
+        public void WriteFloatValue_IsWrittenCorrectly()
+        {
+            // Arrange
+            var value = 36.8f;
+
+            using var textSerializationWriter = new TextSerializationWriter();
+
+            // Act
+            textSerializationWriter.WriteFloatValue(null, value);
+            var contentStream = textSerializationWriter.GetSerializedContent();
+            using var reader = new StreamReader(contentStream, Encoding.UTF8);
+            var serializedString = reader.ReadToEnd();
+
+            // Assert
+            Assert.Equal("36.8", serializedString);
+        }
+
+        [Fact]
+        public void WriteGuidValue_IsWrittenCorrectly()
+        {
+            // Arrange
+            var value = new Guid("3adeb301-58f1-45c5-b820-ae5f4af13c89");
+
+            using var textSerializationWriter = new TextSerializationWriter();
+
+            // Act
+            textSerializationWriter.WriteGuidValue(null, value);
+            var contentStream = textSerializationWriter.GetSerializedContent();
+            using var reader = new StreamReader(contentStream, Encoding.UTF8);
+            var serializedString = reader.ReadToEnd();
+
+            // Assert
+            Assert.Equal("3adeb301-58f1-45c5-b820-ae5f4af13c89", serializedString);
+        }
+
+        [Fact]
+        public void WriteIntegerValue_IsWrittenCorrectly()
+        {
+            // Arrange
+            var value = 25;
+
+            using var textSerializationWriter = new TextSerializationWriter();
+
+            // Act
+            textSerializationWriter.WriteIntValue(null, value);
+            var contentStream = textSerializationWriter.GetSerializedContent();
+            using var reader = new StreamReader(contentStream, Encoding.UTF8);
+            var serializedString = reader.ReadToEnd();
+
+            // Assert
+            Assert.Equal("25", serializedString);
+        }
+
+        [Fact]
+        public void WriteLongValue_IsWrittenCorrectly()
+        {
+            // Arrange
+            var value = long.MaxValue;
+
+            using var textSerializationWriter = new TextSerializationWriter();
+
+            // Act
+            textSerializationWriter.WriteLongValue(null, value);
+            var contentStream = textSerializationWriter.GetSerializedContent();
+            using var reader = new StreamReader(contentStream, Encoding.UTF8);
+            var serializedString = reader.ReadToEnd();
+
+            // Assert
+            Assert.Equal("9223372036854775807", serializedString);
+        }
+
+        [Fact]
+        public void WriteNullValue_IsWrittenCorrectly()
+        {
+            // Arrange
+            using var textSerializationWriter = new TextSerializationWriter();
+
+            // Act
+            textSerializationWriter.WriteNullValue(null);
+            var contentStream = textSerializationWriter.GetSerializedContent();
+            using var reader = new StreamReader(contentStream, Encoding.UTF8);
+            var serializedString = reader.ReadToEnd();
+
+            // Assert
+            Assert.Equal("null", serializedString);
+        }
+
+        [Fact]
+        public void WriteSByteValue_IsWrittenCorrectly()
+        {
+            // Arrange
+            var value = sbyte.MaxValue;
+
+            using var textSerializationWriter = new TextSerializationWriter();
+
+            // Act
+            textSerializationWriter.WriteSbyteValue(null, value);
+            var contentStream = textSerializationWriter.GetSerializedContent();
+            using var reader = new StreamReader(contentStream, Encoding.UTF8);
+            var serializedString = reader.ReadToEnd();
+
+            // Assert
+            Assert.Equal("127", serializedString);
+        }
+
+        [Fact]
+        public void WriteTimeValue_IsWrittenCorrectly()
+        {
+            // Arrange
+            var value = new Time(23, 46, 59);
+
+            using var textSerializationWriter = new TextSerializationWriter();
+
+            // Act
+            textSerializationWriter.WriteTimeValue(null, value);
+            var contentStream = textSerializationWriter.GetSerializedContent();
+            using var reader = new StreamReader(contentStream, Encoding.UTF8);
+            var serializedString = reader.ReadToEnd();
+
+            // Assert
+            Assert.Equal("23:46:59", serializedString);
+        }
+
+        [Fact]
+        public void WriteTimeSpanValue_IsWrittenCorrectly()
+        {
+            // Arrange
+            var value = new TimeSpan(756, 4, 6, 8, 10);
+
+            using var textSerializationWriter = new TextSerializationWriter();
+
+            // Act
+            textSerializationWriter.WriteTimeSpanValue(null, value);
+            var contentStream = textSerializationWriter.GetSerializedContent();
+            using var reader = new StreamReader(contentStream, Encoding.UTF8);
+            var serializedString = reader.ReadToEnd();
+
+            // Assert
+            Assert.Equal("P756DT4H6M8.01S", serializedString);
+        }
+
+        [Fact]
+        public void WriteAdditionalData_ThrowsInvalidOperationException()
+        {
+            // Arrange
+            var additionalData = new Dictionary<string, object>();
+
+            using var textSerializationWriter = new TextSerializationWriter();
+
+            // Act and Assert
+            Assert.Throws<InvalidOperationException>(() => textSerializationWriter.WriteAdditionalData(additionalData));
+        }
+
+        [Fact]
+        public void WriteEnumValue_IsWrittenCorrectly()
+        {
+            // Arrange
+            var value = TestEnum.FirstItem;
+
+            using var textSerializationWriter = new TextSerializationWriter();
+
+            // Act
+            textSerializationWriter.WriteEnumValue<TestEnum>(null, value);
+            var contentStream = textSerializationWriter.GetSerializedContent();
+            using var reader = new StreamReader(contentStream, Encoding.UTF8);
+            var serializedString = reader.ReadToEnd();
+
+            // Assert
+            Assert.Equal("firstItem", serializedString);
+        }
+
+        [Fact]
+        public void WriteCollectionOfEnumValues_ThrowsInvalidOperationException()
+        {
+            // Arrange
+            var value = new List<TestEnum?> { TestEnum.FirstItem, TestEnum.SecondItem };
+
+            using var textSerializationWriter = new TextSerializationWriter();
+
+            // Act and Assert
+            Assert.Throws<InvalidOperationException>(() => textSerializationWriter.WriteCollectionOfEnumValues(null, value));
+        }
     }
 }

From 23137a2feb6bb9da1eba5d28593123bffa121d75 Mon Sep 17 00:00:00 2001
From: Martin Machacek <machacek@edhouse.cz>
Date: Wed, 17 Jul 2024 09:45:17 +0200
Subject: [PATCH 4/7] Use invariant culture for (de)serialization

---
 tests/serialization/json/JsonSerializationWriterTests.cs | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/tests/serialization/json/JsonSerializationWriterTests.cs b/tests/serialization/json/JsonSerializationWriterTests.cs
index a577d9a2..ed9a4b2c 100644
--- a/tests/serialization/json/JsonSerializationWriterTests.cs
+++ b/tests/serialization/json/JsonSerializationWriterTests.cs
@@ -492,7 +492,11 @@ public void WriteDoubleValue_IsWrittenCorrectly()
             var serializedString = reader.ReadToEnd();
 
             // Assert
+#if NET462
+            Assert.Equal("36.799999999999997", serializedString);
+#else
             Assert.Equal("36.8", serializedString);
+#endif
         }
 
         [Fact]
@@ -510,7 +514,11 @@ public void WriteFloatValue_IsWrittenCorrectly()
             var serializedString = reader.ReadToEnd();
 
             // Assert
+#if NET462
+            Assert.Equal("36.7999992", serializedString);
+#else
             Assert.Equal("36.8", serializedString);
+#endif
         }
 
         [Fact]

From e29f522927f230bd1167945ba28410d5f32349aa Mon Sep 17 00:00:00 2001
From: Martin Machacek <machacek@edhouse.cz>
Date: Wed, 17 Jul 2024 12:21:28 +0200
Subject: [PATCH 5/7] Use invariant culture for (de)serialization

---
 CHANGELOG.md                    |  6 +++++-
 Directory.Build.props           |  2 +-
 tests/abstractions/TimeTests.cs | 28 ++++++++++++++++++++++++++++
 3 files changed, 34 insertions(+), 2 deletions(-)
 create mode 100644 tests/abstractions/TimeTests.cs

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 520e42a8..6e77e7fb 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,6 +7,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.9.10] - 2024-07-18
+
+- Fix DateTime serialization and deserialization
+
 ## [1.9.9] - 2024-07-12
 
 - Fix enum deserialization for SendPrimitiveAsync and SendPrimitiveCollectionAsync
@@ -23,4 +27,4 @@ Refer to the following for earlier releases of libraries in the project.
 1. [Serialization - JSON](./src/serialization/json/Changelog-old.md)
 1. [Serialization - FORM](./src/serialization/form/Changelog-old.md)
 1. [Serialization - TEXT](./src/serialization/text/Changelog-old.md)
-1. [Serialization - MULTIPART](./src/serialization/multipart/Changelog-old.md)
+1. [Serialization - MULTIPART](./src/serialization/multipart/Changelog-old.md)
\ No newline at end of file
diff --git a/Directory.Build.props b/Directory.Build.props
index 131c0a8e..6751c2c3 100644
--- a/Directory.Build.props
+++ b/Directory.Build.props
@@ -1,7 +1,7 @@
 <Project>
   <!-- Common default project properties for ALL projects-->
   <PropertyGroup>
-    <VersionPrefix>1.9.9</VersionPrefix>
+    <VersionPrefix>1.9.10</VersionPrefix>
     <VersionSuffix></VersionSuffix>
     <!-- This is overidden in test projects by setting to true-->
     <IsTestProject>false</IsTestProject>
diff --git a/tests/abstractions/TimeTests.cs b/tests/abstractions/TimeTests.cs
new file mode 100644
index 00000000..a4ac1a87
--- /dev/null
+++ b/tests/abstractions/TimeTests.cs
@@ -0,0 +1,28 @@
+using System;
+using Xunit;
+
+namespace Microsoft.Kiota.Abstractions.Tests
+{
+    public class TimeTests
+    {
+        [Fact]
+        public void TestTimeEquality()
+        {
+            var time1 = new Time(10, 30, 0);
+            var time2 = new Time(new DateTime(2024, 7, 17, 10, 30, 0));
+            var time3 = new Time(12, 0, 0);
+
+            Assert.Equal(time1, time2);
+            Assert.NotEqual(time1, time3);
+        }
+
+        [Fact]
+        public void TestTimeToString()
+        {
+            var time = new Time(15, 45, 30);
+            var expectedString = "15:45:30";
+
+            Assert.Equal(expectedString, time.ToString());
+        }
+    }
+}

From 9ccd477aa7bc227836704fcfdac8fc52ef220d96 Mon Sep 17 00:00:00 2001
From: Martin Machacek <machacek@edhouse.cz>
Date: Thu, 18 Jul 2024 13:11:16 +0200
Subject: [PATCH 6/7] Use invariant culture for (de)serialization

---
 .../form/FormSerializationWriter.cs           |   3 +
 src/serialization/json/JsonParseNode.cs       |  22 +-
 .../form/FormSerializationWriterTests.cs      |   2 +-
 .../json/Converters/JsonDateConverter.cs      |  29 +++
 .../Converters/JsonDateTimeOffsetConverter.cs |  28 +++
 .../json/Converters/JsonTimeConverter.cs      |  29 +++
 .../serialization/json/JsonParseNodeTests.cs  | 210 ++++++++++++++++++
 7 files changed, 311 insertions(+), 12 deletions(-)
 create mode 100644 tests/serialization/json/Converters/JsonDateConverter.cs
 create mode 100644 tests/serialization/json/Converters/JsonDateTimeOffsetConverter.cs
 create mode 100644 tests/serialization/json/Converters/JsonTimeConverter.cs

diff --git a/src/serialization/form/FormSerializationWriter.cs b/src/serialization/form/FormSerializationWriter.cs
index 137d5d35..93a9325b 100644
--- a/src/serialization/form/FormSerializationWriter.cs
+++ b/src/serialization/form/FormSerializationWriter.cs
@@ -86,6 +86,9 @@ private void WriteAnyValue(string? key, object value)
             case IEnumerable<object> coll:
                 WriteCollectionOfPrimitiveValues(key, coll);
                 break;
+            case byte[] coll:
+                WriteByteArrayValue(key, coll);
+                break;
             case IParsable:
                 throw new InvalidOperationException("Form serialization does not support nested objects.");
             default:
diff --git a/src/serialization/json/JsonParseNode.cs b/src/serialization/json/JsonParseNode.cs
index 3b400150..7a107ee3 100644
--- a/src/serialization/json/JsonParseNode.cs
+++ b/src/serialization/json/JsonParseNode.cs
@@ -177,14 +177,14 @@ public JsonParseNode(JsonElement node, KiotaJsonSerializationContext jsonSeriali
         /// <returns>A <see cref="Date"/> value</returns>
         public Date? GetDateValue()
         {
-            var dateString = _jsonNode.GetString();
-            if(string.IsNullOrEmpty(dateString))
+            if(_jsonNode.ValueKind != JsonValueKind.String)
                 return null;
 
-            if(DateTime.TryParse(dateString, CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind, out var result))
-                return new Date(result);
-
-            return _jsonNode.Deserialize(_jsonSerializerContext.Date);
+            if(TryGetUsingTypeInfo(_jsonNode, _jsonSerializerContext.Date, out var date))
+                return date;
+            else if(DateTime.TryParse(_jsonNode.GetString(), CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind, out var dt))
+                return new Date(dt);
+            else return null;
         }
 
         /// <summary>
@@ -193,14 +193,14 @@ public JsonParseNode(JsonElement node, KiotaJsonSerializationContext jsonSeriali
         /// <returns>A <see cref="Time"/> value</returns>
         public Time? GetTimeValue()
         {
-            var dateString = _jsonNode.GetString();
-            if(string.IsNullOrEmpty(dateString))
+            if(_jsonNode.ValueKind != JsonValueKind.String)
                 return null;
 
-            if(DateTime.TryParse(dateString, CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind, out var result))
+            if(TryGetUsingTypeInfo(_jsonNode, _jsonSerializerContext.Time, out var time))
+                return time;
+            if(DateTime.TryParse(_jsonNode.GetString(), CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind, out var result))
                 return new Time(result);
-
-            return _jsonNode.Deserialize(_jsonSerializerContext.Time);
+            else return null;
         }
 
         /// <summary>
diff --git a/tests/serialization/form/FormSerializationWriterTests.cs b/tests/serialization/form/FormSerializationWriterTests.cs
index ded84356..45822417 100644
--- a/tests/serialization/form/FormSerializationWriterTests.cs
+++ b/tests/serialization/form/FormSerializationWriterTests.cs
@@ -414,7 +414,7 @@ public void WriteAdditionalData_AreWrittenCorrectly()
         var serializedString = reader.ReadToEnd();
 
         // Assert
-        Assert.Equal("prop1=value1&prop2=2&prop3=true&prop4=2.25&prop5=3.14&prop6=4&prop7=5&prop8=2024-11-30T15%3A35%3A45.9870000%2B03%3A00&prop9=2024-11-30&prop10=23%3A46%3A59&prop11=P756DT4H6M8.01S&prop12=System.Byte%5B%5D&prop13=3adeb301-58f1-45c5-b820-ae5f4af13c89&prop14=127", serializedString);
+        Assert.Equal("prop1=value1&prop2=2&prop3=true&prop4=2.25&prop5=3.14&prop6=4&prop7=5&prop8=2024-11-30T15%3A35%3A45.9870000%2B03%3A00&prop9=2024-11-30&prop10=23%3A46%3A59&prop11=P756DT4H6M8.01S&prop12=AgQG&prop13=3adeb301-58f1-45c5-b820-ae5f4af13c89&prop14=127", serializedString);
     }
 
     [Fact]
diff --git a/tests/serialization/json/Converters/JsonDateConverter.cs b/tests/serialization/json/Converters/JsonDateConverter.cs
new file mode 100644
index 00000000..8d722992
--- /dev/null
+++ b/tests/serialization/json/Converters/JsonDateConverter.cs
@@ -0,0 +1,29 @@
+using System;
+using System.Globalization;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using Microsoft.Kiota.Abstractions;
+
+namespace Microsoft.Kiota.Serialization.Json.Tests.Converters;
+
+/// <summary>
+/// Converts a Date object or value to/from JSON.
+/// </summary>
+public class JsonDateConverter : JsonConverter<Date>
+{
+    /// <inheritdoc />
+    public override Date Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+        => reader.TokenType == JsonTokenType.Null
+            ? new Date()
+            : ReadInternal(ref reader);
+
+    /// <inheritdoc />
+    public override void Write(Utf8JsonWriter writer, Date value, JsonSerializerOptions options)
+        => WriteInternal(writer, value);
+
+    private static Date ReadInternal(ref Utf8JsonReader reader)
+        => new Date(DateTime.ParseExact(reader.GetString()!, "dd---MM---yyyy", CultureInfo.InvariantCulture));
+
+    private static void WriteInternal(Utf8JsonWriter writer, Date value)
+        => writer.WriteStringValue($"{value.Day}---{value.Month}---{value.Year}");
+}
\ No newline at end of file
diff --git a/tests/serialization/json/Converters/JsonDateTimeOffsetConverter.cs b/tests/serialization/json/Converters/JsonDateTimeOffsetConverter.cs
new file mode 100644
index 00000000..f23b4b25
--- /dev/null
+++ b/tests/serialization/json/Converters/JsonDateTimeOffsetConverter.cs
@@ -0,0 +1,28 @@
+using System;
+using System.Globalization;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace Microsoft.Kiota.Serialization.Json.Tests.Converters;
+
+/// <summary>
+/// Converts a DateTimeOffset object or value to/from JSON.
+/// </summary>
+public class JsonDateTimeOffsetConverter : JsonConverter<DateTimeOffset>
+{
+    /// <inheritdoc />
+    public override DateTimeOffset Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+        => reader.TokenType == JsonTokenType.Null
+            ? new DateTimeOffset()
+            : ReadInternal(ref reader);
+
+    /// <inheritdoc />
+    public override void Write(Utf8JsonWriter writer, DateTimeOffset value, JsonSerializerOptions options)
+        => WriteInternal(writer, value);
+
+    private static DateTimeOffset ReadInternal(ref Utf8JsonReader reader)
+        => DateTimeOffset.ParseExact(reader.GetString()!, "dd__MM__yyyyTHH_mm_ssZ", CultureInfo.InvariantCulture);
+
+    private static void WriteInternal(Utf8JsonWriter writer, DateTimeOffset value)
+        => writer.WriteStringValue(value.ToString("dd__MM__yyyyTHH_mm_ssZ"));
+}
diff --git a/tests/serialization/json/Converters/JsonTimeConverter.cs b/tests/serialization/json/Converters/JsonTimeConverter.cs
new file mode 100644
index 00000000..4e0cdc87
--- /dev/null
+++ b/tests/serialization/json/Converters/JsonTimeConverter.cs
@@ -0,0 +1,29 @@
+using System;
+using System.Globalization;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using Microsoft.Kiota.Abstractions;
+
+namespace Microsoft.Kiota.Serialization.Json.Tests.Converters;
+
+/// <summary>
+/// Converts a Time object or value to/from JSON.
+/// </summary>
+public class JsonTimeConverter : JsonConverter<Time>
+{
+    /// <inheritdoc />
+    public override Time Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+        => reader.TokenType == JsonTokenType.Null
+            ? new Time()
+            : ReadInternal(ref reader);
+
+    /// <inheritdoc />
+    public override void Write(Utf8JsonWriter writer, Time value, JsonSerializerOptions options)
+        => WriteInternal(writer, value);
+
+    private static Time ReadInternal(ref Utf8JsonReader reader)
+        => new Time(DateTime.ParseExact(reader.GetString()!, "HH__mm__ss", CultureInfo.InvariantCulture));
+
+    private static void WriteInternal(Utf8JsonWriter writer, Time value)
+        => writer.WriteStringValue($"{value.Hour}__{value.Minute}__{value.Second}");
+}
\ No newline at end of file
diff --git a/tests/serialization/json/JsonParseNodeTests.cs b/tests/serialization/json/JsonParseNodeTests.cs
index f8abae52..6520d9fb 100644
--- a/tests/serialization/json/JsonParseNodeTests.cs
+++ b/tests/serialization/json/JsonParseNodeTests.cs
@@ -322,5 +322,215 @@ public void GetCollectionOfNullableEnumValuesFromJson()
             Assert.Equal(TestNamingEnum.Item2SubItem1, values[0]);
             Assert.Equal(TestNamingEnum.Item3SubItem1, values[1]);
         }
+
+        [Fact]
+        public void GetDateValue_ReturnNullWhenValueKindIsNotString()
+        {
+            // Arrange
+            using var jsonDocument = JsonDocument.Parse("{\"startDate\":\"2024-07-31\"}");
+            var parseNode = new JsonParseNode(jsonDocument.RootElement);
+
+            // Act
+            var result = parseNode.GetDateValue();
+
+            // Assert
+            Assert.Null(result);
+        }
+
+        [Fact]
+        public void GetDateValue_ReturnNullWhenDateParseFails()
+        {
+            // Arrange
+            using var jsonDocument = JsonDocument.Parse("\"2024-13-32\"");
+            var parseNode = new JsonParseNode(jsonDocument.RootElement);
+
+            // Act
+            var result = parseNode.GetDateValue();
+
+            // Assert
+            Assert.Null(result);
+        }
+
+        [Fact]
+        public void GetDateValue_ReturnDateWhenCustomConverterIsUsed()
+        {
+            // Arrange
+            var serializerOptions = new JsonSerializerOptions(JsonSerializerDefaults.General)
+            {
+                Converters = { new JsonDateConverter() }
+            };
+            var serializationContext = new KiotaJsonSerializationContext(serializerOptions);
+
+            using var jsonDocument = JsonDocument.Parse("\"31---07---2024\"");
+            var parseNode = new JsonParseNode(jsonDocument.RootElement, serializationContext);
+
+            // Act
+            var result = parseNode.GetDateValue();
+
+            // Assert
+            Assert.NotNull(result);
+            Assert.Equal(31, result.Value.Day);
+            Assert.Equal(7, result.Value.Month);
+            Assert.Equal(2024, result.Value.Year);
+        }
+
+        [Fact]
+        public void GetDateValue_ReturnCorrectDate()
+        {
+            // Arrange
+            using var jsonDocument = JsonDocument.Parse("\"2024-07-31\"");
+            var parseNode = new JsonParseNode(jsonDocument.RootElement);
+
+            // Act
+            var result = parseNode.GetDateValue();
+
+            // Assert
+            Assert.NotNull(result);
+            Assert.Equal(31, result.Value.Day);
+            Assert.Equal(7, result.Value.Month);
+            Assert.Equal(2024, result.Value.Year);
+        }
+
+        [Fact]
+        public void GetTimeValue_ReturnNullWhenValueKindIsNotString()
+        {
+            // Arrange
+            using var jsonDocument = JsonDocument.Parse("{\"startTime\":\"12:34:56\"}");
+            var parseNode = new JsonParseNode(jsonDocument.RootElement);
+
+            // Act
+            var result = parseNode.GetTimeValue();
+
+            // Assert
+            Assert.Null(result);
+        }
+
+        [Fact]
+        public void GetTimeValue_ReturnNullWhenTimeParseFails()
+        {
+            // Arrange
+            using var jsonDocument = JsonDocument.Parse("\"12:60:56\"");
+            var parseNode = new JsonParseNode(jsonDocument.RootElement);
+
+            // Act
+            var result = parseNode.GetTimeValue();
+
+            // Assert
+            Assert.Null(result);
+        }
+
+        [Fact]
+        public void GetTimeValue_ReturnTimeWhenCustomConverterIsUsed()
+        {
+            // Arrange
+            var serializerOptions = new JsonSerializerOptions(JsonSerializerDefaults.General)
+            {
+                Converters = { new JsonTimeConverter() }
+            };
+            var serializationContext = new KiotaJsonSerializationContext(serializerOptions);
+
+            using var jsonDocument = JsonDocument.Parse("\"12__34__56\"");
+            var parseNode = new JsonParseNode(jsonDocument.RootElement, serializationContext);
+
+            // Act
+            var result = parseNode.GetTimeValue();
+
+            // Assert
+            Assert.NotNull(result);
+            Assert.Equal(12, result.Value.Hour);
+            Assert.Equal(34, result.Value.Minute);
+            Assert.Equal(56, result.Value.Second);
+        }
+
+        [Fact]
+        public void GetTimeValue_ReturnTime()
+        {
+            // Arrange
+            using var jsonDocument = JsonDocument.Parse("\"12:34:56\"");
+            var parseNode = new JsonParseNode(jsonDocument.RootElement);
+
+            // Act
+            var result = parseNode.GetTimeValue();
+
+            // Assert
+            Assert.NotNull(result);
+            Assert.Equal(12, result.Value.Hour);
+            Assert.Equal(34, result.Value.Minute);
+            Assert.Equal(56, result.Value.Second);
+        }
+
+        [Fact]
+        public void GetDateTimeOffsetValue_ReturnNullWhenValueKindIsNotString()
+        {
+            // Arrange
+            using var jsonDocument = JsonDocument.Parse("{\"startDateTime\":\"2024-07-31\"}");
+            var parseNode = new JsonParseNode(jsonDocument.RootElement);
+
+            // Act
+            var result = parseNode.GetDateTimeOffsetValue();
+
+            // Assert
+            Assert.Null(result);
+        }
+
+        [Fact]
+        public void GetDateTimeOffsetValue_ReturnNullWhenDateTimeOffsetParseFails()
+        {
+            // Arrange
+            using var jsonDocument = JsonDocument.Parse("\"2024-13-32T12:34:56Z\"");
+            var parseNode = new JsonParseNode(jsonDocument.RootElement);
+
+            // Act
+            var result = parseNode.GetDateTimeOffsetValue();
+
+            // Assert
+            Assert.Null(result);
+        }
+
+        [Fact]
+        public void GetDateTimeOffsetValue_ReturnDateTimeOffsetWhenCustomConverterIsUsed()
+        {
+            // Arrange
+            var serializerOptions = new JsonSerializerOptions(JsonSerializerDefaults.General)
+            {
+                Converters = { new JsonDateTimeOffsetConverter() }
+            };
+            var serializationContext = new KiotaJsonSerializationContext(serializerOptions);
+
+            using var jsonDocument = JsonDocument.Parse("\"31__07__2024T12_34_56Z\"");
+            var parseNode = new JsonParseNode(jsonDocument.RootElement, serializationContext);
+
+            // Act
+            var result = parseNode.GetDateTimeOffsetValue();
+
+            // Assert
+            Assert.NotNull(result);
+            Assert.Equal(31, result.Value.Day);
+            Assert.Equal(7, result.Value.Month);
+            Assert.Equal(2024, result.Value.Year);
+            Assert.Equal(12, result.Value.Hour);
+            Assert.Equal(34, result.Value.Minute);
+            Assert.Equal(56, result.Value.Second);
+        }
+
+        [Fact]
+        public void GetDateTimeOffsetValue_ReturnCorrectDateTimeOffset()
+        {
+            // Arrange
+            using var jsonDocument = JsonDocument.Parse("\"2024-07-31T12:34:56Z\"");
+            var parseNode = new JsonParseNode(jsonDocument.RootElement);
+
+            // Act
+            var result = parseNode.GetDateTimeOffsetValue();
+
+            // Assert
+            Assert.NotNull(result);
+            Assert.Equal(31, result.Value.Day);
+            Assert.Equal(7, result.Value.Month);
+            Assert.Equal(2024, result.Value.Year);
+            Assert.Equal(12, result.Value.Hour);
+            Assert.Equal(34, result.Value.Minute);
+            Assert.Equal(56, result.Value.Second);
+        }
     }
 }

From cf1c752c1c22941a64888abdce0247c3bb53390c Mon Sep 17 00:00:00 2001
From: Martin Machacek <machacek@edhouse.cz>
Date: Thu, 18 Jul 2024 13:38:29 +0200
Subject: [PATCH 7/7] Use invariant culture for (de)serialization

---
 tests/serialization/json/Converters/JsonDateConverter.cs     | 4 ++--
 .../json/Converters/JsonDateTimeOffsetConverter.cs           | 5 +++--
 tests/serialization/json/Converters/JsonTimeConverter.cs     | 4 ++--
 3 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/tests/serialization/json/Converters/JsonDateConverter.cs b/tests/serialization/json/Converters/JsonDateConverter.cs
index 8d722992..e522b9aa 100644
--- a/tests/serialization/json/Converters/JsonDateConverter.cs
+++ b/tests/serialization/json/Converters/JsonDateConverter.cs
@@ -22,8 +22,8 @@ public override void Write(Utf8JsonWriter writer, Date value, JsonSerializerOpti
         => WriteInternal(writer, value);
 
     private static Date ReadInternal(ref Utf8JsonReader reader)
-        => new Date(DateTime.ParseExact(reader.GetString()!, "dd---MM---yyyy", CultureInfo.InvariantCulture));
+        => new Date(DateTime.ParseExact(reader.GetString(), "dd---MM---yyyy", CultureInfo.InvariantCulture));
 
     private static void WriteInternal(Utf8JsonWriter writer, Date value)
-        => writer.WriteStringValue($"{value.Day}---{value.Month}---{value.Year}");
+        => writer.WriteStringValue(value.ToString());
 }
\ No newline at end of file
diff --git a/tests/serialization/json/Converters/JsonDateTimeOffsetConverter.cs b/tests/serialization/json/Converters/JsonDateTimeOffsetConverter.cs
index f23b4b25..7c75f488 100644
--- a/tests/serialization/json/Converters/JsonDateTimeOffsetConverter.cs
+++ b/tests/serialization/json/Converters/JsonDateTimeOffsetConverter.cs
@@ -10,6 +10,7 @@ namespace Microsoft.Kiota.Serialization.Json.Tests.Converters;
 /// </summary>
 public class JsonDateTimeOffsetConverter : JsonConverter<DateTimeOffset>
 {
+    private const string Format = "dd__MM__yyyyTHH_mm_ssZ";
     /// <inheritdoc />
     public override DateTimeOffset Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
         => reader.TokenType == JsonTokenType.Null
@@ -21,8 +22,8 @@ public override void Write(Utf8JsonWriter writer, DateTimeOffset value, JsonSeri
         => WriteInternal(writer, value);
 
     private static DateTimeOffset ReadInternal(ref Utf8JsonReader reader)
-        => DateTimeOffset.ParseExact(reader.GetString()!, "dd__MM__yyyyTHH_mm_ssZ", CultureInfo.InvariantCulture);
+        => DateTimeOffset.ParseExact(reader.GetString(), Format, CultureInfo.InvariantCulture);
 
     private static void WriteInternal(Utf8JsonWriter writer, DateTimeOffset value)
-        => writer.WriteStringValue(value.ToString("dd__MM__yyyyTHH_mm_ssZ"));
+        => writer.WriteStringValue(value.ToString(Format));
 }
diff --git a/tests/serialization/json/Converters/JsonTimeConverter.cs b/tests/serialization/json/Converters/JsonTimeConverter.cs
index 4e0cdc87..20608b5d 100644
--- a/tests/serialization/json/Converters/JsonTimeConverter.cs
+++ b/tests/serialization/json/Converters/JsonTimeConverter.cs
@@ -22,8 +22,8 @@ public override void Write(Utf8JsonWriter writer, Time value, JsonSerializerOpti
         => WriteInternal(writer, value);
 
     private static Time ReadInternal(ref Utf8JsonReader reader)
-        => new Time(DateTime.ParseExact(reader.GetString()!, "HH__mm__ss", CultureInfo.InvariantCulture));
+        => new Time(DateTime.ParseExact(reader.GetString(), "HH__mm__ss", CultureInfo.InvariantCulture));
 
     private static void WriteInternal(Utf8JsonWriter writer, Time value)
-        => writer.WriteStringValue($"{value.Hour}__{value.Minute}__{value.Second}");
+        => writer.WriteStringValue(value.ToString());
 }
\ No newline at end of file