Fix arg conversion of const ref arg via constructor.

There was a simple mistake in the code that builds the "ArgCheck"
string that the wrappers use for argument type checking.  As a
result, the "argument check" was not distinguishing between const
reference args and non-const reference args.  A "const reference"
arg type can satisfied via implicit conversion from another type,
while a non-const reference arg cannot.  The new test specifically
tests for this.

Change-Id: I59725536496dd6d80b64ace09403161ccd89c9b4

Common/Core/Testing/Python/CMakeLists.txt

@@ -10,6 +10,7 @@ vtk_add_test_python(
   TestNumpySupport.py
   TestNumpyInterface.py
   TestOperators.py
+  TestOverloads.py
   TestPointers.py
   TestStrings.py
   TestSubClass.py

Common/Core/Testing/Python/TestOverloads.py

+"""Test overloaded method resolution in VTK-Python
+
+The wrappers should call overloaded C++ methods using similar
+overload resolution rules as C++.  Python itself does not have
+method overloading.
+
+Created on Feb 15, 2015 by David Gobbi
+
+"""
+
+import sys
+import exceptions
+import vtk
+from vtk.test import Testing
+
+class TestOverloads(Testing.vtkTest):
+
+    def testMethods(self):
+        """Test overloaded methods"""
+        # single-argument method vtkTransform::SetMatrix()
+        t = vtk.vtkTransform()
+        m = vtk.vtkMatrix4x4()
+        m.SetElement(0, 0, 2)
+        t.SetMatrix(m)
+        self.assertEqual(t.GetMatrix().GetElement(0, 0), 2)
+        t.SetMatrix([0,1,0,0, 1,0,0,0, 0,0,-1,0, 0,0,0,1])
+        self.assertEqual(t.GetMatrix().GetElement(0, 0), 0)
+        # mixed number of arguments
+        w = vtk.vtkRenderWindow()
+        w.SetTileScale(2)
+        self.assertEqual(w.GetTileScale(), (2,2))
+        w.SetTileScale(3,4)
+        self.assertEqual(w.GetTileScale(), (3,4))
+
+    def testConstructors(self):
+        """Test overloaded constructors"""
+        # resolve by number of arguments
+        v = vtk.vtkVector3d(3, 4, 5)
+        self.assertEqual((v[0], v[1], v[2]), (3, 4, 5))
+        v = vtk.vtkVector3d(6)
+        self.assertEqual((v[0], v[1], v[2]), (6, 6, 6))
+        # resolve by argument type
+        v = vtk.vtkVariant(3.0)
+        self.assertEqual(v.GetType(), vtk.VTK_DOUBLE)
+        v = vtk.vtkVariant(1)
+        self.assertEqual(v.GetType(), vtk.VTK_INT)
+        v = vtk.vtkVariant("hello")
+        self.assertEqual(v.GetType(), vtk.VTK_STRING)
+        v = vtk.vtkVariant(vtk.vtkObject())
+        self.assertEqual(v.GetType(), vtk.VTK_OBJECT)
+
+    def testArgumentConversion(self):
+        """Test argument conversion via implicit constructors"""
+        # automatic conversion to vtkVariant
+        a = vtk.vtkVariantArray()
+        a.InsertNextValue(2.5)
+        a.InsertNextValue(vtk.vtkObject())
+        self.assertEqual(a.GetValue(0), vtk.vtkVariant(2.5))
+        self.assertEqual(a.GetValue(1).GetType(), vtk.VTK_OBJECT)
+        # same, but this one is via "const vtkVariant&" argument
+        a = vtk.vtkDenseArray[float]()
+        a.Resize(1)
+        a.SetVariantValue(0, 2.5)
+        self.assertEqual(a.GetVariantValue(0).ToDouble(), 2.5)
+
+
+if __name__ == "__main__":
+    Testing.main([(TestOverloads, 'test')])

Wrapping/Tools/vtkWrapPythonOverload.c

@@ -307,7 +307,7 @@ static char *vtkWrapPython_ArgCheckString(
       result[currPos++] = ' ';
       if ((argtype == VTK_PARSE_OBJECT_REF ||
            argtype == VTK_PARSE_UNKNOWN_REF) &&
-          (argtype & VTK_PARSE_CONST) == 0)
+          (arg->Type & VTK_PARSE_CONST) == 0)
         {
         result[currPos++] = '&';
         }