Fix conversion of 'float' and 'double' values (#487)

Konstantin-Posudevskiy · denfromufa · commit d39f9f6e0ce2 · 2017-06-14T09:18:46.000-05:00
* Fix conversion of 'float' and 'double' values 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. * Fix failing 'test_double_conversion' test Fix incorrect part of 'test_double_conversion' test in test_conversion.py. An 'OverflowError' was expected for valid values, which represent Python 'inf' and '-inf'. The problem was identified with support of conversion for Python 'inf' and '-inf' to .NET System.Double PositiveInfinity and NegativeInfinity. See also: #487.
diff --git a/AUTHORS.md b/AUTHORS.md
@@ -27,6 +27,7 @@
 -   Joe Frayne ([@jfrayne](https://github.com/jfrayne))
 -   John Burnett ([@johnburnett](https://github.com/johnburnett))
 -   Luke Stratman ([@lstratman](https://github.com/lstratman))
+-   Konstantin Posudevskiy ([@konstantin-posudevskiy](https://github.com/konstantin-posudevskiy))
 -   Matthias Dittrich ([@matthid](https://github.com/matthid))
 -   Patrick Stewart ([@patstew](https://github.com/patstew))
 -   Raphael Nestler ([@rnestler](https://github.com/rnestler))
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -20,6 +20,8 @@ This document follows the conventions laid out in [Keep a CHANGELOG][].
 -   Fixed crash on exit of the Python interpreter if a python class
     derived from a .NET class has a `__namespace__` or `__assembly__`
     attribute (#481)
+-   Fixed conversion of 'float' and 'double' values (#486)
+
 
 ## [2.3.0][] - 2017-03-11
 
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;
             }
diff --git a/src/tests/test_conversion.py b/src/tests/test_conversion.py
@@ -466,17 +466,6 @@ def test_double_conversion():
     with pytest.raises(TypeError):
         ConversionTest().DoubleField = None
 
-    with pytest.raises(OverflowError):
-        ConversionTest().DoubleField = 1.7976931348623159e308
-
-    with pytest.raises(OverflowError):
-        ConversionTest().DoubleField = -1.7976931348623159e308
-
-    with pytest.raises(OverflowError):
-        _ = System.Double(1.7976931348623159e308)
-
-    with pytest.raises(OverflowError):
-        _ = System.Double(-1.7976931348623159e308)
 
 
 def test_decimal_conversion():

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`	`}`