@@ -5,7 +5,7 @@
 
 namespace Python.EmbeddingTest
 {
-    public class dynamicTest
+    public class DynamicTest
     {
         private Py.GILState gil;
 
 
@@ -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]
 
@@ -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