def testTakeValuesFromDictionary(self):
o = KeyValueClass1Explicit.alloc().init()
self.assertEqual(o._values["key3"], 3)
self.assertEqual(o._values["key4"], b"4".decode("ascii"))
o._values["key5"] = 1
self.assertNotIn("key9", o._values)
STUB.setKeyValue_forObject_key_value_(
3,
o,
None,
{
b"key3".decode("ascii"): b"drie".decode("ascii"),
b"key4".decode("ascii"): b"vier".decode("ascii"),
b"key5".decode("ascii"): b"V".decode("ascii"),
b"key9".decode("ascii"): b"IX".decode("ascii"),
},
)
self.assertEqual(o._values["key3"], b"drie".decode("ascii"))
self.assertEqual(o._values["key4"],
b"viervierviervier".decode("ascii"))
self.assertEqual(o._values["key5"], b"VVVVV".decode("ascii"))
self.assertEqual(o._values["key9"], b"IX".decode("ascii"))
def testKVO2(self):
"""
Check if observations work for python-based keys on ObjC classes
"""
observer = KeyValueObserver.alloc().init()
self.assertEqual(observer.observed, [])
o = KeyValueClass1.alloc().init()
o.addObserver_forKeyPath_options_context_(observer,
b"key3".decode("ascii"),
0, 0)
try:
STUB.setKeyValue_forObject_key_value_(2, o,
b"key3".decode("ascii"),
b"drie".decode("ascii"))
self.assertEqual(o.key3, b"drie".decode("ascii"))
self.assertEqual(len(observer.observed), 1)
keyPath, object, change = observer.observed[0]
self.assertEqual(keyPath, b"key3".decode("ascii"))
self.assertIs(object, o)
self.assertEqual(change, {NSKeyValueChangeKindKey: 1})
finally:
o.removeObserver_forKeyPath_(observer, b"key3".decode("ascii"))
def testKVO3(self):
"""
Check if observations work for python-based keys on ObjC classes
"""
observer = KeyValueObserver.alloc().init()
self.assertEquals(observer.observed, [])
o = KeyValueClass1.alloc().init()
STUB.setKeyValue_forObject_key_value_(2, o, u'key3', u'three')
o.addObserver_forKeyPath_options_context_(
observer, u"key3",
NSKeyValueObservingOptionNew | NSKeyValueObservingOptionOld, 0)
try:
STUB.setKeyValue_forObject_key_value_(2, o, u'key3', u'drie')
self.assertEquals(o.key3, u"drie")
self.assertEquals(len(observer.observed), 1)
keyPath, object, change = observer.observed[0]
self.assertEquals(keyPath, u"key3")
self.assert_(object is o)
self.assertEquals(
change, {
NSKeyValueChangeKindKey: 1,
NSKeyValueChangeNewKey: u'drie',
NSKeyValueChangeOldKey: u'three'
})
finally:
o.removeObserver_forKeyPath_(observer, u'key3')
def testKVO3(self):
"""
Check if observations work for python-based keys on ObjC classes
"""
observer = KeyValueObserver.alloc().init()
self.assertEqual(observer.observed, [])
o = KeyValueClass1.alloc().init()
STUB.setKeyValue_forObject_key_value_(2, o, b'key3'.decode('ascii'), b'three'.decode('ascii'))
o.addObserver_forKeyPath_options_context_(observer, b"key3".decode('ascii'),
NSKeyValueObservingOptionNew|NSKeyValueObservingOptionOld,
0)
try:
STUB.setKeyValue_forObject_key_value_(2, o, b'key3'.decode('ascii'), b'drie'.decode('ascii'))
self.assertEqual(o.key3, b"drie".decode('ascii'))
self.assertEqual(len(observer.observed), 1)
keyPath, object, change = observer.observed[0]
self.assertEqual(keyPath, b"key3".decode('ascii'))
self.assert_(object is o)
self.assertEqual(change,
{
NSKeyValueChangeKindKey:1,
NSKeyValueChangeNewKey:b'drie'.decode('ascii'),
NSKeyValueChangeOldKey:b'three'.decode('ascii')
})
finally:
o.removeObserver_forKeyPath_(observer, b'key3'.decode('ascii'))
def testKVO3(self):
"""
Check if observations work for python-based keys on ObjC classes
"""
observer = KeyValueObserver.alloc().init()
self.assertEquals(observer.observed, [])
o = KeyValueClass1.alloc().init()
STUB.setKeyValue_forObject_key_value_(2, o, u'key3', u'three')
o.addObserver_forKeyPath_options_context_(observer, u"key3",
NSKeyValueObservingOptionNew|NSKeyValueObservingOptionOld,
0)
try:
STUB.setKeyValue_forObject_key_value_(2, o, u'key3', u'drie')
self.assertEquals(o.key3, u"drie")
self.assertEquals(len(observer.observed), 1)
keyPath, object, change = observer.observed[0]
self.assertEquals(keyPath, u"key3")
self.assert_(object is o)
self.assertEquals(change,
{
NSKeyValueChangeKindKey:1,
NSKeyValueChangeNewKey:u'drie',
NSKeyValueChangeOldKey:u'three'
})
finally:
o.removeObserver_forKeyPath_(observer, u'key3')
def testTakeValuesFromDictionary(self):
o = KeyValueClass1.alloc().init()
self.assertEqual(o.key3, 3)
self.assertEqual(o._key4, b"4".decode("ascii"))
o.key5 = 1
self.assertNotHasAttr(o, b"key9".decode("ascii"))
STUB.setKeyValue_forObject_key_value_(
3,
o,
None,
{
b"key3".decode("ascii"): b"drie".decode("ascii"),
b"key4".decode("ascii"): b"vier".decode("ascii"),
b"key5".decode("ascii"): b"V".decode("ascii"),
b"key9".decode("ascii"): b"IX".decode("ascii"),
},
)
self.assertEqual(o.key3, b"drie".decode("ascii"))
self.assertEqual(o._key4, b"viervierviervier".decode("ascii"))
self.assertEqual(o.key5, b"VVVVV".decode("ascii"))
self.assertHasAttr(o, b"key9".decode("ascii"))
self.assertEqual(o.key9, b"IX".decode("ascii"))
def testTakeValueForKeyPath(self):
o = KeyValueClass1Explicit.alloc().init()
o.addMultiple()
self.assertEqual(
o._values["multiple"]._values["level2"]._values["level3"].
_values["keyA"],
"hello",
)
self.assertEqual(
o._values["multiple"]._values["level2"]._values["level3"].
_values["keyB"],
"world",
)
STUB.setKeyValue_forObject_key_value_(1, o,
"multiple.level2.level3.keyA",
"KeyAValue")
self.assertEqual(
o._values["multiple"]._values["level2"]._values["level3"].
_values["keyA"],
"KeyAValue",
)
STUB.setKeyValue_forObject_key_value_(1, o,
"multiple.level2.level3.keyB",
9.999)
self.assertEqual(
o._values["multiple"]._values["level2"]._values["level3"].
_values["keyB"],
9.999,
)
def testKVO3(self):
"""
Check if observations work for python-based keys on ObjC classes
"""
observer = KeyValueObserver.alloc().init()
self.assertEqual(observer.observed, [])
o = KeyValueClass1.alloc().init()
STUB.setKeyValue_forObject_key_value_(2, o,
b'key3'.decode('ascii'),
b'three'.decode('ascii'))
o.addObserver_forKeyPath_options_context_(
observer, b"key3".decode('ascii'),
NSKeyValueObservingOptionNew | NSKeyValueObservingOptionOld, 0)
try:
STUB.setKeyValue_forObject_key_value_(2, o,
b'key3'.decode('ascii'),
b'drie'.decode('ascii'))
self.assertEqual(o.key3, b"drie".decode('ascii'))
self.assertEqual(len(observer.observed), 1)
keyPath, object, change = observer.observed[0]
self.assertEqual(keyPath, b"key3".decode('ascii'))
self.assert_(object is o)
self.assertEqual(
change, {
NSKeyValueChangeKindKey: 1,
NSKeyValueChangeNewKey: b'drie'.decode('ascii'),
NSKeyValueChangeOldKey: b'three'.decode('ascii')
})
finally:
o.removeObserver_forKeyPath_(observer, b'key3'.decode('ascii'))
def testTakeValueForKey2(self):
o = KeyValueClass4.alloc().init()
self.assertEquals(o.foo, u"foobar")
STUB.setKeyValue_forObject_key_value_(0, o, u'foo', u'FOO')
self.assertEquals(o.foo, u"FOO")
self.assertRaises(KeyError, STUB.setKeyValue_forObject_key_value_, 0, o, u'key9', u'IX')
def testTakeValueForKey2(self):
o = KeyValueClass4.alloc().init()
self.assertEqual(o.foo, b"foobar".decode('ascii'))
STUB.setKeyValue_forObject_key_value_(0, o, b'foo'.decode('ascii'), b'FOO'.decode('ascii'))
self.assertEqual(o.foo, b"FOO".decode('ascii'))
self.assertRaises(KeyError, STUB.setKeyValue_forObject_key_value_, 0, o, b'key9'.decode('ascii'), b'IX'.decode('ascii'))
def testTakeValueForKey2(self):
o = KeyValueClass4.alloc().init()
self.assertEquals(o.foo, u"foobar")
STUB.setKeyValue_forObject_key_value_(0, o, u'foo', u'FOO')
self.assertEquals(o.foo, u"FOO")
self.assertRaises(KeyError, STUB.setKeyValue_forObject_key_value_, 0,
o, u'key9', u'IX')
def testTakeValuesFromDictionary2(self):
o = KeyValueClass4.alloc().init()
self.assertEqual(o.foo, b"foobar".decode('ascii'))
STUB.setKeyValue_forObject_key_value_(3, o, None, { b'foo'.decode('ascii'): b'FOO'.decode('ascii') })
self.assertEqual(o.foo, b"FOO".decode('ascii'))
self.assertRaises(KeyError, STUB.setKeyValue_forObject_key_value_, 3, o, None, { b'key9'.decode('ascii'): b'IX'.decode('ascii') })
self.assertRaises(KeyError, STUB.setKeyValue_forObject_key_value_, 3, o, None, { b'roprop'.decode('ascii'): b'IX'.decode('ascii') })
def testTakeValueForKey2(self):
o = KeyValueClass4.alloc().init()
self.assertEqual(o.foo, "foobar")
STUB.setKeyValue_forObject_key_value_(0, o, "foo", "FOO")
self.assertEqual(o.foo, "FOO")
self.assertRaises(KeyError, STUB.setKeyValue_forObject_key_value_, 0,
o, "key9", "IX")
def testTakeValuesFromDictionary2(self):
o = KeyValueClass4.alloc().init()
self.assertEquals(o.foo, u"foobar")
STUB.setKeyValue_forObject_key_value_(3, o, None, { u'foo': u'FOO' })
self.assertEquals(o.foo, u"FOO")
self.assertRaises(KeyError, STUB.setKeyValue_forObject_key_value_, 3, o, None, { u'key9': u'IX' })
self.assertRaises(KeyError, STUB.setKeyValue_forObject_key_value_, 3, o, None, { u'roprop': u'IX' })
def testTakeValuesFromDictionary2(self):
o = KeyValueClass4.alloc().init()
self.assertEquals(o.foo, u"foobar")
STUB.setKeyValue_forObject_key_value_(3, o, None, {u'foo': u'FOO'})
self.assertEquals(o.foo, u"FOO")
self.assertRaises(KeyError, STUB.setKeyValue_forObject_key_value_, 3,
o, None, {u'key9': u'IX'})
self.assertRaises(KeyError, STUB.setKeyValue_forObject_key_value_, 3,
o, None, {u'roprop': u'IX'})
def testTakeValueForKeyPath(self):
o = KeyValueClass1Explicit.alloc().init()
o.addMultiple()
self.assertEquals(o._values['multiple']._values['level2']._values['level3']._values['keyA'], u"hello")
self.assertEquals(o._values['multiple']._values['level2']._values['level3']._values['keyB'], u"world")
STUB.setKeyValue_forObject_key_value_(1, o, u"multiple.level2.level3.keyA", u"KeyAValue")
self.assertEquals(o._values['multiple']._values['level2']._values['level3']._values['keyA'], u"KeyAValue")
STUB.setKeyValue_forObject_key_value_(1, o, u"multiple.level2.level3.keyB", 9.999)
self.assertEquals(o._values['multiple']._values['level2']._values['level3']._values['keyB'], 9.999)
def testTakeValueForKeyPath(self):
o = KeyValueClass1Explicit.alloc().init()
o.addMultiple()
self.assertEqual(o._values['multiple']._values['level2']._values['level3']._values['keyA'], b"hello".decode('ascii'))
self.assertEqual(o._values['multiple']._values['level2']._values['level3']._values['keyB'], b"world".decode('ascii'))
STUB.setKeyValue_forObject_key_value_(1, o, b"multiple.level2.level3.keyA".decode('ascii'), b"KeyAValue".decode('ascii'))
self.assertEqual(o._values['multiple']._values['level2']._values['level3']._values['keyA'], b"KeyAValue".decode('ascii'))
STUB.setKeyValue_forObject_key_value_(1, o, b"multiple.level2.level3.keyB".decode('ascii'), 9.999)
self.assertEqual(o._values['multiple']._values['level2']._values['level3']._values['keyB'], 9.999)
def testTakeValueForKeyPath(self):
o = KeyValueClass1.alloc().init()
o.addMultiple()
self.assertEquals(o.multiple.level2.level3.keyA, u"hello")
self.assertEquals(o.multiple.level2.level3.keyB, u"world")
STUB.setKeyValue_forObject_key_value_(1, o, u"multiple.level2.level3.keyA", u"KeyAValue")
self.assertEquals(o.multiple.level2.level3.keyA, u"KeyAValue")
STUB.setKeyValue_forObject_key_value_(1, o, u"multiple.level2.level3.keyB", 9.999)
self.assertEquals(o.multiple.level2.level3.keyB, 9.999)
def testTakeValueForKey(self):
o = KeyValueClass1Explicit.alloc().init()
self.assertEqual(o._values["key3"], 3)
STUB.setKeyValue_forObject_key_value_(0, o, b"key3".decode("ascii"),
b"drie".decode("ascii"))
self.assertEqual(o._values["key3"], b"drie".decode("ascii"))
self.assertEqual(o._values["key4"], b"4".decode("ascii"))
STUB.setKeyValue_forObject_key_value_(0, o, b"key4".decode("ascii"),
b"vier".decode("ascii"))
self.assertNotHasAttr(o, b"key4".decode("ascii"))
self.assertEqual(o._values["key4"],
b"viervierviervier".decode("ascii"))
o._values["key5"] = 1
STUB.setKeyValue_forObject_key_value_(0, o, b"key5".decode("ascii"),
b"V".decode("ascii"))
self.assertEqual(o._values["key5"], b"VVVVV".decode("ascii"))
self.assertNotHasAttr(o, b"key9".decode("ascii"))
self.assertNotIn("key9", o._values)
STUB.setKeyValue_forObject_key_value_(0, o, b"key9".decode("ascii"),
b"IX".decode("ascii"))
self.assertNotHasAttr(o, b"key9".decode("ascii"))
self.assertIn("key9", o._values)
self.assertEqual(o._values["key9"], b"IX".decode("ascii"))
def testTakeValueForKey(self):
o = KeyValueClass1Explicit.alloc().init()
self.assertEqual(o._values['key3'], 3)
STUB.setKeyValue_forObject_key_value_(0, o, b'key3'.decode('ascii'),
b'drie'.decode('ascii'))
self.assertEqual(o._values['key3'], b"drie".decode('ascii'))
self.assertEqual(o._values['key4'], b"4".decode('ascii'))
STUB.setKeyValue_forObject_key_value_(0, o, b'key4'.decode('ascii'),
b'vier'.decode('ascii'))
self.assert_(not hasattr(o, b"key4".decode('ascii')))
self.assertEqual(o._values['key4'],
b"viervierviervier".decode('ascii'))
o._values['key5'] = 1
STUB.setKeyValue_forObject_key_value_(0, o, b'key5'.decode('ascii'),
b'V'.decode('ascii'))
self.assertEqual(o._values['key5'], b"VVVVV".decode('ascii'))
self.assert_(not hasattr(o, b'key9'.decode('ascii')))
self.assert_('key9' not in o._values)
STUB.setKeyValue_forObject_key_value_(0, o, b'key9'.decode('ascii'),
b'IX'.decode('ascii'))
self.assert_(not hasattr(o, b'key9'.decode('ascii')))
self.assert_('key9' in o._values)
self.assertEqual(o._values['key9'], b'IX'.decode('ascii'))
def testTakeValueForKey2(self):
o = KeyValueClass4.alloc().init()
self.assertEqual(o.foo, b"foobar".decode("ascii"))
STUB.setKeyValue_forObject_key_value_(0, o, b"foo".decode("ascii"),
b"FOO".decode("ascii"))
self.assertEqual(o.foo, b"FOO".decode("ascii"))
self.assertRaises(
KeyError,
STUB.setKeyValue_forObject_key_value_,
0,
o,
b"key9".decode("ascii"),
b"IX".decode("ascii"),
)
def testTakeValueForKeyPath(self):
o = KeyValueClass1.alloc().init()
o.addMultiple()
self.assertEquals(o.multiple.level2.level3.keyA, u"hello")
self.assertEquals(o.multiple.level2.level3.keyB, u"world")
STUB.setKeyValue_forObject_key_value_(1, o,
u"multiple.level2.level3.keyA",
u"KeyAValue")
self.assertEquals(o.multiple.level2.level3.keyA, u"KeyAValue")
STUB.setKeyValue_forObject_key_value_(1, o,
u"multiple.level2.level3.keyB",
9.999)
self.assertEquals(o.multiple.level2.level3.keyB, 9.999)
def testTakeValuesFromDictionary2(self):
o = KeyValueClass4.alloc().init()
self.assertEqual(o.foo, "foobar")
STUB.setKeyValue_forObject_key_value_(3, o, None, {"foo": "FOO"})
self.assertEqual(o.foo, "FOO")
self.assertRaises(KeyError, STUB.setKeyValue_forObject_key_value_, 3,
o, None, {"key9": "IX"})
self.assertRaises(
KeyError,
STUB.setKeyValue_forObject_key_value_,
3,
o,
None,
{"roprop": "IX"},
)
def testKVO3(self):
"""
Check if observations work for python-based keys on ObjC classes
"""
observer = KeyValueObserver.alloc().init()
self.assertEqual(observer.observed, [])
o = KeyValueClass1.alloc().init()
STUB.setKeyValue_forObject_key_value_(2, o,
b"key3".decode("ascii"),
b"three".decode("ascii"))
o.addObserver_forKeyPath_options_context_(
observer,
b"key3".decode("ascii"),
Foundation.NSKeyValueObservingOptionNew
| Foundation.NSKeyValueObservingOptionOld,
0,
)
try:
STUB.setKeyValue_forObject_key_value_(2, o,
b"key3".decode("ascii"),
b"drie".decode("ascii"))
self.assertEqual(o.key3, b"drie".decode("ascii"))
self.assertEqual(len(observer.observed), 1)
keyPath, value, change = observer.observed[0]
self.assertEqual(keyPath, b"key3".decode("ascii"))
self.assertIs(value, o)
self.assertEqual(
change,
{
Foundation.NSKeyValueChangeKindKey:
1,
Foundation.NSKeyValueChangeNewKey:
b"drie".decode("ascii"),
Foundation.NSKeyValueChangeOldKey:
b"three".decode("ascii"),
},
)
finally:
o.removeObserver_forKeyPath_(observer, b"key3".decode("ascii"))
def testTakeValuesFromDictionary(self):
o = KeyValueClass1Explicit.alloc().init()
self.assertEquals(o._values['key3'], 3)
self.assertEquals(o._values['key4'], u"4")
o._values['key5'] = 1
self.assert_('key9' not in o._values)
STUB.setKeyValue_forObject_key_value_(3, o, None, {
u'key3': u'drie',
u'key4': u'vier',
u'key5': u'V',
u'key9': u'IX',
})
self.assertEquals(o._values['key3'], u"drie")
self.assertEquals(o._values['key4'], u"viervierviervier")
self.assertEquals(o._values['key5'], u"VVVVV")
self.assertEquals(o._values['key9'], u'IX')
def testTakeValuesFromDictionary(self):
o = KeyValueClass1Explicit.alloc().init()
self.assertEqual(o._values["key3"], 3)
self.assertEqual(o._values["key4"], "4")
o._values["key5"] = 1
self.assertNotIn("key9", o._values)
STUB.setKeyValue_forObject_key_value_(3, o, None, {
"key3": "drie",
"key4": "vier",
"key5": "V",
"key9": "IX"
})
self.assertEqual(o._values["key3"], "drie")
self.assertEqual(o._values["key4"], "viervierviervier")
self.assertEqual(o._values["key5"], "VVVVV")
self.assertEqual(o._values["key9"], "IX")
def testTakeValuesFromDictionary(self):
o = KeyValueClass1.alloc().init()
self.assertEquals(o.key3, 3)
self.assertEquals(o._key4, u"4")
o.key5 = 1
self.assert_(not hasattr(o, u'key9'))
STUB.setKeyValue_forObject_key_value_(3, o, None, {
u'key3': u'drie',
u'key4': u'vier',
u'key5': u'V',
u'key9': u'IX',
})
self.assertEquals(o.key3, u"drie")
self.assertEquals(o._key4, u"viervierviervier")
self.assertEquals(o.key5, u"VVVVV")
self.assert_(hasattr(o, u'key9'))
self.assertEquals(o.key9, u'IX')
def testTakeValuesFromDictionary(self):
o = KeyValueClass1Explicit.alloc().init()
self.assertEqual(o._values['key3'], 3)
self.assertEqual(o._values['key4'], b"4".decode('ascii'))
o._values['key5'] = 1
self.assert_('key9' not in o._values)
STUB.setKeyValue_forObject_key_value_(3, o, None,
{
b'key3'.decode('ascii'): b'drie'.decode('ascii'),
b'key4'.decode('ascii'): b'vier'.decode('ascii'),
b'key5'.decode('ascii'): b'V'.decode('ascii'),
b'key9'.decode('ascii'): b'IX'.decode('ascii'),
})
self.assertEqual(o._values['key3'], b"drie".decode('ascii'))
self.assertEqual(o._values['key4'], b"viervierviervier".decode('ascii'))
self.assertEqual(o._values['key5'], b"VVVVV".decode('ascii'))
self.assertEqual(o._values['key9'], b'IX'.decode('ascii'))
def testTakeValuesFromDictionary(self):
o = KeyValueClass1.alloc().init()
self.assertEqual(o.key3, 3)
self.assertEqual(o._key4, "4")
o.key5 = 1
self.assertNotHasAttr(o, "key9")
STUB.setKeyValue_forObject_key_value_(3, o, None, {
"key3": b"drie",
"key4": b"vier",
"key5": b"V",
"key9": b"IX"
})
self.assertEqual(o.key3, "drie")
self.assertEqual(o._key4, "viervierviervier")
self.assertEqual(o.key5, "VVVVV")
self.assertHasAttr(o, "key9")
self.assertEqual(o.key9, "IX")
def testTakeValuesFromDictionary(self):
o = KeyValueClass1Explicit.alloc().init()
self.assertEquals(o._values['key3'], 3)
self.assertEquals(o._values['key4'], u"4")
o._values['key5'] = 1
self.assert_('key9' not in o._values)
STUB.setKeyValue_forObject_key_value_(3, o, None,
{
u'key3': u'drie',
u'key4': u'vier',
u'key5': u'V',
u'key9': u'IX',
})
self.assertEquals(o._values['key3'], u"drie")
self.assertEquals(o._values['key4'], u"viervierviervier")
self.assertEquals(o._values['key5'], u"VVVVV")
self.assertEquals(o._values['key9'], u'IX')
def testTakeValuesFromDictionary(self):
o = KeyValueClass1.alloc().init()
self.assertEqual(o.key3, 3)
self.assertEqual(o._key4, b"4".decode('ascii'))
o.key5 = 1
self.assert_(not hasattr(o, b'key9'.decode('ascii')))
STUB.setKeyValue_forObject_key_value_(
3, o, None, {
b'key3'.decode('ascii'): b'drie'.decode('ascii'),
b'key4'.decode('ascii'): b'vier'.decode('ascii'),
b'key5'.decode('ascii'): b'V'.decode('ascii'),
b'key9'.decode('ascii'): b'IX'.decode('ascii'),
})
self.assertEqual(o.key3, b"drie".decode('ascii'))
self.assertEqual(o._key4, b"viervierviervier".decode('ascii'))
self.assertEqual(o.key5, b"VVVVV".decode('ascii'))
self.assert_(hasattr(o, b'key9'.decode('ascii')))
self.assertEqual(o.key9, b'IX'.decode('ascii'))
def testTakeValueForKeyPath(self):
o = KeyValueClass1.alloc().init()
o.addMultiple()
self.assertEqual(o.multiple.level2.level3.keyA,
b"hello".decode("ascii"))
self.assertEqual(o.multiple.level2.level3.keyB,
b"world".decode("ascii"))
STUB.setKeyValue_forObject_key_value_(
1,
o,
b"multiple.level2.level3.keyA".decode("ascii"),
b"KeyAValue".decode("ascii"),
)
self.assertEqual(o.multiple.level2.level3.keyA,
b"KeyAValue".decode("ascii"))
STUB.setKeyValue_forObject_key_value_(
1, o, b"multiple.level2.level3.keyB".decode("ascii"), 9.999)
self.assertEqual(o.multiple.level2.level3.keyB, 9.999)
def testTakeValuesFromDictionary(self):
o = KeyValueClass1.alloc().init()
self.assertEquals(o.key3, 3)
self.assertEquals(o._key4, u"4")
o.key5 = 1
self.assert_(not hasattr(o, u'key9'))
STUB.setKeyValue_forObject_key_value_(3, o, None,
{
u'key3': u'drie',
u'key4': u'vier',
u'key5': u'V',
u'key9': u'IX',
})
self.assertEquals(o.key3, u"drie")
self.assertEquals(o._key4, u"viervierviervier")
self.assertEquals(o.key5, u"VVVVV")
self.assert_(hasattr(o, u'key9'))
self.assertEquals(o.key9, u'IX')
def testTakeValuesFromDictionary(self):
o = KeyValueClass1.alloc().init()
self.assertEqual(o.key3, 3)
self.assertEqual(o._key4, b"4".decode('ascii'))
o.key5 = 1
self.assert_(not hasattr(o, b'key9'.decode('ascii')))
STUB.setKeyValue_forObject_key_value_(3, o, None,
{
b'key3'.decode('ascii'): b'drie'.decode('ascii'),
b'key4'.decode('ascii'): b'vier'.decode('ascii'),
b'key5'.decode('ascii'): b'V'.decode('ascii'),
b'key9'.decode('ascii'): b'IX'.decode('ascii'),
})
self.assertEqual(o.key3, b"drie".decode('ascii'))
self.assertEqual(o._key4, b"viervierviervier".decode('ascii'))
self.assertEqual(o.key5, b"VVVVV".decode('ascii'))
self.assert_(hasattr(o, b'key9'.decode('ascii')))
self.assertEqual(o.key9, b'IX'.decode('ascii'))
def testTakeValuesFromDictionary2(self):
o = KeyValueClass4.alloc().init()
self.assertEqual(o.foo, b"foobar".decode("ascii"))
STUB.setKeyValue_forObject_key_value_(
3, o, None, {b"foo".decode("ascii"): b"FOO".decode("ascii")})
self.assertEqual(o.foo, b"FOO".decode("ascii"))
self.assertRaises(
KeyError,
STUB.setKeyValue_forObject_key_value_,
3,
o,
None,
{b"key9".decode("ascii"): b"IX".decode("ascii")},
)
self.assertRaises(
KeyError,
STUB.setKeyValue_forObject_key_value_,
3,
o,
None,
{b"roprop".decode("ascii"): b"IX".decode("ascii")},
)
def testTakeValueForKeyPath(self):
o = KeyValueClass1Explicit.alloc().init()
o.addMultiple()
self.assertEquals(
o._values['multiple']._values['level2']._values['level3'].
_values['keyA'], u"hello")
self.assertEquals(
o._values['multiple']._values['level2']._values['level3'].
_values['keyB'], u"world")
STUB.setKeyValue_forObject_key_value_(1, o,
u"multiple.level2.level3.keyA",
u"KeyAValue")
self.assertEquals(
o._values['multiple']._values['level2']._values['level3'].
_values['keyA'], u"KeyAValue")
STUB.setKeyValue_forObject_key_value_(1, o,
u"multiple.level2.level3.keyB",
9.999)
self.assertEquals(
o._values['multiple']._values['level2']._values['level3'].
_values['keyB'], 9.999)
def testTakeStoredValueForKey(self):
o = KeyValueClass1Explicit.alloc().init()
self.assertEquals(o._values['key3'], 3)
STUB.setKeyValue_forObject_key_value_(2, o, u'key3', u'drie')
self.assertEquals(o._values['key3'], u"drie")
self.assertEquals(o._values['key4'], u"4")
STUB.setKeyValue_forObject_key_value_(2, o, u'key4', u'vier')
self.assertEquals(o._values['key4'], u"viervierviervier")
o.key5 = 1
STUB.setKeyValue_forObject_key_value_(2, o, u'key5', u'V')
self.assertEquals(o._values['key5'], u"VVVVV")
self.assert_('key9' not in o._values)
STUB.setKeyValue_forObject_key_value_(2, o, u'key9', u'IX')
self.assert_('key9' in o._values)
self.assertEquals(o._values['key9'], u'IX')
def testTakeStoredValueForKey(self):
o = KeyValueClass1.alloc().init()
self.assertEquals(o.key3, 3)
STUB.setKeyValue_forObject_key_value_(2, o, u'key3', u'drie')
self.assertEquals(o.key3, u"drie")
self.assertEquals(o._key4, u"4")
STUB.setKeyValue_forObject_key_value_(2, o, u'key4', u'vier')
self.assertEquals(o._key4, u"viervierviervier")
o.key5 = 1
STUB.setKeyValue_forObject_key_value_(2, o, u'key5', u'V')
self.assertEquals(o.key5, u"VVVVV")
self.assert_(not hasattr(o, u'key9'))
STUB.setKeyValue_forObject_key_value_(2, o, u'key9', u'IX')
self.assert_(hasattr(o, u'key9'))
self.assertEquals(o.key9, u'IX')
def testTakeStoredValueForKey(self):
o = KeyValueClass1.alloc().init()
self.assertEquals(o.key3, 3)
STUB.setKeyValue_forObject_key_value_(2, o, u'key3', u'drie')
self.assertEquals(o.key3, u"drie")
self.assertEquals(o._key4, u"4")
STUB.setKeyValue_forObject_key_value_(2, o, u'key4', u'vier')
self.assertEquals(o._key4, u"viervierviervier")
o.key5 = 1
STUB.setKeyValue_forObject_key_value_(2, o, u'key5', u'V')
self.assertEquals(o.key5, u"VVVVV")
self.assert_(not hasattr(o, u'key9'))
STUB.setKeyValue_forObject_key_value_(2, o, u'key9', u'IX')
self.assert_(hasattr(o, u'key9'))
self.assertEquals(o.key9, u'IX')
def testTakeStoredValueForKey(self):
o = KeyValueClass1Explicit.alloc().init()
self.assertEqual(o._values['key3'], 3)
STUB.setKeyValue_forObject_key_value_(2, o, b'key3'.decode('ascii'), b'drie'.decode('ascii'))
self.assertEqual(o._values['key3'], b"drie".decode('ascii'))
self.assertEqual(o._values['key4'], b"4".decode('ascii'))
STUB.setKeyValue_forObject_key_value_(2, o, b'key4'.decode('ascii'), b'vier'.decode('ascii'))
self.assertEqual(o._values['key4'], b"viervierviervier".decode('ascii'))
o.key5 = 1
STUB.setKeyValue_forObject_key_value_(2, o, b'key5'.decode('ascii'), b'V'.decode('ascii'))
self.assertEqual(o._values['key5'], b"VVVVV".decode('ascii'))
self.assert_('key9' not in o._values)
STUB.setKeyValue_forObject_key_value_(2, o, b'key9'.decode('ascii'), b'IX'.decode('ascii'))
self.assert_('key9' in o._values)
self.assertEqual(o._values['key9'], b'IX'.decode('ascii'))
def testTakeStoredValueForKey(self):
o = KeyValueClass1Explicit.alloc().init()
self.assertEquals(o._values['key3'], 3)
STUB.setKeyValue_forObject_key_value_(2, o, u'key3', u'drie')
self.assertEquals(o._values['key3'], u"drie")
self.assertEquals(o._values['key4'], u"4")
STUB.setKeyValue_forObject_key_value_(2, o, u'key4', u'vier')
self.assertEquals(o._values['key4'], u"viervierviervier")
o.key5 = 1
STUB.setKeyValue_forObject_key_value_(2, o, u'key5', u'V')
self.assertEquals(o._values['key5'], u"VVVVV")
self.assert_('key9' not in o._values)
STUB.setKeyValue_forObject_key_value_(2, o, u'key9', u'IX')
self.assert_('key9' in o._values)
self.assertEquals(o._values['key9'], u'IX')
def testTakeStoredValueForKey(self):
o = KeyValueClass1.alloc().init()
self.assertEqual(o.key3, 3)
STUB.setKeyValue_forObject_key_value_(2, o, b'key3'.decode('ascii'), b'drie'.decode('ascii'))
self.assertEqual(o.key3, b"drie".decode('ascii'))
self.assertEqual(o._key4, b"4".decode('ascii'))
STUB.setKeyValue_forObject_key_value_(2, o, b'key4'.decode('ascii'), b'vier'.decode('ascii'))
self.assertEqual(o._key4, b"viervierviervier".decode('ascii'))
o.key5 = 1
STUB.setKeyValue_forObject_key_value_(2, o, b'key5'.decode('ascii'), b'V'.decode('ascii'))
self.assertEqual(o.key5, b"VVVVV".decode('ascii'))
self.assert_(not hasattr(o, b'key9'.decode('ascii')))
STUB.setKeyValue_forObject_key_value_(2, o, b'key9'.decode('ascii'), b'IX'.decode('ascii'))
self.assert_(hasattr(o, b'key9'.decode('ascii')))
self.assertEqual(o.key9, b'IX'.decode('ascii'))
