Add tests/refactor existing

vmuriart · vmuriart · commit 5070db0dfdd6 · 2017-02-26T23:46:56.000-07:00
diff --git a/src/embed_tests/dynamic.cs b/src/embed_tests/dynamic.cs
@@ -5,7 +5,7 @@
 
 namespace Python.EmbeddingTest
 {
-    public class dynamicTest
+    public class DynamicTest
     {
         private Py.GILState gil;
 
diff --git a/src/embed_tests/pythonexception.cs b/src/embed_tests/pythonexception.cs
@@ -33,14 +33,12 @@ public void Dispose()
         public void TestMessage()
         {
             var list = new PyList();
-            try
-            {
-                PyObject junk = list[0];
-            }
-            catch (PythonException e)
-            {
-                Assert.AreEqual("IndexError : list index out of range", e.Message);
-            }
+            PyObject foo = null;
+
+            var ex = Assert.Throws<PythonException>(() => foo = list[0]);
+
+            Assert.AreEqual("IndexError : list index out of range", ex.Message);
+            Assert.IsNull(foo);
         }
 
         [Test]
diff --git a/src/embed_tests/pytuple.cs b/src/embed_tests/pytuple.cs
@@ -43,6 +43,21 @@ public void TestPyTupleEmpty()
             }
         }
 
+        [Test]
+        public void TestPyTupleBadCtor()
+        {
+            using (Py.GIL())
+            {
+                var i = new PyInt(5);
+                PyTuple t = null;
+
+                var ex = Assert.Throws<ArgumentException>(() => t = new PyTuple(i));
+
+                Assert.AreEqual("object is not a tuple", ex.Message);
+                Assert.IsNull(t);
+            }
+        }
+
         /// <summary>
         /// Test PyTuple.Concat(...) doesn't let invalid appends happen
         /// and throws and exception.
@@ -51,6 +66,8 @@ public void TestPyTupleEmpty()
         /// Test has second purpose. Currently it generated an Exception
         /// that the GC failed to remove often and caused AppDomain unload
         /// errors at the end of tests. See GH#397 for more info.
+        /// <para />
+        /// Curious, on PY27 it gets a Unicode on the ex.Message. On PY3+ its string.
         /// </remarks>
         [Test]
         public void TestPyTupleInvalidAppend()
@@ -59,7 +76,12 @@ public void TestPyTupleInvalidAppend()
             {
                 PyObject s = new PyString("foo");
                 var t = new PyTuple();
-                Assert.Throws<PythonException>(() => t.Concat(s));
+
+                var ex = Assert.Throws<PythonException>(() => t.Concat(s));
+
+                StringAssert.StartsWith("TypeError : can only concatenate tuple", ex.Message);
+                Assert.AreEqual(0, t.Length());
+                Assert.IsEmpty(t);
             }
         }
 
@@ -114,5 +136,23 @@ public void TestNewPyTupleFromPyTuple()
                 Assert.IsInstanceOf(typeof(PyTuple), t);
             }
         }
+
+        /// <remarks>
+        /// TODO: Should this throw ArgumentError instead?
+        /// </remarks>
+        [Test]
+        public void TestInvalidAsTuple()
+        {
+            using (Py.GIL())
+            {
+                var i = new PyInt(5);
+                PyTuple t = null;
+
+                var ex = Assert.Throws<PythonException>(() => t = PyTuple.AsTuple(i));
+
+                Assert.AreEqual("TypeError : 'int' object is not iterable", ex.Message);
+                Assert.IsNull(t);
+            }
+        }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@`
`5`	`5`
`6`	`6`	`namespace Python.EmbeddingTest`
`7`	`7`	`{`
`8`		`- public class dynamicTest`
	`8`	`+ public class DynamicTest`
`9`	`9`	`{`
`10`	`10`	`private Py.GILState gil;`
`11`	`11`