def test_cocoa_get(self): r = objc.lookUpClass('NSObject').alloc().init() self.assertEqual(KeyValueCoding.getKey(r, 'description'), r.description()) self.assertEqual(KeyValueCoding.getKeyPath(r, 'description'), r.description()) self.assertEqual(KeyValueCoding.getKeyPath(r, 'description.length'), len(r.description())) self.assertRaises(KeyError, KeyValueCoding.getKey, r, 'nosuchattr') self.assertRaises(KeyError, KeyValueCoding.getKeyPath, r, 'description.nosuchattr')
def test_attribute_access(self): v = object() o = KeyValueCoding.kvc(v) o.key o.key2 getattr(o, "key3.key4") self.assertEqual(self._trace, [ ('get', v, 'key'), ('get', v, 'key2'), ('get', v, 'key3.key4'), ]) self._trace[:] = [] o.key = 42 setattr(o, "key3.key4", 99) self.assertEqual(self._trace, [ ('set', v, 'key', 42), ('set', v, 'key3.key4', 99), ]) self._trace[:] = [] class Object(object): pass v = Object() o = KeyValueCoding.kvc(v) o.key = 42 o._key = 99 self.assertEqual(self._trace, [ ('set', v, 'key', 42), ]) self.assertEqual(o._key, 99) self.assertIn('_key', o.__dict__) self.assertNotIn('key', o.__dict__)
def test_sum(self): arrayOperators = KeyValueCoding._ArrayOperators values = [ { 'a': 1 }, { 'a': 2, 'b': 4 }, { 'a': 3, 'b': 2 }, { 'a': 4 }, ] self.assertEqual(arrayOperators.sum(values, 'a'), 10) self.assertEqual(arrayOperators.sum(values, 'b'), 6) self.assertEqual(arrayOperators.sum(values, 'c'), 0) self.assertEqual(arrayOperators.sum([], 'b'), 0) self.assertRaises(KeyError, arrayOperators.sum, [], ()) self.assertEqual(KeyValueCoding.getKeyPath(values, '@sum.a'), 10) self.assertEqual(KeyValueCoding.getKeyPath(values, '@sum.b'), 6) self.assertEqual(KeyValueCoding.getKeyPath(values, '@sum.c'), 0)
def test_attribute_access(self): v = object() o = KeyValueCoding.kvc(v) o.key o.key2 getattr(o, "key3.key4") self.assertEqual(self._trace, [ ('get', v, 'key'), ('get', v, 'key2'), ('get', v, 'key3.key4'), ]) self._trace[:] = [] o.key = 42 setattr(o, "key3.key4", 99) self.assertEqual(self._trace, [ ('set', v, 'key', 42), ('set', v, 'key3.key4', 99), ]) self._trace[:] = [] class Object (object): pass v = Object() o = KeyValueCoding.kvc(v) o.key = 42 o._key = 99 self.assertEqual(self._trace, [ ('set', v, 'key', 42), ]) self.assertEqual(o._key, 99) self.assertIn('_key', o.__dict__) self.assertNotIn('key', o.__dict__)
def test_count(self): arrayOperators = KeyValueCoding._ArrayOperators values = [ { 'a': 1 }, { 'a': 2, 'b': 4 }, { 'a': 3, 'b': 2 }, { 'a': 4 }, ] self.assertEqual(arrayOperators.count(values, 'a'), len(values)) self.assertEqual(arrayOperators.count(values, 'b'), len(values)) self.assertEqual(arrayOperators.count(values, ()), len(values)) self.assertEqual(KeyValueCoding.getKeyPath(values, '@count'), len(values)) self.assertEqual(KeyValueCoding.getKeyPath(values, '@count.a'), len(values))
def test_attribute_access(self): v = object() o = KeyValueCoding.kvc(v) o.key o.key2 getattr(o, "key3.key4") self.assertEqual( self._trace, [("get", v, "key"), ("get", v, "key2"), ("get", v, "key3.key4")], ) self._trace[:] = [] o.key = 42 setattr(o, "key3.key4", 99) self.assertEqual(self._trace, [("set", v, "key", 42), ("set", v, "key3.key4", 99)]) self._trace[:] = [] class Object(object): pass v = Object() o = KeyValueCoding.kvc(v) o.key = 42 o._key = 99 self.assertEqual(self._trace, [("set", v, "key", 42)]) self.assertEqual(o._key, 99) self.assertIn("_key", o.__dict__) self.assertNotIn("key", o.__dict__)
def test_avg(self): arrayOperators = KeyValueCoding._ArrayOperators values = [ { 'a': 1 }, { 'a': 2, 'b': 4 }, { 'a': 3, 'b': 2 }, { 'a': 4 }, ] self.assertEqual(arrayOperators.avg(values, 'a'), 2.5) self.assertEqual(arrayOperators.avg(values, 'b'), 1.5) self.assertEqual(arrayOperators.avg(values, 'c'), 0) self.assertEqual(arrayOperators.avg([], 'b'), 0) self.assertRaises(KeyError, arrayOperators.avg, [], ()) self.assertEqual(KeyValueCoding.getKeyPath(values, '@avg.a'), 2.5) self.assertEqual(KeyValueCoding.getKeyPath(values, '@avg.b'), 1.5) self.assertEqual(KeyValueCoding.getKeyPath(values, '@avg.c'), 0)
def testMixedGraph2(self): arr = objc.lookUpClass('NSMutableArray').alloc().init() d1 = objc.lookUpClass('NSMutableDictionary').alloc().init() d2 = objc.lookUpClass('NSMutableDictionary').alloc().init() d3 = {} root = objc.lookUpClass( 'NSMutableDictionary').dictionaryWithDictionary_({ 'a': arr, 'd': d2 }) arr.addObject_(d1) arr.addObject_(d3) d1['k'] = 1 d3['k'] = 2 KeyValueCoding.setKeyPath(root, 'd.a', 'the letter A') self.assertEqual(d2, { 'a': 'the letter A', }) self.assertEqual(KeyValueCoding.getKeyPath(root, 'd.a'), 'the letter A') self.assertEqual(KeyValueCoding.getKeyPath(arr, 'k'), [1, 2]) self.assertEqual(KeyValueCoding.getKeyPath(root, 'a.k'), [1, 2])
def test_attr_get(self): class Record (object): __slots__ = ('slot1', '__dict__') def __init__(self, **kwds): for k, v in kwds.items(): setattr(self, k, v) @property def prop1(self): return 'a property' r = Record(slot1=42, attr1='a') self.assertEqual(KeyValueCoding.getKey(r, 'slot1'), 42) self.assertEqual(KeyValueCoding.getKey(r, 'attr1'), 'a') self.assertEqual(KeyValueCoding.getKey(r, 'prop1'), 'a property') self.assertEqual(KeyValueCoding.getKeyPath(r, 'slot1'), 42) self.assertEqual(KeyValueCoding.getKeyPath(r, 'attr1'), 'a') self.assertEqual(KeyValueCoding.getKeyPath(r, 'prop1'), 'a property') r = Record(attr1=Record(attr2='b', attr3=[Record(a=1), Record(a=2, b='b')])) self.assertRaises(KeyError, KeyValueCoding.getKey, r, 'slot1') self.assertRaises(KeyError, KeyValueCoding.getKey, r, 'attr99') self.assertRaises(KeyError, KeyValueCoding.getKeyPath, r, 'slot1') self.assertRaises(KeyError, KeyValueCoding.getKeyPath, r, 'attr99') self.assertEqual(KeyValueCoding.getKeyPath(r, 'attr1.attr2'), 'b') self.assertEqual(KeyValueCoding.getKeyPath(r, 'attr1.attr3.a'), [1, 2]) self.assertEqual(KeyValueCoding.getKeyPath(r, 'attr1.attr3.b'), [null, 'b']) self.assertRaises(KeyError, KeyValueCoding.getKeyPath, r, 'attr3') self.assertRaises(KeyError, KeyValueCoding.getKeyPath, r, 'attr1.attr9')
def test_dict_set(self): v = {'a': 42, 'c':{} } KeyValueCoding.setKey(v, 'a', 43) KeyValueCoding.setKey(v, 'b', 'B') self.assertEqual(v, {'a': 43, 'b': 'B', 'c':{} }) KeyValueCoding.setKeyPath(v, 'a', 44) KeyValueCoding.setKeyPath(v, 'b', 'C') KeyValueCoding.setKeyPath(v, 'c.a', 'A') self.assertEqual(v, {'a': 44, 'b': 'C', 'c':{'a': 'A'} })
def test_cocoa_set(self): o = objc.lookUpClass('NSMutableDictionary').alloc().init() KeyValueCoding.setKey(o, 'attr', 'value') self.assertEqual(o, {'attr': 'value'}) KeyValueCoding.setKeyPath(o, 'attr', 'value2') self.assertEqual(o, {'attr': 'value2'}) o = objc.lookUpClass('NSObject').alloc().init() self.assertRaises(KeyError, KeyValueCoding.setKey, o, 'description', 'hello') self.assertRaises(KeyError, KeyValueCoding.setKeyPath, o, 'description', 'hello')
def test_dict_set(self): v = {"a": 42, "c": {}} KeyValueCoding.setKey(v, "a", 43) KeyValueCoding.setKey(v, "b", "B") self.assertEqual(v, {"a": 43, "b": "B", "c": {}}) KeyValueCoding.setKeyPath(v, "a", 44) KeyValueCoding.setKeyPath(v, "b", "C") KeyValueCoding.setKeyPath(v, "c.a", "A") self.assertEqual(v, {"a": 44, "b": "C", "c": {"a": "A"}})
def test_count(self): arrayOperators = KeyValueCoding._ArrayOperators values = [{"a": 1}, {"a": 2, "b": 4}, {"a": 3, "b": 2}, {"a": 4}] self.assertEqual(arrayOperators.count(values, "a"), len(values)) self.assertEqual(arrayOperators.count(values, "b"), len(values)) self.assertEqual(arrayOperators.count(values, ()), len(values)) self.assertEqual(KeyValueCoding.getKeyPath(values, "@count"), len(values)) self.assertEqual(KeyValueCoding.getKeyPath(values, "@count.a"), len(values))
def test_dict_set(self): v = {'a': 42, 'c': {}} KeyValueCoding.setKey(v, 'a', 43) KeyValueCoding.setKey(v, 'b', 'B') self.assertEqual(v, {'a': 43, 'b': 'B', 'c': {}}) KeyValueCoding.setKeyPath(v, 'a', 44) KeyValueCoding.setKeyPath(v, 'b', 'C') KeyValueCoding.setKeyPath(v, 'c.a', 'A') self.assertEqual(v, {'a': 44, 'b': 'C', 'c': {'a': 'A'}})
def test_sum(self): arrayOperators = KeyValueCoding._ArrayOperators values = [{"a": 1}, {"a": 2, "b": 4}, {"a": 3, "b": 2}, {"a": 4}] self.assertEqual(arrayOperators.sum(values, "a"), 10) self.assertEqual(arrayOperators.sum(values, "b"), 6) self.assertEqual(arrayOperators.sum(values, "c"), 0) self.assertEqual(arrayOperators.sum([], "b"), 0) self.assertRaises(KeyError, arrayOperators.sum, [], ()) self.assertEqual(KeyValueCoding.getKeyPath(values, "@sum.a"), 10) self.assertEqual(KeyValueCoding.getKeyPath(values, "@sum.b"), 6) self.assertEqual(KeyValueCoding.getKeyPath(values, "@sum.c"), 0)
def test_avg(self): arrayOperators = KeyValueCoding._ArrayOperators values = [{"a": 1}, {"a": 2, "b": 4}, {"a": 3, "b": 2}, {"a": 4}] self.assertEqual(arrayOperators.avg(values, "a"), 2.5) self.assertEqual(arrayOperators.avg(values, "b"), 1.5) self.assertEqual(arrayOperators.avg(values, "c"), 0) self.assertEqual(arrayOperators.avg([], "b"), 0) self.assertRaises(KeyError, arrayOperators.avg, [], ()) self.assertEqual(KeyValueCoding.getKeyPath(values, "@avg.a"), 2.5) self.assertEqual(KeyValueCoding.getKeyPath(values, "@avg.b"), 1.5) self.assertEqual(KeyValueCoding.getKeyPath(values, "@avg.c"), 0)
def test_cocoa_set(self): o = objc.lookUpClass("NSMutableDictionary").alloc().init() KeyValueCoding.setKey(o, "attr", "value") self.assertEqual(o, {"attr": "value"}) KeyValueCoding.setKeyPath(o, "attr", "value2") self.assertEqual(o, {"attr": "value2"}) o = objc.lookUpClass("NSObject").alloc().init() self.assertRaises(KeyError, KeyValueCoding.setKey, o, "description", "hello") self.assertRaises(KeyError, KeyValueCoding.setKeyPath, o, "description", "hello")
def test_count(self): arrayOperators = KeyValueCoding._ArrayOperators values = [ { 'a' : 1 }, { 'a' : 2, 'b': 4 }, { 'a' : 3, 'b': 2 }, { 'a' : 4 }, ] self.assertEqual(arrayOperators.count(values, 'a'), len(values)) self.assertEqual(arrayOperators.count(values, 'b'), len(values)) self.assertEqual(arrayOperators.count(values, ()), len(values)) self.assertEqual(KeyValueCoding.getKeyPath(values, '@count'), len(values)) self.assertEqual(KeyValueCoding.getKeyPath(values, '@count.a'), len(values))
def notify(self, title='', subtitle='', message='', data=None, sound='NSUserNotificationDefaultSoundName', after=0, repeat={}): """Send a notification to Notification Center (Mac OS X 10.8+). If running on a version of Mac OS X that does not support notifications, a ``RuntimeError`` will be raised. Apple says, "The userInfo content must be of reasonable serialized size (less than 1k) or an exception will be thrown." So don't do that! :param title: text in a larger font. :param subtitle: text in a smaller font below the `title`. :param message: text representing the body of the notification below the `subtitle`. :param data: will be passed to the application's "notification center" (see :func:`rumps.notifications`) when this notification is clicked. :param sound: whether the notification should make a noise when it arrives. :param after: number of seconds to postpone the notification. :param repeat: dict of date components that specify how the notification shoul be repeated. e.g. {'hour': 1, 'minute': 30} """ after = max(after, 0) if not _NOTIFICATIONS: raise RuntimeError('Mac OS X 10.8+ is required to send notifications') if data is not None and not isinstance(data, Mapping): raise TypeError('notification data must be a mapping') _require_string_or_none(title, subtitle, message, sound) notification = NSUserNotification.alloc().init() notification.setTitle_(title) notification.setSubtitle_(subtitle) notification.setInformativeText_(message) notification.setUserInfo_(data or {}) if sound: notification.setSoundName_(sound) if after: notification.setDeliveryDate_(NSDate.dateWithTimeIntervalSinceNow_(after)) if repeat: deliveryRepeatInterval = NSDateComponents.alloc().init() for k, v in repeat.items(): kvc.setKey(deliveryRepeatInterval, k, v) notification.setDeliveryRepeatInterval_(deliveryRepeatInterval) self.defaultNotificationCenter.scheduleNotification_(notification) return notification
def test_unionOfObjects(self): arrayOperators = KeyValueCoding._ArrayOperators values = [ { 'a': { 'b': 1 } }, { 'a': { 'b': 1 } }, { 'a': { 'b': 2 } }, { 'a': { 'b': 3 } }, ] self.assertEqual(arrayOperators.unionOfObjects(values, ('a', 'b')), [1, 1, 2, 3]) self.assertEqual( KeyValueCoding.getKeyPath(values, '@unionOfObjects.a.b'), [1, 1, 2, 3]) values.append({'a': {}}) self.assertRaises(KeyError, arrayOperators.unionOfObjects, values, ('a', 'b'))
def test_deprecated_class(self): with filterWarnings('error', DeprecationWarning): self.assertRaises(DeprecationWarning, KeyValueCoding.ArrayOperators) o = KeyValueCoding.ArrayOperators() self.assertIsInstance(o, KeyValueCoding._ArrayOperators)
def test_unionOfObjects(self): arrayOperators = KeyValueCoding._ArrayOperators values = [{ "a": { "b": 1 } }, { "a": { "b": 1 } }, { "a": { "b": 2 } }, { "a": { "b": 3 } }] self.assertEqual(arrayOperators.unionOfObjects(values, ("a", "b")), [1, 1, 2, 3]) self.assertEqual( KeyValueCoding.getKeyPath(values, "@unionOfObjects.a.b"), [1, 1, 2, 3]) values.append({"a": {}}) self.assertRaises(KeyError, arrayOperators.unionOfObjects, values, ("a", "b"))
def test_min(self): arrayOperators = KeyValueCoding._ArrayOperators values = [{"a": 1}, {"a": 2, "b": 5}, {"a": 3, "b": 2}, {"a": 4}] self.assertEqual(arrayOperators.min(values, "a"), 1) self.assertEqual(arrayOperators.min(values, "b"), 2) self.assertRaises(KeyError, arrayOperators.min, values, ()) self.assertEqual(KeyValueCoding.getKeyPath(values, "@min.a"), 1)
def test_keyCaps(self): self.assertEqual(KeyValueCoding.keyCaps("attr"), "Attr") self.assertEqual(KeyValueCoding.keyCaps("Attr"), "Attr") self.assertEqual(KeyValueCoding.keyCaps("AttR"), "AttR") self.assertEqual(KeyValueCoding.keyCaps("attr_with_value"), "Attr_with_value") self.assertEqual(KeyValueCoding.keyCaps(b"attr"), b"Attr") self.assertEqual(KeyValueCoding.keyCaps(b"Attr"), b"Attr") self.assertEqual(KeyValueCoding.keyCaps(b"AttR"), b"AttR") self.assertEqual(KeyValueCoding.keyCaps(b"attr_with_value"), b"Attr_with_value")
def test_sum(self): arrayOperators = KeyValueCoding._ArrayOperators values = [ { 'a' : 1 }, { 'a' : 2, 'b': 4 }, { 'a' : 3, 'b': 2 }, { 'a' : 4 }, ] self.assertEqual(arrayOperators.sum(values, 'a'), 10) self.assertEqual(arrayOperators.sum(values, 'b'), 6) self.assertEqual(arrayOperators.sum(values, 'c'), 0) self.assertEqual(arrayOperators.sum([], 'b'), 0) self.assertRaises(KeyError, arrayOperators.sum, [], ()) self.assertEqual(KeyValueCoding.getKeyPath(values, '@sum.a'), 10) self.assertEqual(KeyValueCoding.getKeyPath(values, '@sum.b'), 6) self.assertEqual(KeyValueCoding.getKeyPath(values, '@sum.c'), 0)
def test_avg(self): arrayOperators = KeyValueCoding._ArrayOperators values = [ { 'a' : 1 }, { 'a' : 2, 'b': 4 }, { 'a' : 3, 'b': 2 }, { 'a' : 4 }, ] self.assertEqual(arrayOperators.avg(values, 'a'), 2.5) self.assertEqual(arrayOperators.avg(values, 'b'), 1.5) self.assertEqual(arrayOperators.avg(values, 'c'), 0) self.assertEqual(arrayOperators.avg([], 'b'), 0) self.assertRaises(KeyError, arrayOperators.avg, [], ()) self.assertEqual(KeyValueCoding.getKeyPath(values, '@avg.a'), 2.5) self.assertEqual(KeyValueCoding.getKeyPath(values, '@avg.b'), 1.5) self.assertEqual(KeyValueCoding.getKeyPath(values, '@avg.c'), 0)
def testMixedGraph2(self): arr = objc.lookUpClass('NSMutableArray').alloc().init() d1 = objc.lookUpClass('NSMutableDictionary').alloc().init() d2 = objc.lookUpClass('NSMutableDictionary').alloc().init() d3 = {} root = objc.lookUpClass('NSMutableDictionary').dictionaryWithDictionary_({ 'a': arr, 'd': d2 }) arr.addObject_(d1) arr.addObject_(d3) d1['k'] = 1 d3['k'] = 2 KeyValueCoding.setKeyPath(root, 'd.a', 'the letter A') self.assertEqual(d2, {'a': 'the letter A', }) self.assertEqual(KeyValueCoding.getKeyPath(root, 'd.a'), 'the letter A') self.assertEqual(KeyValueCoding.getKeyPath(arr, 'k'), [1, 2]) self.assertEqual(KeyValueCoding.getKeyPath(root, 'a.k'), [1, 2])
def testMixedGraph(self): arr = objc.lookUpClass("NSMutableArray").alloc().init() d1 = objc.lookUpClass("NSMutableDictionary").alloc().init() d2 = objc.lookUpClass("NSMutableDictionary").alloc().init() d3 = {} root = {"a": arr, "d": d2} arr.addObject_(d1) arr.addObject_(d3) d1["k"] = 1 d3["k"] = 2 KeyValueCoding.setKeyPath(root, "d.a", "the letter A") self.assertEqual(d2, {"a": "the letter A"}) self.assertEqual(KeyValueCoding.getKeyPath(root, "d.a"), "the letter A") self.assertEqual(KeyValueCoding.getKeyPath(arr, "k"), [1, 2]) self.assertEqual(KeyValueCoding.getKeyPath(root, "a.k"), [1, 2])
def test_distinctUnionOfObjects(self): arrayOperators = KeyValueCoding._ArrayOperators class Int (object): def __init__(self, value): self._value = value def __repr__(self): return 'Int(%r)'%(self._value) def __eq__(self, other): if isinstance(other, int): return self._value == other elif isinstance(other, Int): return self._value == other._value else: return False def __hash__(self): raise TypeError values = [ { 'a' : { 'b': 1 } }, { 'a' : { 'b': Int(1) } }, { 'a' : { 'b': 2 } }, { 'a' : { 'b': Int(3) } }, { 'a' : { 'b': Int(3) } }, ] self.assertEqual(arrayOperators.distinctUnionOfObjects(values, ('a', 'b')), [1, 2, 3 ]) self.assertEqual(KeyValueCoding.getKeyPath(values, '@distinctUnionOfObjects.a.b'), [1, 2, 3 ]) values.append({'a': {}}) self.assertRaises(KeyError, arrayOperators.distinctUnionOfObjects, values, ('a', 'b')) self.assertRaises(KeyError, KeyValueCoding.getKeyPath, values, '@distinctUnionOfObjects.a.b') class Rec (object): def __init__(self, b): self.b = b def __eq__(self, other): return type(self) == type(other) and self.b == other.b def __hash__(self): raise TypeError values = [ { 'a' : Rec(1) }, { 'a' : Rec(1) }, { 'a' : Rec(2) }, { 'a' : Rec(3) }, ] self.assertEqual(arrayOperators.distinctUnionOfObjects(values, ('a', 'b')), [1, 2, 3 ])
def test_max(self): arrayOperators = KeyValueCoding._ArrayOperators values = [ { 'a' : 1 }, { 'a' : 2, 'b': 5 }, { 'a' : 3, 'b': 2 }, { 'a' : 4 }, ] self.assertEqual(arrayOperators.max(values, 'a'), 4) self.assertEqual(arrayOperators.max(values, 'b'), 5) self.assertRaises(KeyError, arrayOperators.max, values, ()) self.assertEqual(KeyValueCoding.getKeyPath(values, '@max.a'), 4)
def test_unionOfObjects(self): arrayOperators = KeyValueCoding._ArrayOperators values = [ { 'a' : { 'b': 1 } }, { 'a' : { 'b': 1 } }, { 'a' : { 'b': 2 } }, { 'a' : { 'b': 3 } }, ] self.assertEqual(arrayOperators.unionOfObjects(values, ('a', 'b')), [1, 1, 2, 3 ]) self.assertEqual(KeyValueCoding.getKeyPath(values, '@unionOfObjects.a.b'), [1, 1, 2, 3]) values.append({'a': {}}) self.assertRaises(KeyError, arrayOperators.unionOfObjects, values, ('a', 'b'))
def test_attr_get(self): class Record(object): __slots__ = ("slot1", "__dict__") def __init__(self, **kwds): for k, v in kwds.items(): setattr(self, k, v) @property def prop1(self): return "a property" r = Record(slot1=42, attr1="a") self.assertEqual(KeyValueCoding.getKey(r, "slot1"), 42) self.assertEqual(KeyValueCoding.getKey(r, "attr1"), "a") self.assertEqual(KeyValueCoding.getKey(r, "prop1"), "a property") self.assertEqual(KeyValueCoding.getKeyPath(r, "slot1"), 42) self.assertEqual(KeyValueCoding.getKeyPath(r, "attr1"), "a") self.assertEqual(KeyValueCoding.getKeyPath(r, "prop1"), "a property") r = Record( attr1=Record(attr2="b", attr3=[Record( a=1), Record(a=2, b="b")])) self.assertRaises(KeyError, KeyValueCoding.getKey, r, "slot1") self.assertRaises(KeyError, KeyValueCoding.getKey, r, "attr99") self.assertRaises(KeyError, KeyValueCoding.getKeyPath, r, "slot1") self.assertRaises(KeyError, KeyValueCoding.getKeyPath, r, "attr99") self.assertEqual(KeyValueCoding.getKeyPath(r, "attr1.attr2"), "b") self.assertEqual(KeyValueCoding.getKeyPath(r, "attr1.attr3.a"), [1, 2]) self.assertEqual(KeyValueCoding.getKeyPath(r, "attr1.attr3.b"), [null, "b"]) self.assertRaises(KeyError, KeyValueCoding.getKeyPath, r, "attr3") self.assertRaises(KeyError, KeyValueCoding.getKeyPath, r, "attr1.attr9")
def test_item_access(self): v = object() o = KeyValueCoding.kvc(v) o['key'] o['key2'] o['key3.key4'] self.assertEqual(self._trace, [ ('get-path', v, 'key'), ('get-path', v, 'key2'), ('get-path', v, 'key3.key4'), ]) self._trace[:] = [] o["key"] = 42 o["key3.key4"] = 99 self.assertEqual(self._trace, [ ('set-path', v, 'key', 42), ('set-path', v, 'key3.key4', 99), ]) self._trace[:] = [] self.assertRaises(TypeError, operator.getitem, o, 42) self.assertRaises(TypeError, operator.setitem, o, 42, 99)
def test_item_access(self): v = object() o = KeyValueCoding.kvc(v) o["key"] o["key2"] o["key3.key4"] self.assertEqual( self._trace, [ ("get-path", v, "key"), ("get-path", v, "key2"), ("get-path", v, "key3.key4"), ], ) self._trace[:] = [] o["key"] = 42 o["key3.key4"] = 99 self.assertEqual(self._trace, [("set-path", v, "key", 42), ("set-path", v, "key3.key4", 99)]) self._trace[:] = [] self.assertRaises(TypeError, operator.getitem, o, 42) self.assertRaises(TypeError, operator.setitem, o, 42, 99)
def test_array_get(self): l = [{'a': 1, 'b':2 }, {'a':2} ] self.assertEqual(KeyValueCoding.getKey(l, 'a'), [1, 2]) self.assertEqual(KeyValueCoding.getKey(l, 'b'), [2, null])
def test_msum(self): self.assertEqual(KeyValueCoding.msum([1, 1e100, 1, -1e100] * 10000), 20000) self.assertEqual(KeyValueCoding.msum([1.0, 2.0, 3.0, 4.0]), 10.0)
def test_attr_set(self): class R (object): @property def attr3(self): return self._attr3 @attr3.setter def attr3(self, v): self._attr3 = v * 2 @property def attr4(self): return self._attr4 def attr6(self): return self._attr6 r = R() r._attr1 = 42 r._attr4 = 43 r.attr5 = {} r._attr6 = 9 KeyValueCoding.setKey(r, 'attr1', 1) KeyValueCoding.setKey(r, 'attr2', 2) KeyValueCoding.setKey(r, 'attr3', 3) self.assertRaises(KeyError, KeyValueCoding.setKey, r, 'attr4', 4) KeyValueCoding.setKey(r, 'attr6', 7) self.assertEqual(r._attr1, 1) self.assertEqual(r.attr2, 2) self.assertEqual(r.attr3, 6) self.assertEqual(r._attr3, 6) self.assertEqual(r._attr6, 7) KeyValueCoding.setKeyPath(r, 'attr1', 'one') KeyValueCoding.setKeyPath(r, 'attr2', 'two') KeyValueCoding.setKeyPath(r, 'attr3', 'three') KeyValueCoding.setKeyPath(r, 'attr5.sub1', 3) KeyValueCoding.setKeyPath(r, 'attr6', 'seven') self.assertEqual(r._attr1, 'one') self.assertEqual(r.attr2, 'two') self.assertEqual(r.attr3, 'threethree') self.assertEqual(r._attr3, 'threethree') self.assertEqual(r.attr5, {'sub1': 3}) self.assertEqual(r._attr6, 'seven')
def test_repr(self): for o in [object(), 42, "42", b"42"]: self.assertEqual(repr(KeyValueCoding.kvc(o)), repr(o))
def test_accessor(self): class Record(object): def __init__(self): self._attr1 = 1 self._attr2 = 2 self._attr3 = 3 def attr1(self): return self._attr1 def setAttr1_(self, value): self._attr1 = (1, value) def setAttr1(self, value): self._attr1 = (2, value) def set_attr1(self, value): self._attr1 = (3, value) def setAttr2(self, value): self._attr2 = (2, value) def set_attr2(self, value): self._attr2 = (3, value) def set_attr3(self, value): self._attr3 = (3, value) set_no_attr = 4 o = Record() self.assertEqual(o._attr1, 1) self.assertEqual(o._attr2, 2) self.assertEqual(o._attr3, 3) self.assertEqual(o.set_no_attr, 4) KeyValueCoding.setKey(o, "attr1", 9) KeyValueCoding.setKey(o, "attr2", 10) KeyValueCoding.setKey(o, "attr3", 11) KeyValueCoding.setKey(o, "no_attr", 12) self.assertEqual(o._attr1, (1, 9)) self.assertEqual(o._attr2, (2, 10)) self.assertEqual(o._attr3, (3, 11)) self.assertEqual(o.no_attr, 12) KeyValueCoding.setKeyPath(o, "attr1", 29) KeyValueCoding.setKeyPath(o, "attr2", 210) KeyValueCoding.setKeyPath(o, "attr3", 211) self.assertEqual(o._attr1, (1, 29)) self.assertEqual(o._attr2, (2, 210)) self.assertEqual(o._attr3, (3, 211)) o._attr1 = {"a": "b"} KeyValueCoding.setKeyPath(o, "attr1.a", 30) self.assertEqual(o._attr1, {"a": 30})
def test_dict_get(self): d = {'a':1 } self.assertEqual(KeyValueCoding.getKey(d, 'a'), 1) self.assertRaises(KeyError, KeyValueCoding.getKey, d, 'b')
def test_accessor(self): class Record (object): def __init__(self): self._attr1 = 1 self._attr2 = 2 self._attr3 = 3 def attr1(self): return self._attr1 def setAttr1_(self, value): self._attr1 = (1, value) def setAttr1(self, value): self._attr1 = (2, value) def set_attr1(self, value): self._attr1 = (3, value) def setAttr2(self, value): self._attr2 = (2, value) def set_attr2(self, value): self._attr2 = (3, value) def set_attr3(self, value): self._attr3 = (3, value) set_no_attr = 4 o = Record() self.assertEqual(o._attr1, 1) self.assertEqual(o._attr2, 2) self.assertEqual(o._attr3, 3) self.assertEqual(o.set_no_attr, 4) KeyValueCoding.setKey(o, 'attr1', 9) KeyValueCoding.setKey(o, 'attr2', 10) KeyValueCoding.setKey(o, 'attr3', 11) KeyValueCoding.setKey(o, 'no_attr', 12) self.assertEqual(o._attr1, (1, 9)) self.assertEqual(o._attr2, (2, 10)) self.assertEqual(o._attr3, (3, 11)) self.assertEqual(o.no_attr, 12) KeyValueCoding.setKeyPath(o, 'attr1', 29) KeyValueCoding.setKeyPath(o, 'attr2', 210) KeyValueCoding.setKeyPath(o, 'attr3', 211) self.assertEqual(o._attr1, (1, 29)) self.assertEqual(o._attr2, (2, 210)) self.assertEqual(o._attr3, (3, 211)) o._attr1 = {'a': 'b'} KeyValueCoding.setKeyPath(o, 'attr1.a', 30) self.assertEqual(o._attr1, {'a': 30})
def test_attr_set(self): class R(object): @property def attr3(self): return self._attr3 @attr3.setter def attr3(self, v): self._attr3 = v * 2 @property def attr4(self): return self._attr4 def attr6(self): return self._attr6 r = R() r._attr1 = 42 r._attr4 = 43 r.attr5 = {} r._attr6 = 9 KeyValueCoding.setKey(r, "attr1", 1) KeyValueCoding.setKey(r, "attr2", 2) KeyValueCoding.setKey(r, "attr3", 3) self.assertRaises(KeyError, KeyValueCoding.setKey, r, "attr4", 4) KeyValueCoding.setKey(r, "attr6", 7) self.assertEqual(r._attr1, 1) self.assertEqual(r.attr2, 2) self.assertEqual(r.attr3, 6) self.assertEqual(r._attr3, 6) self.assertEqual(r._attr6, 7) KeyValueCoding.setKeyPath(r, "attr1", "one") KeyValueCoding.setKeyPath(r, "attr2", "two") KeyValueCoding.setKeyPath(r, "attr3", "three") KeyValueCoding.setKeyPath(r, "attr5.sub1", 3) KeyValueCoding.setKeyPath(r, "attr6", "seven") self.assertEqual(r._attr1, "one") self.assertEqual(r.attr2, "two") self.assertEqual(r.attr3, "threethree") self.assertEqual(r._attr3, "threethree") self.assertEqual(r.attr5, {"sub1": 3}) self.assertEqual(r._attr6, "seven")
def test_repr(self): for o in [ object(), 42, "42", b"42", b"42".decode('latin1') ]: self.assertEqual(repr(KeyValueCoding.kvc(o)), repr(o))
def test_unionOfArrays(self): arrayOperators = KeyValueCoding._ArrayOperators class Rec (object): def __init__(self, **kwds): for k, v in kwds.items(): setattr(self, k, v) def __eq__(self, other): return type(self) is type(other) and self.__dict__ == other.__dict__ def __hash__(self): raise TypeError class Str (object): def __init__(self, value): self._value = value def __repr__(self): return 'Str(%r)'%(self._value) def __eq__(self, other): if isinstance(other, str): return self._value == other elif isinstance(other, Str): return self._value == other._value else: return False def __cmp__(self, other): if isinstance(other, str): return cmp(self._value, other) elif isinstance(other, Str): return cmp(self._value, other._value) else: return NotImplementedError def __hash__(self): raise TypeError transactions = [ [ dict(payee='Green Power', amount=120.0), dict(payee='Green Power', amount=150.0), dict(payee=Str('Green Power'), amount=170.0), Rec(payee='Car Loan', amount=250.0), dict(payee='Car Loan', amount=250.0), dict(payee='Car Loan', amount=250.0), dict(payee=Str('General Cable'), amount=120.0), dict(payee='General Cable', amount=155.0), Rec(payee='General Cable', amount=120.0), dict(payee='Mortgage', amount=1250.0), dict(payee='Mortgage', amount=1250.0), dict(payee='Mortgage', amount=1250.0), dict(payee='Animal Hospital', amount=600.0), ], [ dict(payee='General Cable - Cottage', amount=120.0), dict(payee='General Cable - Cottage', amount=155.0), Rec(payee='General Cable - Cottage', amount=120.0), dict(payee='Second Mortgage', amount=1250.0), dict(payee='Second Mortgage', amount=1250.0), dict(payee=Str('Second Mortgage'), amount=1250.0), dict(payee='Hobby Shop', amount=600.0), ] ] self.assertEqual(arrayOperators.distinctUnionOfArrays(transactions, ('payee',)), ['Green Power', 'Car Loan', 'General Cable', 'Mortgage', 'Animal Hospital', 'General Cable - Cottage', 'Second Mortgage', 'Hobby Shop']) self.assertEqual(KeyValueCoding.getKeyPath(transactions, '@distinctUnionOfArrays.payee'), ['Green Power', 'Car Loan', 'General Cable', 'Mortgage', 'Animal Hospital', 'General Cable - Cottage', 'Second Mortgage', 'Hobby Shop']) self.assertEqual(arrayOperators.unionOfArrays(transactions, ('payee',)), [ 'Green Power', 'Green Power', 'Green Power', 'Car Loan', 'Car Loan', 'Car Loan', 'General Cable', 'General Cable', 'General Cable', 'Mortgage', 'Mortgage', 'Mortgage', 'Animal Hospital', 'General Cable - Cottage', 'General Cable - Cottage', 'General Cable - Cottage', 'Second Mortgage', 'Second Mortgage', 'Second Mortgage', 'Hobby Shop' ]) self.assertEqual(KeyValueCoding.getKeyPath(transactions, '@unionOfArrays.payee'), [ 'Green Power', 'Green Power', 'Green Power', 'Car Loan', 'Car Loan', 'Car Loan', 'General Cable', 'General Cable', 'General Cable', 'Mortgage', 'Mortgage', 'Mortgage', 'Animal Hospital', 'General Cable - Cottage', 'General Cable - Cottage', 'General Cable - Cottage', 'Second Mortgage', 'Second Mortgage', 'Second Mortgage', 'Hobby Shop' ]) self.assertRaises(KeyError, arrayOperators.unionOfArrays, transactions, 'date') self.assertRaises(KeyError, arrayOperators.distinctUnionOfArrays, transactions, 'date')
def test_none_get(self): self.assertEqual(KeyValueCoding.getKey(None, 'a'), None) self.assertEqual(KeyValueCoding.getKeyPath(None, 'a'), None)
def test_none_set(self): # setKey(None, 'any', 'value') is documented as a no-op # check that this doesn't raise an exception. v = None KeyValueCoding.setKey(v, 'a', 42) KeyValueCoding.setKeyPath(v, 'a', 42)
def test_accessor_get(self): class Object (object): def get_attr1(self): return "attr1" def getAttr1(self): return "Attr1" def attr1(self): return ".attr1" def get_attr2(self): return "attr2" def attr2(self): return '.attr2' def attr3(self): return '.attr3' def isAttr4(self): return "attr4?" @objc.selector def attrsel(self): return 'selattr' r = Object() self.assertEqual(KeyValueCoding.getKey(r, 'attr1'), 'Attr1') self.assertEqual(KeyValueCoding.getKey(r, 'attr2'), 'attr2') self.assertEqual(KeyValueCoding.getKey(r, 'attr3'), '.attr3') self.assertEqual(KeyValueCoding.getKey(r, 'attr4'), 'attr4?') self.assertEqual(KeyValueCoding.getKey(r, 'attrsel'), 'selattr') t = Object() o = objc.lookUpClass('NSObject').alloc().init() l = [] r.attr5 = t.isAttr4 r.attr6 = o.description r.attr7 = l.__len__ r.attr8 = os.getpid r.attr9 = 'attribute 9' self.assertEqual(KeyValueCoding.getKey(r, 'attr5'), t.isAttr4) self.assertEqual( KeyValueCoding.getKey(r, 'attr6'), r.attr6) self.assertEqual(KeyValueCoding.getKey(r, 'attr7'), l.__len__) self.assertEqual(KeyValueCoding.getKey(r, 'attr8'), os.getpid()) self.assertEqual(KeyValueCoding.getKey(r, 'attr9'), 'attribute 9') self.assertEqual(KeyValueCoding.getKey(1.5, 'hex'), (1.5).hex())