def test_dict(self): d = {"one": 1, "two": 2, "three": 3} for i in (1, 2, 3): self.assertTrue(i in py2.dict_values(d)) self.assertFalse(i in py2.dict_keys(d)) self.assertFalse("one" in py2.dict_values(d)) self.assertTrue("one" in py2.dict_keys(d)) self.assertTrue(("one", 1) in py2.dict_items(d)) self.assertFalse((1, "one") in py2.dict_items(d)) # finally, these functions return iterable objects, not lists try: py2.dict_keys(d)[0] self.fail("dict_keys can be indexed") except TypeError: pass try: py2.dict_values(d)[0] self.fail("dict_values can be indexed") except TypeError: pass try: py2.dict_items(d)[0] self.fail("dict_items can be indexed") except TypeError: pass
def test_dict(self): d = {"one": 1, "two": 2, "three": 3} for i in (1, 2, 3): self.assertTrue(i in py2.dict_values(d)) self.assertFalse(i in py2.dict_keys(d)) self.assertFalse("one" in py2.dict_values(d)) self.assertTrue("one" in py2.dict_keys(d))
def test_get_set(self): e = atom.AtomElement(None) e.set_base("http://www.example.com/") self.assertTrue(e.get_base() == "http://www.example.com/", "Get/Set example xml:base value") e.set_lang("en-US") self.assertTrue(e.get_lang() == "en-US", "Get/Set example xml:lang value") attrs = e.get_attributes() self.assertTrue(sum(1 for k in dict_keys(attrs)) == 2, "Two attributes expected") self.assertTrue(attrs[(xmlns.XML_NAMESPACE, 'base')] == "http://www.example.com/", "Base attribute") self.assertTrue(attrs[(xmlns.XML_NAMESPACE, 'lang')] == "en-US", "Lang attribute") e.set_base(None) attrs = e.get_attributes() self.assertTrue(e.get_base() is None, "Get/Set empty xml:base value") self.assertTrue(sum(1 for k in dict_keys(attrs)) == 1, "One attribute expected") e.set_lang(None) attrs = e.get_attributes() self.assertTrue(e.get_lang() is None, "Get/Set empty xml:lang value") self.assertTrue(sum(1 for k in dict_keys(attrs)) == 0, "No attributes expected")
def test_se_range(self): """seRange ::= charOrEsc '-' charOrEsc """ tests = { 'a-c': ("abc", "`dABC"), '\\?-A': ("?@A", ">Ba"), 'z-\\|': ("z{|", "y}Z") } for b in dict_keys(tests): p = xsi.RegularExpressionParser(b) try: cclass = p.require_se_range() except xsi.RegularExpressionError: logging.debug("Failed to parse %s" % repr(b)) raise self.assertTrue(p.the_char is None) t1, t2 = tests[b] for c in t1: self.assertTrue(cclass.test(c), "%s not in %s" % (repr(c), b)) for c in t2: self.assertFalse(cclass.test(c), "%s in %s" % (repr(c), b)) p = xsi.RegularExpressionParser("c-a") try: cclass = p.require_se_range() self.fail("Failed to spot reversed range") except xsi.RegularExpressionError: pass
def test_char_prop(self): """:: charProp ::= IsCategory | IsBlock""" tests = { # positive and negative tests 'Nd': (u8(b'123\xdb\xb1\xdb\xb2\xdb\xb3'), u8(b'ABC\xe2\x85\x95\xe2\x85\x96\xe2\x85\x97\xe2\x85\x98')), 'S': (u8(b'+<=>\xe2\x81\x84\xe2\x82\xac'), "(){}"), 'IsBasicLatin': ("ABC", ul("\xc0\xdf\xa9")), 'IsLatin-1Supplement': (ul("\xc0\xdf\xa9"), "ABC"), 'IsCurrencySymbols': (u8(b'\xe2\x82\xa4\xe2\x82\xa9\xe2\x82\xac'), ul("\x24\xa2\xa3")), 'IsNumberForms': ( u8(b'\xe2\x85\x95\xe2\x85\x96\xe2\x85\x97\xe2\x85\x98'), "1/5 2/5 3/5 4/5") } for b in dict_keys(tests): p = xsi.RegularExpressionParser(b) cclass = p.require_char_prop() self.assertTrue(p.the_char is None) t1, t2 = tests[b] for c in t1: self.assertTrue(cclass.test(c), "%s not in %s" % (repr(c), b)) for c in t2: self.assertFalse(cclass.test(c), "%s in %s" % (repr(c), b))
def test_is_block(self): """:: IsBlock ::= 'Is' [a-zA-Z0-9#x2D]+""" tests = { # positive and negative tests 'BasicLatin': ("ABC", ul("\xc0\xdf\xa9")), 'Latin-1Supplement': (ul("\xc0\xdf\xa9"), "ABC"), 'CurrencySymbols': (u8(b'\xe2\x82\xa4\xe2\x82\xa9\xe2\x82\xac'), ul("\x24\xa2\xa3")), 'NumberForms': ( u8(b'\xe2\x85\x95\xe2\x85\x96\xe2\x85\x97\xe2\x85\x98'), "1/5 2/5 3/5 4/5") } for b in dict_keys(tests): p = xsi.RegularExpressionParser("Is" + b) cclass = p.require_is_block() self.assertTrue(p.the_char is None) t1, t2 = tests[b] for c in t1: self.assertTrue(cclass.test(c), "%s not in %s" % (repr(c), b)) for c in t2: self.assertFalse(cclass.test(c), "%s in Is%s" % (repr(c), b)) p = xsi.RegularExpressionParser("IsNumberFoams") try: cclass = p.require_is_block() self.fail("IsNumberFoams") except xsi.RegularExpressionError: pass
def test_quant_exact(self): """:: QuantExact ::= [0-9]+ """ tests = { '0': 0, '1': 1, '9': 9, '01': 1, '010': 10, '020': 20, '20': 20, '99': 99 } for b in dict_keys(tests): p = xsi.RegularExpressionParser(b) try: result = p.require_quant_exact() self.assertTrue(result == tests[b], "Mismatched number: %s expected %s" % (repr(result), repr(tests[b]))) except xsi.RegularExpressionError: logging.debug("Failed to parse %s" % repr(b)) raise self.assertTrue(p.the_char is None) p = xsi.RegularExpressionParser("x") try: p.require_quant_exact() self.fail("Parsed x as QuantExact") except xsi.RegularExpressionError: pass
def test_quant_exact(self): """:: QuantExact ::= [0-9]+ """ tests = { '0': 0, '1': 1, '9': 9, '01': 1, '010': 10, '020': 20, '20': 20, '99': 99 } for b in dict_keys(tests): p = xsi.RegularExpressionParser(b) try: result = p.require_quant_exact() self.assertTrue( result == tests[b], "Mismatched number: %s expected %s" % (repr(result), repr(tests[b]))) except xsi.RegularExpressionError: logging.debug("Failed to parse %s" % repr(b)) raise self.assertTrue(p.the_char is None) p = xsi.RegularExpressionParser("x") try: p.require_quant_exact() self.fail("Parsed x as QuantExact") except xsi.RegularExpressionError: pass
def test_decode(self): tests = { "-1.23": -1.23, "+100000.00": 100000.0, "210.": 210.0, "010": 10, "010.": 10, "01.0": 1, "0.10": 0.1, ".010": 0.01, " 1": ValueError, "1,000": ValueError, "0.0": 0.0, "+0.0": 0.0, "-0.0": 0.0, "1E+2": ValueError, "1e-2": ValueError, "1 ": ValueError, "1 000": ValueError } for src in dict_keys(tests): t = tests[src] try: result = xsi.decimal_from_str(src) self.assertTrue( result == t, "Mismatched decimal: %s expected %s" % (repr(result), repr(t))) except ValueError: if t is ValueError: pass else: logging.debug("Failed to parse %s" % repr(src)) raise
def test_char_prop(self): """:: charProp ::= IsCategory | IsBlock""" tests = { # positive and negative tests 'Nd': (u8(b'123\xdb\xb1\xdb\xb2\xdb\xb3'), u8(b'ABC\xe2\x85\x95\xe2\x85\x96\xe2\x85\x97\xe2\x85\x98')), 'S': (u8(b'+<=>\xe2\x81\x84\xe2\x82\xac'), "(){}"), 'IsBasicLatin': ("ABC", ul("\xc0\xdf\xa9")), 'IsLatin-1Supplement': (ul("\xc0\xdf\xa9"), "ABC"), 'IsCurrencySymbols': (u8(b'\xe2\x82\xa4\xe2\x82\xa9\xe2\x82\xac'), ul("\x24\xa2\xa3")), 'IsNumberForms': (u8(b'\xe2\x85\x95\xe2\x85\x96\xe2\x85\x97\xe2\x85\x98'), "1/5 2/5 3/5 4/5") } for b in dict_keys(tests): p = xsi.RegularExpressionParser(b) cclass = p.require_char_prop() self.assertTrue(p.the_char is None) t1, t2 = tests[b] for c in t1: self.assertTrue(cclass.test(c), "%s not in %s" % (repr(c), b)) for c in t2: self.assertFalse(cclass.test(c), "%s in %s" % (repr(c), b))
def test_is_block(self): """:: IsBlock ::= 'Is' [a-zA-Z0-9#x2D]+""" tests = { # positive and negative tests 'BasicLatin': ("ABC", ul("\xc0\xdf\xa9")), 'Latin-1Supplement': (ul("\xc0\xdf\xa9"), "ABC"), 'CurrencySymbols': (u8(b'\xe2\x82\xa4\xe2\x82\xa9\xe2\x82\xac'), ul("\x24\xa2\xa3")), 'NumberForms': (u8(b'\xe2\x85\x95\xe2\x85\x96\xe2\x85\x97\xe2\x85\x98'), "1/5 2/5 3/5 4/5") } for b in dict_keys(tests): p = xsi.RegularExpressionParser("Is" + b) cclass = p.require_is_block() self.assertTrue(p.the_char is None) t1, t2 = tests[b] for c in t1: self.assertTrue(cclass.test(c), "%s not in %s" % (repr(c), b)) for c in t2: self.assertFalse(cclass.test(c), "%s in Is%s" % (repr(c), b)) p = xsi.RegularExpressionParser("IsNumberFoams") try: cclass = p.require_is_block() self.fail("IsNumberFoams") except xsi.RegularExpressionError: pass
def test_constructor(self): entry = atom.Entry(None) self.assertTrue(isinstance(entry, atom.AtomElement), "Entry not an AtomElement") self.assertTrue(entry.get_base() is None, "xml:base present on construction") self.assertTrue(entry.get_lang() is None, "xml:lang present on construction") attrs = entry.get_attributes() self.assertTrue(sum(1 for k in dict_keys(attrs)) == 0, "Attributes present on construction")
def test_quantity(self): """:: quantity ::= quantRange | quantMin | QuantExact quantRange ::= QuantExact ',' QuantExact quantMin ::= QuantExact ',' """ tests = { '0,0': (0, 0), '0,': (0, None), '99,': (99, None), '0': (0, 0), '99': (99, 99), '99,1': xsi.RegularExpressionParser, '1,99': (1, 99), '0,99': (0, 99), ',99': xsi.RegularExpressionParser, '?': xsi.RegularExpressionParser, '*': xsi.RegularExpressionParser, '+': xsi.RegularExpressionParser } for b in dict_keys(tests): p = xsi.RegularExpressionParser(b) t = tests[b] try: x, y = p.require_quantity() self.assertTrue( x == t[0] and y == t[1], "Mismatched quantity: %s expected %s" % (repr( (x, y)), repr(t))) self.assertTrue(p.the_char is None) except xsi.RegularExpressionError: if t is xsi.RegularExpressionParser: pass else: logging.debug("Failed to parse %s" % repr(b)) raise
def test_quantity(self): """:: quantity ::= quantRange | quantMin | QuantExact quantRange ::= QuantExact ',' QuantExact quantMin ::= QuantExact ',' """ tests = { '0,0': (0, 0), '0,': (0, None), '99,': (99, None), '0': (0, 0), '99': (99, 99), '99,1': xsi.RegularExpressionParser, '1,99': (1, 99), '0,99': (0, 99), ',99': xsi.RegularExpressionParser, '?': xsi.RegularExpressionParser, '*': xsi.RegularExpressionParser, '+': xsi.RegularExpressionParser } for b in dict_keys(tests): p = xsi.RegularExpressionParser(b) t = tests[b] try: x, y = p.require_quantity() self.assertTrue(x == t[0] and y == t[1], "Mismatched quantity: %s expected %s" % (repr((x, y)), repr(t))) self.assertTrue(p.the_char is None) except xsi.RegularExpressionError: if t is xsi.RegularExpressionParser: pass else: logging.debug("Failed to parse %s" % repr(b)) raise
def test_decode(self): tests = { "-1.23": -1.23, "+100000.00": 100000.0, "210.": 210.0, "010": 10, "010.": 10, "01.0": 1, "0.10": 0.1, ".010": 0.01, " 1": ValueError, "1,000": ValueError, "0.0": 0.0, "+0.0": 0.0, "-0.0": 0.0, "1E+2": ValueError, "1e-2": ValueError, "1 ": ValueError, "1 000": ValueError} for src in dict_keys(tests): t = tests[src] try: result = xsi.decimal_from_str(src) self.assertTrue(result == t, "Mismatched decimal: %s expected %s" % (repr(result), repr(t))) except ValueError: if t is ValueError: pass else: logging.debug("Failed to parse %s" % repr(src)) raise
def test_server(self): for k in dict_keys(SERVER_EXAMPLES): userinfo, host, port = uri.split_server(k) userinfo2, host2, port2 = SERVER_EXAMPLES[k] self.assertTrue(userinfo == userinfo2, "%s found userinfo %s" % (repr(k), repr(userinfo2))) self.assertTrue(host == host2, "%s found host %s" % (k, host2)) self.assertTrue(port == port2, "%s found port %s" % (k, port2))
def test_attributes(self): e = structures.Element(None) e.set_xmlname("test") e.set_attribute("atest", "value") attrs = e.get_attributes() self.assertTrue(len(list(dict_keys(attrs))) == 1, "Attribute not set") self.assertTrue(attrs["atest"] == "value", "Attribute not set correctly") e = ReflectiveElement(None) e.set_attribute("atest", "value") # Deprecated: self.assertTrue(e.atest=='value',"Attribute relfection") attrs = e.get_attributes() self.assertTrue(attrs["atest"] == "value", "Attribute not set correctly") e.set_attribute("btest", "Yes") self.assertTrue(e.bTest == "Yes", "Attribute relfection with simple assignment") attrs = e.get_attributes() self.assertTrue(attrs["btest"] == "Yes", "Attribute not set correctly") e.set_attribute("ctest", "Yes") self.assertTrue(e.cTest is True, "Attribute relfection with decode/encode") attrs = e.get_attributes() self.assertTrue(attrs["ctest"] == "Yes", "Attribute not set correctly") self.assertFalse("dtest" in attrs, "Optional ordered list attribute") self.assertTrue(attrs["dtestR"] == "", "Required ordered list attribute") e.set_attribute("dtest", "Yes No") self.assertTrue(e.dTest == [True, False], "Attribute relfection with list; %s" % repr(e.dTest)) attrs = e.get_attributes() self.assertTrue(attrs["dtest"] == "Yes No", "Attribute not set correctly") self.assertFalse("etest" in attrs, "Optional unordered list attribute") self.assertTrue(attrs["etestR"] == "", "Required unordered list attribute") e.set_attribute("etest", "Yes No Yes") self.assertTrue(e.eTest == {True: 2, False: 1}, "Attribute relfection with list: %s" % repr(e.eTest)) attrs = e.get_attributes() self.assertTrue(attrs["etest"] == "No Yes Yes", "Attribute not set correctly: %s" % repr(attrs["etest"])) try: if e.ztest: pass self.fail("AttributeError required for undefined names") except AttributeError: pass e.ztest = 1 if e.ztest: pass del e.ztest try: if e.ztest: pass self.fail("AttributeError required for undefined names after del") except AttributeError: pass try: self.assertTrue(e.fTest is None, "Missing attribute auto value not None") except AttributeError: self.fail("Missing attribute auto value: AttributeError") e.fTest = 1 del e.fTest try: self.assertTrue(e.fTest is None, "Missing attribute auto value not None (after del)") except AttributeError: self.fail("Missing attribute auto value: AttributeError (after del)")
def test_constructor(self): text = atom.Text(None) self.assertTrue(text.xmlname is None, "element name on construction") self.assertTrue(isinstance(text, atom.AtomElement), "Text not an AtomElement") self.assertTrue(text.get_base() is None, "xml:base present on construction") self.assertTrue(text.get_lang() is None, "xml:lang present on construction") attrs = text.get_attributes() self.assertTrue(sum(1 for k in dict_keys(attrs)) == 1, "Attributes present on construction") self.assertTrue(text.get_value() == "", "Content present on construction")
def test_constructor(self): feed = atom.Feed(None) self.assertTrue(isinstance(feed, atom.AtomElement), "Feed not an AtomElement") self.assertTrue(feed.xmlname == "feed", "Feed XML name") self.assertTrue(feed.get_base() is None, "xml:base present on construction") self.assertTrue(feed.get_lang() is None, "xml:lang present on construction") self.assertTrue(len(feed.Entry) == 0, "Non-empty feed on construction") attrs = feed.get_attributes() self.assertTrue(sum(1 for k in dict_keys(attrs)) == 0, "Attributes present on construction")
def test_constructor(self): e = atom.AtomElement(None) self.assertTrue(e.parent is None, "empty parent on construction") self.assertTrue(e.xmlname is None, "element name on construction") self.assertTrue(e.get_base() is None, "xml:base present on construction") self.assertTrue(e.get_lang() is None, "xml:lang present on construction") attrs = e.get_attributes() self.assertTrue(sum(1 for k in dict_keys(attrs)) == 0, "Attributes present on construction") e2 = atom.AtomElement(e) self.assertTrue(e2.parent is e, "non-empty parent on construction")
def test_relative_examples(self): base = uri.URI(REL_BASE) current = uri.URI(REL_CURRENT) relatives = {} for k in dict_keys(REL_EXAMPLES): logging.info("Testing relative: %s", k) u = uri.URI(k) resolved, scheme, authority, abs_path, rel_path, query, \ fragment = REL_EXAMPLES[k] relatives[resolved] = relatives.get(resolved, []) + [k] resolution = str(u.resolve(base, current)) self.assertTrue(scheme == u.scheme, "%s found scheme %s" % (k, u.scheme)) self.assertTrue(authority == u.authority, "%s found authority %s" % (k, u.authority)) self.assertTrue(abs_path == u.abs_path, "%s found abs_path %s" % (k, u.abs_path)) self.assertTrue(rel_path == u.rel_path, "%s found rel_path %s" % (k, u.rel_path)) self.assertTrue(query == u.query, "%s found query %s" % (k, u.query)) self.assertTrue(fragment == u.fragment, "%s found fragment %s" % (k, u.fragment)) self.assertTrue(resolved == resolution, "%s [*] %s = %s ; found %s" % (str(base), k, resolved, resolution)) for r in dict_keys(relatives): logging.info("Testing %s [/] %s = ( %s )", r, str(base), ' | '.join(relatives[r])) u = uri.URI(r) # this check removes the 'current document' case if not u.is_absolute(): continue relative = str(u.relative(base)) # relative should be one of the relatives! no_match = True for k in relatives[r]: if k == relative: no_match = False break self.assertFalse(no_match, "%s [/] %s = ( %s ) ; found %s" % (r, str(base), ' | '.join(relatives[r]), relative))
def test_constructor(self): person = atom.Person(None) self.assertTrue(person.xmlname is None, "element name on construction") self.assertTrue(isinstance(person, atom.AtomElement), "Person not an AtomElement") self.assertTrue(person.get_base() is None, "xml:base present on construction") self.assertTrue(person.get_lang() is None, "xml:lang present on construction") attrs = person.get_attributes() self.assertTrue(sum(1 for k in dict_keys(attrs)) == 0, "Attributes present on construction") self.assertTrue(isinstance(person.Name, atom.Name), "Name on construction") self.assertTrue(person.URI is None, "URI on construction") self.assertTrue(person.Email is None, "Email on construction")
def test_constructor(self): svc = app.Service(None) self.assertTrue( isinstance(svc, app.APPElement), "Service not an APPElement") self.assertTrue(svc.xmlname == "service", "Service XML name") attrs = svc.get_attributes() self.assertTrue(sum(1 for k in dict_keys(attrs)) == 0, "Attributes present on construction") workspaces = svc.Workspace self.assertTrue( len(workspaces) == 0, "Workspaces present on construction")
def test_constructor(self): entry = atom.Entry(None) self.assertTrue( isinstance(entry, atom.AtomElement), "Entry not an AtomElement") self.assertTrue( entry.get_base() is None, "xml:base present on construction") self.assertTrue( entry.get_lang() is None, "xml:lang present on construction") attrs = entry.get_attributes() self.assertTrue(sum(1 for k in dict_keys(attrs)) == 0, "Attributes present on construction")
def test_constructor(self): e = structures.Element(None) self.assertTrue(e.xmlname is None, "element name on construction") self.assertTrue(e.get_document() is None, "document set on construction") attrs = e.get_attributes() self.assertTrue(len(list(dict_keys(attrs))) == 0, "Attributes present on construction") children = e.get_children() try: next(children) self.fail("Children present on construction") except StopIteration: pass
def test_constructor(self): e = app.APPElement(None) self.assertTrue(e.xmlname is None, 'element name on construction') self.assertTrue( e.get_base() is None, "xml:base present on construction") self.assertTrue( e.get_lang() is None, "xml:lang present on construction") self.assertTrue( e.get_space() is None, "xml:space present on construction") attrs = e.get_attributes() self.assertTrue(sum(1 for k in dict_keys(attrs)) == 0, "Attributes present on construction")
def test_constructor(self): svc = app.Service(None) self.assertTrue(isinstance(svc, app.APPElement), "Service not an APPElement") self.assertTrue(svc.xmlname == "service", "Service XML name") attrs = svc.get_attributes() self.assertTrue( sum(1 for k in dict_keys(attrs)) == 0, "Attributes present on construction") workspaces = svc.Workspace self.assertTrue( len(workspaces) == 0, "Workspaces present on construction")
def test_constructor(self): ws = app.Workspace(None) self.assertTrue( isinstance(ws, app.APPElement), "Workspace not an APPElement") self.assertTrue(ws.xmlname == "workspace", "Workspace XML name") attrs = ws.get_attributes() self.assertTrue(sum(1 for k in dict_keys(attrs)) == 0, "Attributes present on construction") self.assertTrue(ws.Title is None, "Title present on construction") collections = ws.Collection self.assertTrue( len(collections) == 0, "Collections present on construction")
def test_constructor(self): e = app.APPElement(None) self.assertTrue(e.xmlname is None, 'element name on construction') self.assertTrue(e.get_base() is None, "xml:base present on construction") self.assertTrue(e.get_lang() is None, "xml:lang present on construction") self.assertTrue(e.get_space() is None, "xml:space present on construction") attrs = e.get_attributes() self.assertTrue( sum(1 for k in dict_keys(attrs)) == 0, "Attributes present on construction")
def test_constructor(self): feed = atom.Feed(None) self.assertTrue( isinstance(feed, atom.AtomElement), "Feed not an AtomElement") self.assertTrue(feed.xmlname == "feed", "Feed XML name") self.assertTrue( feed.get_base() is None, "xml:base present on construction") self.assertTrue( feed.get_lang() is None, "xml:lang present on construction") self.assertTrue(len(feed.Entry) == 0, "Non-empty feed on construction") attrs = feed.get_attributes() self.assertTrue(sum(1 for k in dict_keys(attrs)) == 0, "Attributes present on construction")
def test_constructor(self): e = atom.AtomElement(None) self.assertTrue(e.parent is None, 'empty parent on construction') self.assertTrue(e.xmlname is None, 'element name on construction') self.assertTrue(e.get_base() is None, "xml:base present on construction") self.assertTrue(e.get_lang() is None, "xml:lang present on construction") attrs = e.get_attributes() self.assertTrue(sum(1 for k in dict_keys(attrs)) == 0, "Attributes present on construction") e2 = atom.AtomElement(e) self.assertTrue(e2.parent is e, 'non-empty parent on construction')
def test_atom_date_constructor(self): date = atom.Date(None) self.assertTrue(date.xmlname is None, "element name on construction") self.assertTrue(isinstance(date, atom.AtomElement), "Date not an AtomElement") self.assertTrue(date.get_base() is None, "xml:base present on construction") self.assertTrue(date.get_lang() is None, "xml:lang present on construction") attrs = date.get_attributes() self.assertTrue(sum(1 for k in dict_keys(attrs)) == 0, "Attributes present on construction") self.assertTrue(isinstance(date.get_value(), iso8601.TimePoint), "Value not a TimePoint") date.set_value("2016-10-22T19:10:00Z") date2 = date.get_value() self.assertTrue(isinstance(date2, iso8601.TimePoint), "Value not a TimePoint") self.assertTrue(date2 == iso8601.TimePoint.from_str("2016-10-22T19:10:00Z"))
def test_constructor(self): ws = app.Workspace(None) self.assertTrue(isinstance(ws, app.APPElement), "Workspace not an APPElement") self.assertTrue(ws.xmlname == "workspace", "Workspace XML name") attrs = ws.get_attributes() self.assertTrue( sum(1 for k in dict_keys(attrs)) == 0, "Attributes present on construction") self.assertTrue(ws.Title is None, "Title present on construction") collections = ws.Collection self.assertTrue( len(collections) == 0, "Collections present on construction")
def test_atom_date_constructor(self): date = atom.Date(None) self.assertTrue(date.xmlname is None, 'element name on construction') self.assertTrue(isinstance(date, atom.AtomElement), "Date not an AtomElement") self.assertTrue(date.get_base() is None, "xml:base present on construction") self.assertTrue(date.get_lang() is None, "xml:lang present on construction") attrs = date.get_attributes() self.assertTrue(sum(1 for k in dict_keys(attrs)) == 0, "Attributes present on construction") self.assertTrue(isinstance(date.get_value(), iso8601.TimePoint), "Value not a TimePoint")
def test_constructor(self): text = atom.Text(None) self.assertTrue(text.xmlname is None, 'element name on construction') self.assertTrue(isinstance(text, atom.AtomElement), "Text not an AtomElement") self.assertTrue(text.get_base() is None, "xml:base present on construction") self.assertTrue(text.get_lang() is None, "xml:lang present on construction") attrs = text.get_attributes() self.assertTrue(sum(1 for k in dict_keys(attrs)) == 1, "Attributes present on construction") self.assertTrue(text.get_value() == '', "Content present on construction")
def test_constructor(self): c = app.Collection(None) self.assertTrue( isinstance(c, app.APPElement), "Collection not an APPElement") self.assertTrue(c.xmlname == "collection", "Collection XML name") self.assertTrue(c.href is None, "HREF present on construction") attrs = c.get_attributes() self.assertTrue(sum(1 for k in dict_keys(attrs)) == 0, "Attributes present on construction") self.assertTrue(c.Title is None, "Title present on construction") self.assertTrue(len(c.Accept) == 0, "Accept list non-empty on construction") self.assertTrue(len(c.Categories) == 0, "Categories list non-empty on construction")
def test_constructor(self): e = structures.Element(None) self.assertTrue(e.xmlname is None, 'element name on construction') self.assertTrue(e.get_document() is None, 'document set on construction') attrs = e.get_attributes() self.assertTrue( len(list(dict_keys(attrs))) == 0, "Attributes present on construction") children = e.get_children() try: next(children) self.fail("Children present on construction") except StopIteration: pass
def test_constructor(self): c = app.Collection(None) self.assertTrue(isinstance(c, app.APPElement), "Collection not an APPElement") self.assertTrue(c.xmlname == "collection", "Collection XML name") self.assertTrue(c.href is None, "HREF present on construction") attrs = c.get_attributes() self.assertTrue( sum(1 for k in dict_keys(attrs)) == 0, "Attributes present on construction") self.assertTrue(c.Title is None, "Title present on construction") self.assertTrue( len(c.Accept) == 0, "Accept list non-empty on construction") self.assertTrue( len(c.Categories) == 0, "Categories list non-empty on construction")
def test_constructor(self): person = atom.Person(None) self.assertTrue(person.xmlname is None, 'element name on construction') self.assertTrue(isinstance(person, atom.AtomElement), "Person not an AtomElement") self.assertTrue(person.get_base() is None, "xml:base present on construction") self.assertTrue(person.get_lang() is None, "xml:lang present on construction") attrs = person.get_attributes() self.assertTrue(sum(1 for k in dict_keys(attrs)) == 0, "Attributes present on construction") self.assertTrue(isinstance(person.Name, atom.Name), "Name on construction") self.assertTrue(person.URI is None, "URI on construction") self.assertTrue(person.Email is None, "Email on construction")
def test_is_category(self): """:: IsCategory ::= Letters | Marks | Numbers | Punctuation | Separators | Symbols | Others Letters ::= 'L' [ultmo]? Marks ::= 'M' [nce]? Numbers ::= 'N' [dlo]? Punctuation ::= 'P' [cdseifo]? Separators ::= 'Z' [slp]? Symbols ::= 'S' [mcko]? Others ::= 'C' [cfon]?""" tests = [ "L", "Lu", "Ll", "Lt", "Lm", "Lo", "M", "Mn", "Mc", "Me", "N", "Nd", "Nl", "No", "P", "Pc", "Pd", "Ps", "Pe", "Pi", "Pf", "Po", "Z", "Zs", "Zl", "Zp", "S", "Sm", "Sc", "Sk", "So", "C", "Cc", "Cf", "Co", "Cn" ] bad = ["A", "Za"] for s in tests: p = xsi.RegularExpressionParser(s) self.assertTrue(isinstance(p.require_is_category(), CharClass), "Missing category: %s" % s) self.assertTrue(p.the_char is None, "Incomplete parse of category: %s" % s) for s in bad: p = xsi.RegularExpressionParser(s) try: p.require_is_category() self.assertFalse(p.the_char is None, "Undetected bad category: %s" % s) except xsi.RegularExpressionError: pass tests = { # positive and negative tests 'Nd': (u8(b'123\xdb\xb1\xdb\xb2\xdb\xb3'), u8(b'ABC\xe2\x85\x95\xe2\x85\x96\xe2\x85\x97\xe2\x85\x98')), 'S': (u8(b'+<=>\xe2\x81\x84\xe2\x82\xac'), "(){}") } for b in dict_keys(tests): p = xsi.RegularExpressionParser(b) cclass = p.require_is_category() self.assertTrue(p.the_char is None) t1, t2 = tests[b] for c in t1: self.assertTrue(cclass.test(c), "%s not in %s" % (repr(c), b)) for c in t2: self.assertFalse(cclass.test(c), "%s in %s" % (repr(c), b))
def test_is_category(self): """:: IsCategory ::= Letters | Marks | Numbers | Punctuation | Separators | Symbols | Others Letters ::= 'L' [ultmo]? Marks ::= 'M' [nce]? Numbers ::= 'N' [dlo]? Punctuation ::= 'P' [cdseifo]? Separators ::= 'Z' [slp]? Symbols ::= 'S' [mcko]? Others ::= 'C' [cfon]?""" tests = ["L", "Lu", "Ll", "Lt", "Lm", "Lo", "M", "Mn", "Mc", "Me", "N", "Nd", "Nl", "No", "P", "Pc", "Pd", "Ps", "Pe", "Pi", "Pf", "Po", "Z", "Zs", "Zl", "Zp", "S", "Sm", "Sc", "Sk", "So", "C", "Cc", "Cf", "Co", "Cn"] bad = ["A", "Za"] for s in tests: p = xsi.RegularExpressionParser(s) self.assertTrue(isinstance(p.require_is_category(), CharClass), "Missing category: %s" % s) self.assertTrue( p.the_char is None, "Incomplete parse of category: %s" % s) for s in bad: p = xsi.RegularExpressionParser(s) try: p.require_is_category() self.assertFalse( p.the_char is None, "Undetected bad category: %s" % s) except xsi.RegularExpressionError: pass tests = { # positive and negative tests 'Nd': ( u8(b'123\xdb\xb1\xdb\xb2\xdb\xb3'), u8(b'ABC\xe2\x85\x95\xe2\x85\x96\xe2\x85\x97\xe2\x85\x98')), 'S': (u8(b'+<=>\xe2\x81\x84\xe2\x82\xac'), "(){}") } for b in dict_keys(tests): p = xsi.RegularExpressionParser(b) cclass = p.require_is_category() self.assertTrue(p.the_char is None) t1, t2 = tests[b] for c in t1: self.assertTrue(cclass.test(c), "%s not in %s" % (repr(c), b)) for c in t2: self.assertFalse(cclass.test(c), "%s in %s" % (repr(c), b))
def test_absolute_examples(self): for k in dict_keys(ABS_EXAMPLES): logging.info("Testing absolute: %s", k) u = uri.URI(k) scheme, opaque_part, authority, abs_path, query, fName = \ ABS_EXAMPLES[k] self.assertTrue(scheme == u.scheme, "%s found scheme %s" % (k, u.scheme)) self.assertTrue(opaque_part == u.opaque_part, "%s found opaque_part %s" % (k, u.opaque_part)) self.assertTrue(authority == u.authority, "%s found authority %s" % (k, u.authority)) self.assertTrue(abs_path == u.abs_path, "%s found abs_path %s" % (k, u.abs_path)) self.assertTrue(query == u.query, "%s found query %s" % (k, u.query)) self.assertTrue(fName == u.get_file_name(), "%s found file name %s" % (k, u.get_file_name()))
def test_atom(self): """:: atom ::= Char | charClass | ( '(' regExp ')' ) """ tests = { 'A': "A", '[A-z-[\[-\]]]': "[A-Z_-z^]", '(Hello(Mum)|(Dad))': "(Hello(Mum)|(Dad))" } for b in dict_keys(tests): p = xsi.RegularExpressionParser(b) try: result = p.require_atom() self.assertTrue(result == tests[b], "Mismatched atom: %s expected %s" % (repr(result), repr(b))) except xsi.RegularExpressionError: logging.debug("Failed to parse %s" % repr(b)) raise self.assertTrue(p.the_char is None)
def test_reg_exp(self): """:: regExp ::= branch ( '|' branch )* """ tests = {"A.*Z": "A[^\\n\\r]*Z", ".*AAA.*": "[^\\n\\r]*AAA[^\\n\\r]*"} for b in dict_keys(tests): p = xsi.RegularExpressionParser(b) t = tests[b] try: result = p.require_reg_exp() self.assertTrue( result == t, "Mismatched regExp: %s expected %s" % (repr(result), repr(t))) self.assertTrue(p.the_char is None) except xsi.RegularExpressionError: if t is xsi.RegularExpressionParser: pass else: logging.debug("Failed to parse %s" % repr(b)) raise
def test_char_class_esc(self): """:: charClassEsc ::= ( SingleCharEsc | MultiCharEsc | catEsc | complEsc ) """ tests = { '\\?': ("?", "\\"), '\\d': (u8(b'123\xd9\xa1\xd9\xa2\xd9\xa3'), u8(b'ABC\xe2\x82\x81\xe2\x82\x82\xe2\x82\x83')), '\\p{S}': (u8(b'+<=>\xe2\x81\x84\xe2\x82\xac'), "(){}"), '\\P{S}': ("(){}", u8(b'+<=>\xe2\x81\x84\xe2\x82\xac'))} for b in dict_keys(tests): p = xsi.RegularExpressionParser(b) cclass = p.require_char_class_esc() self.assertTrue(p.the_char is None) t1, t2 = tests[b] for c in t1: self.assertTrue(cclass.test(c), "%s not in %s" % (repr(c), b)) for c in t2: self.assertFalse(cclass.test(c), "%s in %s" % (repr(c), b))
def test_constructor(self): e = app.Categories(None) self.assertTrue(e.ns == app.APP_NAMESPACE, 'ns on construction') self.assertTrue( e.xmlname == "categories", 'element name on construction') self.assertTrue( e.get_base() is None, "xml:base present on construction") self.assertTrue( e.get_lang() is None, "xml:lang present on construction") self.assertTrue( e.get_space() is None, "xml:space present on construction") attrs = e.get_attributes() self.assertTrue(sum(1 for k in dict_keys(attrs)) == 0, "Attributes present on construction") self.assertTrue(e.href is None, "href present on construction") self.assertTrue(e.fixed is None, "fixed on construction") self.assertTrue(e.scheme is None, "scheme present on construction") self.assertTrue( len(e.Category) == 0, "Category list non empty on construction")
def test_atom(self): """:: atom ::= Char | charClass | ( '(' regExp ')' ) """ tests = { 'A': "A", '[A-z-[\[-\]]]': "[A-Z_-z^]", '(Hello(Mum)|(Dad))': "(Hello(Mum)|(Dad))" } for b in dict_keys(tests): p = xsi.RegularExpressionParser(b) try: result = p.require_atom() self.assertTrue( result == tests[b], "Mismatched atom: %s expected %s" % (repr(result), repr(b))) except xsi.RegularExpressionError: logging.debug("Failed to parse %s" % repr(b)) raise self.assertTrue(p.the_char is None)
def test_piece(self): """:: piece ::= atom quantifier? """ tests = { 'A': "A", '[A-z-[\[-\]]]': "[A-Z_-z^]", '(Hello(Mum)|(Dad))': "(Hello(Mum)|(Dad))", "A{0,0}": "", '[A-Z]{0,1}': "[A-Z]?", '(Hello){0,}': "(Hello)*", 'B{1,}': "B+", ul('[@-\xA9]?'): ul("[@-\xA9]?"), '(Bye)*': "(Bye)*", 'X+': "X+", '[45]{099,}': "[45]{99,}", '(45){0}': "", '@{99}': "@{99}", 'A{99,1}': xsi.RegularExpressionParser, 'A{1,99}': "A{1,99}", 'A{0,99}': "A{,99}", 'A{,99}': xsi.RegularExpressionParser, '$': "\\$", '^': "\\^", 'A{1,99': xsi.RegularExpressionParser, '\\{{0,1}': "\\{?", '\\??': "\\??" } for b in dict_keys(tests): p = xsi.RegularExpressionParser(b) t = tests[b] try: result = p.require_piece() self.assertTrue(result == t, "Mismatched piece: %s expected %s" % (repr(result), repr(t))) self.assertTrue(p.the_char is None) except xsi.RegularExpressionError: if t is xsi.RegularExpressionParser: pass else: logging.debug("Failed to parse %s" % repr(b)) raise
def test_piece(self): """:: piece ::= atom quantifier? """ tests = { 'A': "A", '[A-z-[\[-\]]]': "[A-Z_-z^]", '(Hello(Mum)|(Dad))': "(Hello(Mum)|(Dad))", "A{0,0}": "", '[A-Z]{0,1}': "[A-Z]?", '(Hello){0,}': "(Hello)*", 'B{1,}': "B+", ul('[@-\xA9]?'): ul("[@-\xA9]?"), '(Bye)*': "(Bye)*", 'X+': "X+", '[45]{099,}': "[45]{99,}", '(45){0}': "", '@{99}': "@{99}", 'A{99,1}': xsi.RegularExpressionParser, 'A{1,99}': "A{1,99}", 'A{0,99}': "A{,99}", 'A{,99}': xsi.RegularExpressionParser, '$': "\\$", '^': "\\^", 'A{1,99': xsi.RegularExpressionParser, '\\{{0,1}': "\\{?", '\\??': "\\??" } for b in dict_keys(tests): p = xsi.RegularExpressionParser(b) t = tests[b] try: result = p.require_piece() self.assertTrue( result == t, "Mismatched piece: %s expected %s" % (repr(result), repr(t))) self.assertTrue(p.the_char is None) except xsi.RegularExpressionError: if t is xsi.RegularExpressionParser: pass else: logging.debug("Failed to parse %s" % repr(b)) raise
def test_compl_esc(self): """:: complEsc ::= '\P{' charProp '}' """ tests = { # positive and negative tests '\\P{Nd}': (u8(b'ABC\xe2\x85\x95\xe2\x85\x96\xe2\x85\x97\xe2\x85\x98'), u8(b'123\xdb\xb1\xdb\xb2\xdb\xb3')), '\\P{S}': ("(){}", u8(b'+<=>\xe2\x81\x84\xe2\x82\xac')), '\\P{IsBasicLatin}': (ul("\xc0\xdf\xa9"), "ABC") } for b in dict_keys(tests): p = xsi.RegularExpressionParser(b) cclass = p.require_compl_esc() self.assertTrue(p.the_char is None) t1, t2 = tests[b] for c in t1: self.assertTrue(cclass.test(c), "%s not in %s" % (repr(c), b)) for c in t2: self.assertFalse(cclass.test(c), "%s in %s" % (repr(c), b))
def test_char_class_esc(self): """:: charClassEsc ::= ( SingleCharEsc | MultiCharEsc | catEsc | complEsc ) """ tests = { '\\?': ("?", "\\"), '\\d': (u8(b'123\xd9\xa1\xd9\xa2\xd9\xa3'), u8(b'ABC\xe2\x82\x81\xe2\x82\x82\xe2\x82\x83')), '\\p{S}': (u8(b'+<=>\xe2\x81\x84\xe2\x82\xac'), "(){}"), '\\P{S}': ("(){}", u8(b'+<=>\xe2\x81\x84\xe2\x82\xac')) } for b in dict_keys(tests): p = xsi.RegularExpressionParser(b) cclass = p.require_char_class_esc() self.assertTrue(p.the_char is None) t1, t2 = tests[b] for c in t1: self.assertTrue(cclass.test(c), "%s not in %s" % (repr(c), b)) for c in t2: self.assertFalse(cclass.test(c), "%s in %s" % (repr(c), b))
def test_constructor(self): e = app.Categories(None) self.assertTrue(e.ns == app.APP_NAMESPACE, 'ns on construction') self.assertTrue(e.xmlname == "categories", 'element name on construction') self.assertTrue(e.get_base() is None, "xml:base present on construction") self.assertTrue(e.get_lang() is None, "xml:lang present on construction") self.assertTrue(e.get_space() is None, "xml:space present on construction") attrs = e.get_attributes() self.assertTrue( sum(1 for k in dict_keys(attrs)) == 0, "Attributes present on construction") self.assertTrue(e.href is None, "href present on construction") self.assertTrue(e.fixed is None, "fixed on construction") self.assertTrue(e.scheme is None, "scheme present on construction") self.assertTrue( len(e.Category) == 0, "Category list non empty on construction")
def test_char_group(self): """:: charGroup ::= posCharGroup | negCharGroup | charClassSub """ tests = { 'a-c': ("abc", "ABC-"), '^a-c': ("ABC-", "abc"), '^a-z-[^A-Z]': ("ABZ", "`abz{@[-"), } for b in dict_keys(tests): p = xsi.RegularExpressionParser(b) try: cclass = p.require_char_group() except xsi.RegularExpressionError: logging.debug("Failed to parse %s" % repr(b)) raise self.assertTrue(p.the_char is None) t1, t2 = tests[b] for c in t1: self.assertTrue(cclass.test(c), "%s not in %s" % (repr(c), b)) for c in t2: self.assertFalse(cclass.test(c), "%s in %s" % (repr(c), b))