+ def test_unknown_strip_prefix_for_ro(self):
+ self.failUnlessEqual(strip_prefix_for_ro("foo", False), "foo")
+ self.failUnlessEqual(strip_prefix_for_ro("ro.foo", False), "foo")
+ self.failUnlessEqual(strip_prefix_for_ro("imm.foo", False), "imm.foo")
+ self.failUnlessEqual(strip_prefix_for_ro("foo", True), "foo")
+ self.failUnlessEqual(strip_prefix_for_ro("ro.foo", True), "foo")
+ self.failUnlessEqual(strip_prefix_for_ro("imm.foo", True), "foo")
+
+ def test_unknownnode(self):
+ mut_write_uri = "URI:SSK:vfvcbdfbszyrsaxchgevhmmlii:euw4iw7bbnkrrwpzuburbhppuxhc3gwxv26f6imekhz7zyw2ojnq"
+ mut_read_uri = "URI:SSK-RO:jf6wkflosyvntwxqcdo7a54jvm:euw4iw7bbnkrrwpzuburbhppuxhc3gwxv26f6imekhz7zyw2ojnq"
+ lit_uri = "URI:LIT:n5xgk"
+
+ # This does not attempt to be exhaustive.
+ no_no = [# Opaque node, but not an error.
+ ( 0, UnknownNode(None, None)),
+ ( 1, UnknownNode(None, None, deep_immutable=True)),
+ ]
+ unknown_rw = [# These are errors because we're only given a rw_uri, and we can't
+ # diminish it.
+ ( 2, UnknownNode("foo", None)),
+ ( 3, UnknownNode("foo", None, deep_immutable=True)),
+ ( 4, UnknownNode("ro.foo", None, deep_immutable=True)),
+ ( 5, UnknownNode("ro." + mut_read_uri, None, deep_immutable=True)),
+ ( 6, UnknownNode("URI:SSK-RO:foo", None, deep_immutable=True)),
+ ( 7, UnknownNode("URI:SSK:foo", None)),
+ ]
+ must_be_ro = [# These are errors because a readonly constraint is not met.
+ ( 8, UnknownNode("ro." + mut_write_uri, None)),
+ ( 9, UnknownNode(None, "ro." + mut_write_uri)),
+ ]
+ must_be_imm = [# These are errors because an immutable constraint is not met.
+ (10, UnknownNode(None, "ro.URI:SSK-RO:foo", deep_immutable=True)),
+ (11, UnknownNode(None, "imm.URI:SSK:foo")),
+ (12, UnknownNode(None, "imm.URI:SSK-RO:foo")),
+ (13, UnknownNode("bar", "ro.foo", deep_immutable=True)),
+ (14, UnknownNode("bar", "imm.foo", deep_immutable=True)),
+ (15, UnknownNode("bar", "imm." + lit_uri, deep_immutable=True)),
+ (16, UnknownNode("imm." + mut_write_uri, None)),
+ (17, UnknownNode("imm." + mut_read_uri, None)),
+ (18, UnknownNode("bar", "imm.foo")),
+ ]
+ bad_uri = [# These are errors because the URI is bad once we've stripped the prefix.
+ (19, UnknownNode("ro.URI:SSK-RO:foo", None)),
+ (20, UnknownNode("imm.URI:CHK:foo", None, deep_immutable=True)),
+ ]
+ ro_prefixed = [# These are valid, and the readcap should end up with a ro. prefix.
+ (21, UnknownNode(None, "foo")),
+ (22, UnknownNode(None, "ro.foo")),
+ (32, UnknownNode(None, "ro." + lit_uri)),
+ (23, UnknownNode("bar", "foo")),
+ (24, UnknownNode("bar", "ro.foo")),
+ (32, UnknownNode("bar", "ro." + lit_uri)),
+ (25, UnknownNode("ro.foo", None)),
+ (30, UnknownNode("ro." + lit_uri, None)),
+ ]
+ imm_prefixed = [# These are valid, and the readcap should end up with an imm. prefix.
+ (26, UnknownNode(None, "foo", deep_immutable=True)),
+ (27, UnknownNode(None, "ro.foo", deep_immutable=True)),
+ (28, UnknownNode(None, "imm.foo")),
+ (29, UnknownNode(None, "imm.foo", deep_immutable=True)),
+ (31, UnknownNode("imm." + lit_uri, None)),
+ (31, UnknownNode("imm." + lit_uri, None, deep_immutable=True)),
+ (33, UnknownNode(None, "imm." + lit_uri)),
+ (33, UnknownNode(None, "imm." + lit_uri, deep_immutable=True)),
+ ]
+ error = unknown_rw + must_be_ro + must_be_imm + bad_uri
+ ok = ro_prefixed + imm_prefixed
+
+ for (i, n) in no_no + error + ok:
+ self.failUnless(n.is_unknown(), i)
+
+ for (i, n) in no_no + error:
+ self.failUnless(n.get_uri() is None, i)
+ self.failUnless(n.get_write_uri() is None, i)
+ self.failUnless(n.get_readonly_uri() is None, i)
+
+ for (i, n) in no_no + ok:
+ n.raise_error()
+
+ for (i, n) in unknown_rw:
+ self.failUnlessRaises(MustNotBeUnknownRWError, lambda: n.raise_error())
+
+ for (i, n) in must_be_ro:
+ self.failUnlessRaises(MustBeReadonlyError, lambda: n.raise_error())
+
+ for (i, n) in must_be_imm:
+ self.failUnlessRaises(MustBeDeepImmutableError, lambda: n.raise_error())
+
+ for (i, n) in bad_uri:
+ self.failUnlessRaises(uri.BadURIError, lambda: n.raise_error())
+
+ for (i, n) in ok:
+ self.failIf(n.get_readonly_uri() is None, i)
+
+ for (i, n) in ro_prefixed:
+ self.failUnless(n.get_readonly_uri().startswith("ro."), i)
+
+ for (i, n) in imm_prefixed:
+ self.failUnless(n.get_readonly_uri().startswith("imm."), i)
+
+