def test_torture_profile(self):
import time
total_time = 0
print("")
object_ = Everything.TestObj()
sys.stdout.write("\ttorture test 1 (10000 iterations): ")
start_time = time.clock()
for i in range(10000):
(y, z, q) = object_.torture_signature_0(5000, "Torture Test 1",
12345)
end_time = time.clock()
delta_time = end_time - start_time
total_time += delta_time
print("%f secs" % delta_time)
sys.stdout.write("\ttorture test 2 (10000 iterations): ")
start_time = time.clock()
for i in range(10000):
(y, z, q) = Everything.TestObj().torture_signature_0(
5000, "Torture Test 2", 12345)
end_time = time.clock()
delta_time = end_time - start_time
total_time += delta_time
print("%f secs" % delta_time)
sys.stdout.write("\ttorture test 3 (10000 iterations): ")
start_time = time.clock()
for i in range(10000):
try:
(y, z,
q) = object_.torture_signature_1(5000, "Torture Test 3",
12345)
except:
pass
end_time = time.clock()
delta_time = end_time - start_time
total_time += delta_time
print("%f secs" % delta_time)
sys.stdout.write("\ttorture test 4 (10000 iterations): ")
def callback(userdata):
return 0
userdata = [1, 2, 3, 4]
start_time = time.clock()
for i in range(10000):
(y, z,
q) = Everything.test_torture_signature_2(5000, callback, userdata,
"Torture Test 4", 12345)
end_time = time.clock()
delta_time = end_time - start_time
total_time += delta_time
print("%f secs" % delta_time)
print("\t====")
print("\tTotal: %f sec" % total_time)
def test_gtype(self):
object_ = Everything.TestObj()
self.assertEqual(object_.props.gtype, GObject.TYPE_INVALID)
object_.props.gtype = int
self.assertEqual(object_.props.gtype, GObject.TYPE_INT)
object_ = Everything.TestObj(gtype=int)
self.assertEqual(object_.props.gtype, GObject.TYPE_INT)
object_.props.gtype = str
self.assertEqual(object_.props.gtype, GObject.TYPE_STRING)
def test_gtype(self):
obj = Regress.TestObj()
self.assertEqual(self.get_prop(obj, 'gtype'), GObject.TYPE_INVALID)
self.set_prop(obj, 'gtype', int)
self.assertEqual(self.get_prop(obj, 'gtype'), GObject.TYPE_INT)
obj = Regress.TestObj(gtype=int)
self.assertEqual(self.get_prop(obj, 'gtype'), GObject.TYPE_INT)
self.set_prop(obj, 'gtype', str)
self.assertEqual(self.get_prop(obj, 'gtype'), GObject.TYPE_STRING)
def test_list(self):
object_ = Everything.TestObj()
self.assertEquals(object_.props.list, [])
object_.props.list = ['1', '2', '3']
self.assertTrue(isinstance(object_.props.list, list))
self.assertEquals(object_.props.list, ['1', '2', '3'])
def test_basic(self):
object_ = Everything.TestObj()
self.assertEqual(object_.props.int, 0)
object_.props.int = 42
self.assertTrue(isinstance(object_.props.int, int))
self.assertEqual(object_.props.int, 42)
self.assertEqual(object_.props.float, 0.0)
object_.props.float = 42.42
self.assertTrue(isinstance(object_.props.float, float))
self.assertAlmostEqual(object_.props.float, 42.42, places=5)
self.assertEqual(object_.props.double, 0.0)
object_.props.double = 42.42
self.assertTrue(isinstance(object_.props.double, float))
self.assertAlmostEqual(object_.props.double, 42.42, places=5)
self.assertEqual(object_.props.string, None)
object_.props.string = 'mec'
self.assertTrue(isinstance(object_.props.string, str))
self.assertEqual(object_.props.string, 'mec')
self.assertEqual(object_.props.gtype, GObject.TYPE_INVALID)
object_.props.gtype = int
self.assertEqual(object_.props.gtype, GObject.TYPE_INT)
def test_hash_table(self):
object_ = Everything.TestObj()
self.assertEquals(object_.props.hash_table, None)
object_.props.hash_table = {'mec': 56}
self.assertTrue(isinstance(object_.props.hash_table, dict))
self.assertEquals(list(object_.props.hash_table.items())[0], ('mec', 56))
def test_annotated_glist(self):
obj = Regress.TestObj()
self.assertEqual(self.get_prop(obj, 'list'), [])
self.set_prop(obj, 'list', ['1', '2', '3'])
self.assertTrue(isinstance(self.get_prop(obj, 'list'), list))
self.assertEqual(self.get_prop(obj, 'list'), ['1', '2', '3'])
def test_obj_skip_return_val_no_out(self):
obj = Everything.TestObj()
# raises an error for 0, succeeds for any other value
self.assertRaises(GLib.GError, obj.skip_return_val_no_out, 0)
ret = obj.skip_return_val_no_out(1)
self.assertEqual(ret, None)
def test_obj_skip_return_val(self):
obj = Everything.TestObj()
ret = obj.skip_return_val(50, 42.0, 60, 2, 3)
self.assertEqual(len(ret), 3)
self.assertEqual(ret[0], 51)
self.assertEqual(ret[1], 61)
self.assertEqual(ret[2], 32)
def test_callback_in_methods(self):
object_ = Everything.TestObj()
def callback():
TestCallbacks.called = True
return 42
TestCallbacks.called = False
object_.instance_method_callback(callback)
self.assertTrue(TestCallbacks.called)
TestCallbacks.called = False
Everything.TestObj.static_method_callback(callback)
self.assertTrue(TestCallbacks.called)
def callbackWithUserData(user_data):
TestCallbacks.called += 1
return 42
TestCallbacks.called = 0
Everything.TestObj.new_callback(callbackWithUserData, None)
self.assertEqual(TestCallbacks.called, 1)
# Note: using "new_callback" adds the notification to the same global
# list as Everything.test_callback_destroy_notify, so thaw the list
# so we don't get confusion between tests.
self.assertEqual(Everything.test_callback_thaw_notifications(), 42)
self.assertEqual(TestCallbacks.called, 2)
def test_hash_table(self):
obj = Regress.TestObj()
self.assertEqual(self.get_prop(obj, 'hash-table'), None)
self.set_prop(obj, 'hash-table', {'mec': 56})
self.assertTrue(isinstance(self.get_prop(obj, 'hash-table'), dict))
self.assertEqual(list(self.get_prop(obj, 'hash-table').items())[0],
('mec', 56))
def test_object_argument_type_error(self):
# ensure TypeError is raised for things which are not GObjects
obj = Regress.TestObj()
obj.set_bare(GObject.Object())
obj.set_bare(None)
self.assertRaises(TypeError, obj.set_bare, object())
self.assertRaises(TypeError, obj.set_bare, 42)
self.assertRaises(TypeError, obj.set_bare, 'not an object')
def test_object_param_signal(self):
obj = Everything.TestObj()
def callback(obj, obj_param):
self.assertEqual(obj_param.props.int, 3)
self.assertGreater(obj_param.__grefcount__, 1)
obj.connect('sig-with-obj', callback)
obj.emit_sig_with_obj()
def test_instance_argument_base_type_error(self):
# ensure TypeError is raised when a base type is passed to something
# expecting a derived type
obj = Regress.TestSubObj()
self.assertEqual(Regress.TestSubObj.instance_method(obj), 0)
self.assertRaises(TypeError, Regress.TestSubObj.instance_method,
GObject.Object())
self.assertRaises(TypeError, Regress.TestSubObj.instance_method,
Regress.TestObj())
def test_instance_argument_error(self):
# ensure TypeError is raised for non Regress.TestObj instances.
obj = Regress.TestObj()
self.assertEqual(Regress.TestObj.instance_method(obj), -1)
self.assertRaises(TypeError, Regress.TestObj.instance_method, object())
self.assertRaises(TypeError, Regress.TestObj.instance_method,
GObject.Object())
self.assertRaises(TypeError, Regress.TestObj.instance_method, 42)
self.assertRaises(TypeError, Regress.TestObj.instance_method,
'not an object')
def test_boxed(self):
object_ = Everything.TestObj()
self.assertEqual(object_.props.boxed, None)
boxed = Everything.TestBoxed()
boxed.some_int8 = 42
object_.props.boxed = boxed
self.assertTrue(isinstance(object_.props.boxed, Everything.TestBoxed))
self.assertEqual(object_.props.boxed.some_int8, 42)
def test_interface(self):
s = Regress.TestStructC()
obj = Regress.TestObj()
s.obj = obj
self.assertTrue(s.obj is obj)
s.obj = None
self.assertTrue(s.obj is None)
self.assertRaises(TypeError, setattr, s, "obj", object())
def test_uint64_param_from_c(self):
obj = Everything.TestObj()
def callback(obj, i):
obj.callback_i = i
return i
obj.callback_i = None
obj.connect('sig-with-uint64-prop', callback)
obj.emit_sig_with_uint64()
self.assertEqual(obj.callback_i, GObject.G_MAXUINT64)
def test_int64_param_from_py(self):
obj = Everything.TestObj()
def callback(obj, i):
obj.callback_i = i
return i
obj.callback_i = None
obj.connect('sig-with-int64-prop', callback)
rv = obj.emit('sig-with-int64-prop', GObject.G_MAXINT64)
self.assertEqual(rv, GObject.G_MAXINT64)
self.assertEqual(obj.callback_i, GObject.G_MAXINT64)
def test_intarray_ret(self):
obj = Everything.TestObj()
def callback(obj, i):
obj.callback_i = i
return [i, i + 1]
obj.callback_i = None
try:
obj.connect('sig-with-intarray-ret', callback)
except TypeError as e:
# compat with g-i 1.34.x
if 'unknown signal' in str(e):
return
raise
rv = obj.emit('sig-with-intarray-ret', 42)
self.assertEqual(obj.callback_i, 42)
self.assertEqual(type(rv), GLib.Array)
self.assertEqual(rv.len, 2)
def testCallbackInMethods(self):
object_ = Everything.TestObj()
def callback():
TestCallbacks.called = True
return 42
TestCallbacks.called = False
object_.instance_method_callback(callback)
self.assertTrue(TestCallbacks.called)
TestCallbacks.called = False
Everything.TestObj.static_method_callback(callback)
self.assertTrue(TestCallbacks.called)
def callbackWithUserData(user_data):
TestCallbacks.called = True
return 42
TestCallbacks.called = False
obj_ = Everything.TestObj.new_callback(callbackWithUserData, None)
self.assertTrue(TestCallbacks.called)
def test_main(self):
obj = Everything.TestObj()
for _ in range(10):
obj.instance_method_full()
def test_ghashtable(self):
obj = Regress.TestObj()
self.assertTrue(obj.hash_table is None)
def test_regress(self):
res = Regress.TestObj().skip_return_val(50, 42.0, 60, 2, 3)
self.assertEqual(repr(res), "(out_b=51, inout_d=61, out_sum=32)")
