## Check unsuccessful searches.
me.assertRaises(KeyError, lambda: kf["notexist"])
- me.assertEqual(kf.bytag("notexist"), None)
- me.assertEqual(kf.bytag(12345), None)
- me.assertEqual(kf.bytype("notexist"), None)
+ me.assertRaises(C.KeyError, kf.bytag, "notexist")
+ me.assertRaises(C.KeyError, kf.bytag, 12345)
+ me.assertEqual(kf.bytag("notexist", fail = False), None)
+ me.assertRaises(C.KeyError, kf.bytype, "notexist")
me.assertRaises(TypeError, kf.bytype, 12345)
+ me.assertEqual(kf.bytype("notexist", fail = False), None)
me.assertRaises(C.KeyError, kf.byid, 0x12345678)
+ me.assertEqual(kf.byid(0x12345678, fail = False), None)
me.assertRaises(C.KeyError, kf.mergeline, "nowhere", 2, "")
k = kf.newkey(0x11111111, "first", exp)
me.assertEqual(kf.modifiedp, True)
- me.assertEqual(kf[0x11111111].id, 0x11111111)
+ me.assertEqual(k, kf[0x11111111])
me.assertEqual(k.exptime, exp)
me.assertEqual(k.deltime, exp)
me.assertRaises(ValueError, setattr, k, "deltime", C.KEXP_FOREVER)
"22222222:test integer,public:32519164 forever forever -")
###--------------------------------------------------------------------------
-
-def keydata_equalp(kd0, kd1):
- if type(kd0) is not type(kd1): return False
- elif type(kd0) is C.KeyDataBinary: return kd0.bin == kd1.bin
- elif type(kd0) is C.KeyDataMP: return kd0.mp == kd1.mp
- elif type(kd0) is C.KeyDataEncrypted: return kd0.ct == kd1.ct
- elif type(kd0) is C.KeyDataECPt: return kd0.ecpt == kd1.ecpt
- elif type(kd0) is C.KeyDataString: return kd0.str == kd1.str
- elif type(kd0) is C.KeyDataStructured:
- if len(kd0) != len(kd1): return False
- for t, v0 in T.iteritems(kd0):
- try: v1 = kd1[t]
- except KeyError: return False
- if not keydata_equalp(v0, v1): return False
- return True
- else:
- raise SystemError("unexpected keydata type")
-
class TestKeyData (U.TestCase):
def test_flags(me):
me.assertEqual(set(T.iterkeys(kd2)), set(["b"]))
def check_encode(me, kd):
- me.assertTrue(keydata_equalp(C.KeyData.decode(kd.encode()), kd))
- kd1, tail = C.KeyData.read(kd.write())
- me.assertEqual(tail, "")
- me.assertTrue(keydata_equalp(kd, kd1))
+ me.assertEqual(C.KeyData.decode(kd.encode()), kd)
+ me.assertEqual(C.KeyData.read(kd.write()), (kd, ""))
def test_bin(me):
rng = T.detrand("kd-bin")
def test_struct(me):
rng = T.detrand("kd-struct")
kd = C.KeyDataStructured({ "a": C.KeyDataString("a"),
- "b": C.KeyDataString("b"),
- "c": C.KeyDataString("c"),
- "d": C.KeyDataString("d") })
+ "b": C.KeyDataString("b") },
+ c = C.KeyDataString("c"),
+ d = C.KeyDataString("d"))
for i in ["a", "b", "c", "d"]: me.assertEqual(kd[i].str, i)
me.assertEqual(len(kd), 4)
me.check_encode(kd)
me.assertRaises(TypeError, C.KeyDataStructured, { "a": "a" })
+ me.assertRaises(ValueError, C.KeyDataStructured,
+ { "a": C.KeyDataString("a") },
+ a = C.KeyDataString("b"))
###--------------------------------------------------------------------------
### Mappings.
me.check_immutable_mapping(kf, model)
+class TestKeyStructMapping (T.MutableMappingTestMixin):
+ def _mkvalue(me, i): return C.KeyDataMP(i)
+ def _getvalue(me, v): return v.mp
+
+ def test_keystructmap(me):
+ me.check_mapping(C.KeyDataStructured)
+
class TestKeyAttrMapping (T.MutableMappingTestMixin):
def test_attrmap(me):