def testStrictWeakOrder(self):
"""Use svtkVariantStrictWeakOrder to sort a list of svtkVariants"""
original = [1, 2.5, svtk.svtkVariant(), "0", cedilla]
ordered = [svtk.svtkVariant(), 1, 2.5, "0", cedilla]
l = [svtk.svtkVariant(x) for x in original]
s = [svtk.svtkVariant(x) for x in ordered]
l.sort(key=svtk.svtkVariantStrictWeakOrderKey)
self.assertEqual(l, s)
def testCompare(self):
"""Use comparison operators to sort a list of svtkVariants"""
original = [1, 2.5, svtk.svtkVariant(), "0", cedilla]
ordered = [svtk.svtkVariant(), "0", 1, 2.5, cedilla]
l = [svtk.svtkVariant(x) for x in original]
s = [svtk.svtkVariant(x) for x in ordered]
l.sort()
self.assertEqual(l, s)
def testBoolPointer(self):
v = svtk.svtkVariant("1")
bp = [False]
d = v.ToFloat(bp)
self.assertEqual(bp, [True])
v = svtk.svtkVariant("George")
d = v.ToFloat(bp)
self.assertEqual(bp, [False])
def testComparisonMethods(self):
v1 = svtk.svtkVariant(10)
v2 = svtk.svtkVariant("10")
# compare without regards to type
self.assertEqual(svtk.svtkVariantEqual(v1, v2), True)
self.assertEqual(svtk.svtkVariantLessThan(v1, v2), False)
# compare with different types being non-equivalent
self.assertEqual(svtk.svtkVariantStrictEquality(v1, v2), False)
if sys.hexversion >= 0x03000000:
self.assertEqual(svtk.svtkVariantStrictWeakOrder(v1, v2), True)
else:
# for Python 2, it worked like the cmp() function
self.assertEqual(svtk.svtkVariantStrictWeakOrder(v1, v2), -1)
def testObjectConstructor(self):
"""Construct from SVTK object"""
o = svtk.svtkIntArray()
v = svtk.svtkVariant(o)
self.assertEqual(v.GetType(), svtk.SVTK_OBJECT)
self.assertEqual(v.GetTypeAsString(), o.GetClassName())
self.assertEqual(v.ToSVTKObject(), o)
def testConstructors(self):
"""Test overloaded constructors"""
# resolve by number of arguments
v = svtk.svtkVector3d(3, 4, 5)
self.assertEqual((v[0], v[1], v[2]), (3, 4, 5))
v = svtk.svtkVector3d(6)
self.assertEqual((v[0], v[1], v[2]), (6, 6, 6))
# resolve by argument type
v = svtk.svtkVariant(3.0)
self.assertEqual(v.GetType(), svtk.SVTK_DOUBLE)
v = svtk.svtkVariant(1)
self.assertEqual(v.GetType(), svtk.SVTK_INT)
v = svtk.svtkVariant("hello")
self.assertEqual(v.GetType(), svtk.SVTK_STRING)
v = svtk.svtkVariant(svtk.svtkObject())
self.assertEqual(v.GetType(), svtk.SVTK_OBJECT)
def testPassByValueReturnByReference(self):
"""Pass svtkVariant by value, return by reference"""
a = svtk.svtkVariantArray()
a.SetNumberOfValues(1)
v = svtk.svtkVariant(1)
a.SetValue(0, v)
u = a.GetValue(0)
self.assertEqual(u.ToInt(), v.ToInt())
self.assertEqual(u.GetType(), v.GetType())
self.assertEqual(u.IsValid(), v.IsValid())
def testPassByReferenceReturnByValue(self):
"""Pass svtkVariant by reference, return by value."""
a = svtk.svtkArray.CreateArray(1, svtk.SVTK_INT)
a.Resize(1,1)
v = svtk.svtkVariant(1)
a.SetVariantValue(0, 0, v)
u = a.GetVariantValue(0, 0)
self.assertEqual(u.ToInt(), v.ToInt())
self.assertEqual(u.GetType(), v.GetType())
self.assertEqual(u.IsValid(), v.IsValid())
def testArgumentConversion(self):
"""Test argument conversion via implicit constructors"""
# automatic conversion to svtkVariant
a = svtk.svtkVariantArray()
a.InsertNextValue(2.5)
a.InsertNextValue(svtk.svtkObject())
self.assertEqual(a.GetValue(0), svtk.svtkVariant(2.5))
self.assertEqual(a.GetValue(1).GetType(), svtk.SVTK_OBJECT)
# same, but this one is via "const svtkVariant&" argument
a = svtk.svtkDenseArray[float]()
a.Resize(1)
a.SetVariantValue(0, 2.5)
self.assertEqual(a.GetVariantValue(0).ToDouble(), 2.5)
def testSparseArray(self):
"""Test svtkSparseArray template"""
for t in (arrayTypes + arrayCodes):
a = svtk.svtkSparseArray[t]()
a.Resize(1)
i = svtk.svtkArrayCoordinates(0)
if t in ['bool', '?']:
value = 0
a.SetValue(i, value)
result = a.GetValue(i)
self.assertEqual(value, result)
elif t in ['float32', 'float64', 'float', 'f', 'd']:
value = 3.125
a.SetValue(i, value)
result = a.GetValue(i)
self.assertEqual(value, result)
elif t in ['char', 'c']:
value = 'c'
a.SetValue(i, value)
result = a.GetValue(i)
self.assertEqual(value, result)
elif t in [str, 'str']:
value = "hello"
a.SetValue(i, value)
result = a.GetValue(i)
self.assertEqual(value, result)
elif t in ['unicode']:
value = francois
a.SetValue(i, value)
result = a.GetValue(i)
self.assertEqual(value, result)
elif t in ['svtkVariant', svtk.svtkVariant]:
value = svtk.svtkVariant("world")
a.SetValue(i, value)
result = a.GetValue(i)
self.assertEqual(value, result)
else:
value = 12
a.SetValue(i, value)
result = a.GetValue(i)
self.assertEqual(value, result)
def testAutomaticArgConversion(self):
"""Automatic construction of variants to resolve args"""
# use with one of svtkVariant's own constructors
v = svtk.svtkVariant('10', svtk.SVTK_INT)
self.assertEqual(v.ToInt(), 10)
self.assertEqual(v.GetType(), svtk.SVTK_INT)
# use with svtkVariantArray
a = svtk.svtkVariantArray()
i = a.InsertNextValue(10)
v = a.GetValue(i)
self.assertEqual(v.GetType(), svtk.SVTK_INT)
self.assertEqual(v.ToInt(), 10)
i = a.InsertNextValue(10.0)
v = a.GetValue(i)
self.assertEqual(v.GetType(), svtk.SVTK_DOUBLE)
self.assertEqual(v.ToDouble(), 10.0)
i = a.InsertNextValue('10')
v = a.GetValue(i)
self.assertEqual(v.GetType(), svtk.SVTK_STRING)
self.assertEqual(v.ToString(), '10')
def testTwoArgConstructor(self):
"""Construct with a specific type"""
# construct with conversion to int
v = svtk.svtkVariant('10')
u = svtk.svtkVariant(v, svtk.SVTK_INT)
self.assertEqual(u.GetType(), svtk.SVTK_INT)
self.assertEqual(v.ToInt(), u.ToInt())
# construct with conversion to double
v = svtk.svtkVariant(10)
u = svtk.svtkVariant(v, svtk.SVTK_DOUBLE)
self.assertEqual(u.GetType(), svtk.SVTK_DOUBLE)
self.assertEqual(u.ToDouble(), 10.0)
# failed conversion to svtkObject
v = svtk.svtkVariant(10)
u = svtk.svtkVariant(v, svtk.SVTK_OBJECT)
self.assertEqual(u.IsValid(), False)
def testCopyConstructor(self):
"""Construct from another svtkVariant"""
u = svtk.svtkVariant('test')
v = svtk.svtkVariant(u)
self.assertEqual(v.GetType(), svtk.SVTK_STRING)
self.assertEqual(v.ToString(), u.ToString())
def testVariantExtract(self):
"""Use svtkVariantExtract"""
l = [1, '2', cedilla, 4.0, svtk.svtkObject()]
s = [svtk.svtkVariant(x) for x in l]
m = [svtk.svtkVariantExtract(x) for x in s]
self.assertEqual(l, m)
def testHash(self):
"""Use a variant as a dict key"""
d = {}
# doubles, ints, strings, all hash as strings
d[svtk.svtkVariant(1.0)] = 'double'
d[svtk.svtkVariant(1)] = 'int'
self.assertEqual(d[svtk.svtkVariant('1')], 'int')
# strings and unicode have the same hash
d[svtk.svtkVariant('s').ToString()] = 'string'
d[svtk.svtkVariant('s').ToUnicodeString()] = 'unicode'
self.assertEqual(d[svtk.svtkVariant('s').ToString()], 'unicode')
# every svtkObject is hashed by memory address
o1 = svtk.svtkIntArray()
o2 = svtk.svtkIntArray()
d[svtk.svtkVariant(o1)] = 'svtkIntArray1'
d[svtk.svtkVariant(o2)] = 'svtkIntArray2'
self.assertEqual(d[svtk.svtkVariant(o1)], 'svtkIntArray1')
self.assertEqual(d[svtk.svtkVariant(o2)], 'svtkIntArray2')
# invalid variants all hash the same
d[svtk.svtkVariant()] = 'invalid'
self.assertEqual(d[svtk.svtkVariant()], 'invalid')
def testUnicodeConstructor(self):
"""Construct from unicode"""
v = svtk.svtkVariant(cedilla)
self.assertEqual(v.GetType(), svtk.SVTK_UNICODE_STRING)
self.assertEqual(v.ToUnicodeString(), cedilla)
def testBytesConstructor(self):
"""Construct from bytes"""
v = svtk.svtkVariant(b'hello')
self.assertEqual(v.GetType(), svtk.SVTK_STRING)
self.assertEqual(v.ToString(), 'hello')
def testFloatConstructor(self):
"""Construct from float"""
v = svtk.svtkVariant(10.0)
self.assertEqual(v.GetType(), svtk.SVTK_DOUBLE)
self.assertEqual(v.ToDouble(), 10.0)
def testIntConstructor(self):
"""Construct from int"""
v = svtk.svtkVariant(10)
self.assertEqual(v.GetType(), svtk.SVTK_INT)
self.assertEqual(v.ToInt(), 10)
def testDefaultConstructor(self):
"""Default constructor"""
v = svtk.svtkVariant()
self.assertEqual(v.IsValid(), False)
self.assertEqual(v.GetType(), 0)