Fix conversion of 'float' and 'double' values

Konstantin-Posudevskiy · Konstantin-Posudevskiy · commit a9c3d8bc542b · 2017-06-12T15:21:31.000+03:00
Fix problem of conversion 'float' and 'double' values in converter.cs. As there was a range check both for 'float' and 'double' values, which are less or greater than its 'MinValue' and 'MaxValue' accordingly, several values like 'float.NegativeInfinity', 'float.PositiveInfinity' and the same 'double' values cannot be converted from Python to .NET values. Add error check after 'PyFloat_AsDouble' call. Due to Python C API documentation, method 'PyFloat_AsDouble' can return '-1.0' upon failure. So it requires error check. This rule forces to check for error and throw exception in case of error. Add tests, which cover problem of conversion 'float' and 'double' values. Resolves: #486.
diff --git a/src/embed_tests/Python.EmbeddingTest.csproj b/src/embed_tests/Python.EmbeddingTest.csproj
@@ -84,6 +84,7 @@
     <Compile Include="pyimport.cs" />
     <Compile Include="pyinitialize.cs" />
     <Compile Include="pyrunstring.cs" />
+    <Compile Include="TestConverter.cs" />
     <Compile Include="TestCustomMarshal.cs" />
     <Compile Include="TestExample.cs" />
     <Compile Include="TestPyAnsiString.cs" />
diff --git a/src/embed_tests/TestConverter.cs b/src/embed_tests/TestConverter.cs
@@ -0,0 +1,48 @@
+﻿using NUnit.Framework;
+using Python.Runtime;
+
+namespace Python.EmbeddingTest
+{
+    public class TestConverter
+    {
+        [OneTimeSetUp]
+        public void SetUp()
+        {
+            PythonEngine.Initialize();
+        }
+
+        [OneTimeTearDown]
+        public void Dispose()
+        {
+            PythonEngine.Shutdown();
+        }
+
+        [Test]
+        public void TestConvertSingleToManaged(
+            [Values(float.PositiveInfinity, float.NegativeInfinity, float.MinValue, float.MaxValue, float.NaN,
+                float.Epsilon)] float testValue)
+        {
+            var pyFloat = new PyFloat(testValue);
+
+            object convertedValue;
+            var converted = Converter.ToManaged(pyFloat.Handle, typeof(float), out convertedValue, false);
+
+            Assert.IsTrue(converted);
+            Assert.IsTrue(((float) convertedValue).Equals(testValue));
+        }
+
+        [Test]
+        public void TestConvertDoubleToManaged(
+            [Values(double.PositiveInfinity, double.NegativeInfinity, double.MinValue, double.MaxValue, double.NaN,
+                double.Epsilon)] double testValue)
+        {
+            var pyFloat = new PyFloat(testValue);
+
+            object convertedValue;
+            var converted = Converter.ToManaged(pyFloat.Handle, typeof(double), out convertedValue, false);
+
+            Assert.IsTrue(converted);
+            Assert.IsTrue(((double) convertedValue).Equals(testValue));
+        }
+    }
+}
diff --git a/src/runtime/converter.cs b/src/runtime/converter.cs
@@ -770,10 +770,14 @@ private static bool ToPrimitive(IntPtr value, Type obType, out object result, bo
                         goto type_error;
                     }
                     double dd = Runtime.PyFloat_AsDouble(op);
+                    Runtime.CheckExceptionOccurred();
                     Runtime.XDecref(op);
                     if (dd > Single.MaxValue || dd < Single.MinValue)
                     {
-                        goto overflow;
+                        if (!double.IsInfinity(dd))
+                        {
+                            goto overflow;
+                        }
                     }
                     result = (float)dd;
                     return true;
@@ -785,11 +789,8 @@ private static bool ToPrimitive(IntPtr value, Type obType, out object result, bo
                         goto type_error;
                     }
                     double d = Runtime.PyFloat_AsDouble(op);
+                    Runtime.CheckExceptionOccurred();
                     Runtime.XDecref(op);
-                    if (d > Double.MaxValue || d < Double.MinValue)
-                    {
-                        goto overflow;
-                    }
                     result = d;
                     return true;
             }

Original file line number	Diff line number	Diff line change
`@@ -770,10 +770,14 @@ private static bool ToPrimitive(IntPtr value, Type obType, out object result, bo`
`770`	`770`	`goto type_error;`
`771`	`771`	`}`
`772`	`772`	`double dd = Runtime.PyFloat_AsDouble(op);`
	`773`	`+ Runtime.CheckExceptionOccurred();`
`773`	`774`	`Runtime.XDecref(op);`
`774`	`775`	`if (dd > Single.MaxValue \|\| dd < Single.MinValue)`
`775`	`776`	`{`
`776`		`- goto overflow;`
	`777`	`+ if (!double.IsInfinity(dd))`
	`778`	`+ {`
	`779`	`+ goto overflow;`
	`780`	`+ }`
`777`	`781`	`}`
`778`	`782`	`result = (float)dd;`
`779`	`783`	`return true;`
`@@ -785,11 +789,8 @@ private static bool ToPrimitive(IntPtr value, Type obType, out object result, bo`
`785`	`789`	`goto type_error;`
`786`	`790`	`}`
`787`	`791`	`double d = Runtime.PyFloat_AsDouble(op);`
	`792`	`+ Runtime.CheckExceptionOccurred();`
`788`	`793`	`Runtime.XDecref(op);`
`789`		`- if (d > Double.MaxValue \|\| d < Double.MinValue)`
`790`		`- {`
`791`		`- goto overflow;`
`792`		`- }`
`793`	`794`	`result = d;`
`794`	`795`	`return true;`
`795`	`796`	`}`