Merge pull request #209 from joelwkall/support-all-openapi-types-in-serializer

Support all numeric IOpenApiAny types in OpenApiWriterBase

Author: PerthCharern

src/Microsoft.OpenApi/Writers/OpenApiWriterBase.cs

@@ -111,6 +111,26 @@ public void Flush()
         /// </summary>
         /// <param name="value">The string value.</param>
         public abstract void WriteValue(string value);
+        
+        /// <summary>
+        /// Write float value.
+        /// </summary>
+        /// <param name="value">The float value.</param>
+        public virtual void WriteValue(float value)
+        {
+            WriteValueSeparator();
+            Writer.Write(value);
+        }
+
+        /// <summary>
+        /// Write double value.
+        /// </summary>
+        /// <param name="value">The double value.</param>
+        public virtual void WriteValue(double value)
+        {
+            WriteValueSeparator();
+            Writer.Write(value);
+        }
 
         /// <summary>
         /// Write decimal value.
@@ -132,6 +152,16 @@ public virtual void WriteValue(int value)
             Writer.Write(value);
         }
 
+        /// <summary>
+        /// Write long value.
+        /// </summary>
+        /// <param name="value">The long value.</param>
+        public virtual void WriteValue(long value)
+        {
+            WriteValueSeparator();
+            Writer.Write(value);
+        }
+
         /// <summary>
         /// Write boolean value.
         /// </summary>
@@ -164,10 +194,22 @@ public virtual void WriteValue(object value)
             {
                 WriteValue((int)value);
             }
+            else if (type == typeof(long) || type == typeof(long?))
+            {
+                WriteValue((long)value);
+            }
             else if (type == typeof(bool) || type == typeof(bool?))
             {
                 WriteValue((bool)value);
             }
+            else if (type == typeof(float) || type == typeof(float?))
+            {
+                WriteValue((float)value);
+            }
+            else if (type == typeof(double) || type == typeof(double?))
+            {
+                WriteValue((double)value);
+            }
             else if (type == typeof(decimal) || type == typeof(decimal?))
             {
                 WriteValue((decimal)value);

test/Microsoft.OpenApi.Tests/Writers/OpenApiWriterAnyExtensionsTests.cs

@@ -25,10 +25,10 @@ public void WriteOpenApiNullAsJsonWorks()
         }
 
         [Theory]
-        [InlineData(-100)]
-        [InlineData(0)]
+        [InlineData(int.MinValue)]
         [InlineData(42)]
-        public void WriteOpenApiIntergerAsJsonWorks(int input)
+        [InlineData(int.MaxValue)]
+        public void WriteOpenApiIntegerAsJsonWorks(int input)
         {
             // Arrange
             var intValue = new OpenApiInteger(input);
@@ -39,6 +39,51 @@ public void WriteOpenApiIntergerAsJsonWorks(int input)
             json.Should().Be(input.ToString());
         }
 
+        [Theory]
+        [InlineData(long.MinValue)]
+        [InlineData(42)]
+        [InlineData(long.MaxValue)]
+        public void WriteOpenApiLongAsJsonWorks(long input)
+        {
+            // Arrange
+            var longValue = new OpenApiLong(input);
+
+            var json = WriteAsJson(longValue);
+
+            // Assert
+            json.Should().Be(input.ToString());
+        }
+
+        [Theory]
+        [InlineData(float.MinValue)]
+        [InlineData(42.42)]
+        [InlineData(float.MaxValue)]
+        public void WriteOpenApiFloatAsJsonWorks(float input)
+        {
+            // Arrange
+            var floatValue = new OpenApiFloat(input);
+
+            var json = WriteAsJson(floatValue);
+
+            // Assert
+            json.Should().Be(input.ToString());
+        }
+
+        [Theory]
+        [InlineData(double.MinValue)]
+        [InlineData(42.42)]
+        [InlineData(double.MaxValue)]
+        public void WriteOpenApiDoubleAsJsonWorks(double input)
+        {
+            // Arrange
+            var doubleValue = new OpenApiDouble(input);
+
+            var json = WriteAsJson(doubleValue);
+
+            // Assert
+            json.Should().Be(input.ToString());
+        }
+
         [Theory]
         [InlineData(true)]
         [InlineData(false)]