from __future__ import print_function from __future__ import unicode_literals from __future__ import division from builtins import str, bytes, dict, int from builtins import map, zip, filter from builtins import object, range import os import sys sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..")) import unittest import time import re import random from random import seed seed(0) from pattern import search from pattern.en import Sentence, parse #--------------------------------------------------------------------------------------------------- class TestUtilityFunctions(unittest.TestCase): def setUp(self): pass def test_match(self): # Assert search._match() wildcard matching. for s, p, b in ( ("rabbit" , "rabbit", True), ("rabbits", "rabbit*", True), ("rabbits", "*abbits", True), ("rabbits", "*abbit*", True), ("rabbits", "rab*its", True), ("rabbits", re.compile(r"ra.*?"), True)): self.assertEqual(search._match(s, p), b) print("pattern.search._match()") def test_unique(self): self.assertEqual(search.unique([1, 1, 2, 2]), [1, 2]) def test_find(self): self.assertEqual(search.find(lambda v: v > 2, [1, 2, 3, 4, 5]), 3) def test_product(self): # Assert combinations of list items. self.assertEqual(list(search.product([], repeat=2)), []) # No possibilities. self.assertEqual(list(search.product([1], repeat=0)), [()]) # One possibility: the empty set. self.assertEqual(list(search.product([1, 2, 3], repeat=2)), [(1, 1), (1, 2), (1, 3), (2, 1), (2, 2), (2, 3), (3, 1), (3, 2), (3, 3)]) for n, m in ((1, 9), (2, 81), (3, 729), (4, 6561)): v = search.product([1, 2, 3, 4, 5, 6, 7, 8, 9], repeat=n) self.assertEqual(len(list(v)), m) print("pattern.search.product()") def test_variations(self): # Assert variations include the original input (the empty list has one variation = itself). v = search.variations([]) self.assertEqual(v, [()]) # Assert variations = (1,) and (). v = search.variations([1], optional=lambda item: item == 1) self.assertEqual(v, [(1,), ()]) # Assert variations = the original input, (2,), (1,) and (). v = search.variations([1, 2], optional=lambda item: item in (1, 2)) self.assertEqual(v, [(1, 2), (2,), (1,), ()]) # Assert variations are sorted longest-first. v = search.variations([1, 2, 3, 4], optional=lambda item: item in (1, 2)) self.assertEqual(v, [(1, 2, 3, 4), (2, 3, 4), (1, 3, 4), (3, 4)]) self.assertTrue(len(v[0]) >= len(v[1]) >= len(v[2]), len(v[3])) print("pattern.search.variations()") def test_odict(self): # Assert odict.append() which must be order-preserving. v = search.odict() v.push(("a", 1)) v.push(("b", 2)) v.push(("c", 3)) v.push(("a", 0)) v = v.copy() self.assertTrue(isinstance(v, dict)) self.assertEqual(v.keys(), ["a", "c", "b"]) print("pattern.search.odict()") #--------------------------------------------------------------------------------------------------- class TestTaxonomy(unittest.TestCase): def setUp(self): pass def test_taxonomy(self): # Assert Taxonomy search. t = search.Taxonomy() t.append("King Arthur", type="knight", value=1) t.append("Sir Bedevere", type="knight", value=2) t.append("Sir Lancelot", type="knight", value=3) t.append("Sir Gallahad", type="knight", value=4) t.append("Sir Robin", type="knight", value=5) t.append("John Cleese", type="Sir Lancelot") t.append("John Cleese", type="Basil Fawlty") # Matching is case-insensitive, results are lowercase. self.assertTrue("John Cleese" in t) self.assertTrue("john cleese" in t) self.assertEqual(t.classify("King Arthur"), "knight") self.assertEqual(t.value("King Arthur"), 1) self.assertEqual(t.parents("John Cleese"), ["basil fawlty", "sir lancelot"]) self.assertEqual(t.parents("John Cleese", recursive=True), [ "basil fawlty", "sir lancelot", "knight"]) self.assertEqual(t.children("knight"), [ "sir robin", "sir gallahad", "sir lancelot", "sir bedevere", "king arthur"]) self.assertEqual(t.children("knight", recursive=True), [ "sir robin", "sir gallahad", "sir lancelot", "sir bedevere", "king arthur", "john cleese"]) print("pattern.search.Taxonomy") def test_classifier(self): # Assert taxonomy classifier + keyword arguments. c1 = search.Classifier(parents=lambda word, chunk=None: word.endswith("ness") and ["quality"] or []) c2 = search.Classifier(parents=lambda word, chunk=None: chunk == "VP" and ["action"] or []) t = search.Taxonomy() t.classifiers.append(c1) t.classifiers.append(c2) self.assertEqual(t.classify("fuzziness"), "quality") self.assertEqual(t.classify("run", chunk="VP"), "action") print("pattern.search.Classifier") def test_wordnet_classifier(self): # Assert WordNet classifier parents & children. c = search.WordNetClassifier() t = search.Taxonomy() t.classifiers.append(c) self.assertEqual(t.classify("cat"), "feline") self.assertEqual(t.classify("dog"), "canine") self.assertTrue("domestic_cat" in t.children("cat")) self.assertTrue("puppy" in t.children("dog")) print("pattern.search.WordNetClassifier") #--------------------------------------------------------------------------------------------------- class TestConstraint(unittest.TestCase): def setUp(self): pass def _test_constraint(self, constraint, **kwargs): # Assert Constraint property values with given optional parameters. self.assertEqual(constraint.words, kwargs.get("words", [])) self.assertEqual(constraint.tags, kwargs.get("tags", [])) self.assertEqual(constraint.chunks, kwargs.get("chunks", [])) self.assertEqual(constraint.roles, kwargs.get("roles", [])) self.assertEqual(constraint.taxa, kwargs.get("taxa", [])) self.assertEqual(constraint.optional, kwargs.get("optional", False)) self.assertEqual(constraint.multiple, kwargs.get("multiple", False)) self.assertEqual(constraint.first, kwargs.get("first", False)) self.assertEqual(constraint.exclude, kwargs.get("exclude", None)) self.assertEqual(constraint.taxonomy, kwargs.get("taxonomy", search.taxonomy)) def test_fromstring(self): # Assert Constraint string syntax. for s, kwargs in ( ( "cats", dict( words = ["cats"])), ( "Cat*", dict( words = ["cat*"])), ( "\\[cat\\]", dict( words = ["[cat]"])), ("[black cats]", dict( words = ["black cats"])), ( "black_cats", dict( words = ["black cats"])), ("black\\_cats", dict( words = ["black_cats"])), ( "NNS", dict( tags = ["NNS"])), ( "NN*|VB*", dict( tags = ["NN*", "VB*"])), ( "NP", dict(chunks = ["NP"])), ( "SBJ", dict( roles = ["SBJ"])), ( "CATS", dict( taxa = ["cats"])), ( "cats?", dict( words = ["cats"], optional=True)), ( "(cats)", dict( words = ["cats"], optional=True)), ( "\\(cats\\)", dict( words = ["(cats)"])), ( "cats+", dict( words = ["cats"], multiple=True)), ( "cats\\+", dict( words = ["cats+"])), ( "cats+dogs", dict( words = ["cats+dogs"])), ( "(cats+)", dict( words = ["cats"], optional=True, multiple=True)), ( "(cats)+", dict( words = ["cats"], optional=True, multiple=True)), ( "cats+?", dict( words = ["cats"], optional=True, multiple=True)), ( "cats?+", dict( words = ["cats"], optional=True, multiple=True)), ( "^[fat cat]?", dict( words = ["fat cat"], first=True, optional=True)), ( "[^fat cat?]", dict( words = ["fat cat"], first=True, optional=True)), ( "cats\\|dogs", dict( words = ["cats|dogs"])), ( "cats|dogs", dict( words = ["cats", "dogs"])), ( "^cat", dict( words = ["cat"], first=True)), ( "\\^cat", dict( words = ["^cat"])), ( "(cat*)+", dict( words = ["cat*"], optional=True, multiple=True)), ( "^black_cat+", dict( words = ["black cat"], multiple=True, first=True)), ( "black\[cat", dict( words = ["black[cat"])), ( "black\(cat", dict( words = ["black(cat"])), ( "black\{cat", dict( words = ["black{cat"])), ( "black\|cat", dict( words = ["black|cat"])), ( "black\!cat", dict( words = ["black!cat"])), ( "black\^cat", dict( words = ["black^cat"])), ( "black\+cat", dict( words = ["black+cat"])), ( "black\?cat", dict( words = ["black?cat"])), ( "cats|NN*", dict( words = ["cats"], tags=["NN*"]))): self._test_constraint(search.Constraint.fromstring(s), **kwargs) # Assert non-alpha taxonomy items. t = search.Taxonomy() t.append("0.5", type="0.5") t.append("half", type="0.5") v = search.Constraint.fromstring("0.5", taxonomy=t) # Assert non-alpha words without taxonomy. self.assertTrue(v.taxa == ["0.5"]) v = search.Constraint.fromstring("0.5") # Assert exclude Constraint. self.assertTrue(v.words == ["0.5"]) v = search.Constraint.fromstring("\\!cats|!dogs|!fish") self.assertTrue(v.words == ["!cats"]) self.assertTrue(v.exclude.words == ["dogs", "fish"]) print("pattern.search.Constraint.fromstring") print("pattern.search.Constraint.fromstring") def test_match(self): # Assert Constraint-Word matching. R = search.Constraint.fromstring S = lambda s: Sentence(parse(s, relations=True, lemmata=True)) W = lambda s, tag=None, index=0: search.Word(None, s, tag, index) for constraint, tests in ( (R("cat|dog"), [(W("cat"), 1), (W("dog"), 1), (W("fish"), 0)]), (R("cat*"), [(W("cats"), 1)]), (R("*cat"), [(W("tomcat"), 1)]), (R("c*t|d*g"), [(W("cat"), 1), (W("cut"), 1), (W("dog"), 1), (W("dig"), 1)]), (R("cats|NN*"), [(W("cats", "NNS"), 1), (W("cats"), 0)]), (R("^cat"), [(W("cat", "NN", index=0), 1), (W("cat", "NN", index=1), 0)]), (R("*|!cat"), [(W("cat"), 0), (W("dog"), 1), (W("fish"), 1)]), (R("my cat"), [(W("cat"), 0)]), (R("my cat"), [(S("my cat").words[1], 1)]), # "my cat" is an overspecification of "cat" (R("my_cat"), [(S("my cat").words[1], 1)]), (R("cat|NP"), [(S("my cat").words[1], 1)]), (R("dog|VP"), [(S("my dog").words[1], 0)]), (R("cat|SBJ"), [(S("the cat is sleeping").words[1], 1)]), (R("dog"), [(S("MY DOGS").words[1], 1)]), # lemma matches (R("dog"), [(S("MY DOG").words[1], 1)])): # case-insensitive for test, b in tests: self.assertEqual(constraint.match(test), bool(b)) # Assert Constraint-Taxa matching. t = search.Taxonomy() t.append("Tweety", type="bird") t.append("Steven", type="bird") v = search.Constraint.fromstring("BIRD", taxonomy=t) self.assertTrue(v.match(W("bird"))) self.assertTrue(v.match(S("tweeties")[0])) self.assertTrue(v.match(W("Steven"))) print("pattern.search.Constraint.match()") def test_string(self): # Assert Constraint.string. v = search.Constraint() v.words = ["Steven\\*"] v.tags = ["NN*"] v.roles = ["SBJ"] v.taxa = ["(associate) professor"] v.exclude = search.Constraint(["bird"]) v.multiple = True v.first = True self.assertEqual(v.string, "^[Steven\\*|NN*|SBJ|\(ASSOCIATE\)_PROFESSOR|!bird]+") print("pattern.search.Constraint.string") #--------------------------------------------------------------------------------------------------- class TestPattern(unittest.TestCase): def setUp(self): pass def test_pattern(self): # Assert Pattern properties. v = search.Pattern([ search.Constraint("a|an|the"), search.Constraint("JJ*"), search.Constraint("cat")], search.STRICT) self.assertEqual(len(v), 3) self.assertEqual(v.strict, True) print("pattern.search.Pattern") def test_fromstring(self): # Assert Pattern string syntax. v = search.Pattern.fromstring("a|an|the JJ*? cat*") self.assertEqual(v[0].words, ["a", "an", "the"]) self.assertEqual(v[1].tags, ["JJ*"]) self.assertEqual(v[1].optional, True) self.assertEqual(v[2].words, ["cat*"]) # Assert escaped control characters. v = search.Pattern.fromstring("[\\[Figure 1\\]] VP") self.assertEqual(v[0].words, ["[figure 1]"]) self.assertEqual(v[1].chunks, ["VP"]) # Assert messy syntax (fix brackets and whitespace, don't fix empty options). v = search.Pattern.fromstring("[avoid][|!|messy |syntax |]") self.assertEqual(v[0].words, ["avoid"]) self.assertEqual(v[1].words, ["", "messy", "syntax", ""]) self.assertEqual(v[1].exclude.words, [""]) # "!" = exclude everything print("pattern.search.Pattern.fromstring()") def test_match(self): # Assert Pattern.match() P = search.Pattern.fromstring X = search.STRICT S = lambda s: Sentence(parse(s, relations=True, lemmata=True)) for i, (pattern, test, match) in enumerate(( (P("^rabbit"), "white rabbit", None), # 0 (P("^rabbit"), "rabbit", "rabbit"), # 1 (P("rabbit"), "big white rabbit", "rabbit"), # 2 (P("rabbit*"), "big white rabbits", "rabbits"), # 3 (P("JJ|NN"), S("big white rabbits"), "big"), # 4 (P("JJ+"), S("big white rabbits"), "big white"), # 5 (P("JJ+ NN*"), S("big white rabbits"), "big white rabbits"), # 6 (P("JJ black|white NN*"), S("big white rabbits"), "big white rabbits"), # 7 (P("NP"), S("big white rabbit"), "big white rabbit"), # 8 (P("big? rabbit", X), S("big white rabbit"), "rabbit"), # 9 strict (P("big? rabbit|NN"), S("big white rabbit"), "rabbit"), # 10 explicit (P("big? rabbit"), S("big white rabbit"), "big white rabbit"), # 11 greedy (P("rabbit VP JJ"), S("the rabbit was huge"), "the rabbit was huge"), # 12 (P("rabbit be JJ"), S("the rabbit was huge"), "the rabbit was huge"), # 13 lemma (P("rabbit be JJ", X), S("the rabbit was huge"), "rabbit was huge"), # 14 (P("rabbit is JJ"), S("the rabbit was huge"), None), # 15 (P("the NP"), S("the rabid rodents"), "the rabid rodents"), # 16 overlap (P("t*|r*+"), S("the rabid rodents"), "the rabid rodents"), # 17 (P("(DT) JJ? NN*"), S("the rabid rodents"), "the rabid rodents"), # 18 (P("(DT) JJ? NN*"), S("the rabbit"), "the rabbit"), # 19 (P("rabbit"), S("the big rabbit"), "the big rabbit"), # 20 greedy (P("eat carrot"), S("is eating a carrot"), "is eating a carrot"), # 21 (P("eat carrot|NP"), S("is eating a carrot"), "is eating a carrot"), # 22 (P("eat NP"), S("is eating a carrot"), "is eating a carrot"), # 23 (P("eat a"), S("is eating a carrot"), "is eating a"), # 24 (P("!NP carrot"), S("is eating a carrot"), "is eating a carrot"), # 25 (P("eat !pizza"), S("is eating a carrot"), "is eating a carrot"), # 26 (P("eating a"), S("is eating a carrot"), "is eating a"), # 27 (P("eating !carrot", X), S("is eating a carrot"), "eating a"), # 28 (P("eat !carrot"), S("is eating a carrot"), None), # 28 NP chunk is a carrot (P("eat !DT"), S("is eating a carrot"), None), # 30 eat followed by DT (P("eat !NN"), S("is eating a carrot"), "is eating a"), # 31 a/DT is not NN (P("!be carrot"), S("is eating a carrot"), "is eating a carrot"), # 32 is eating == eat != is (P("!eat|VP carrot"), S("is eating a carrot"), None), # 33 VP chunk == eat (P("white_rabbit"), S("big white rabbit"), None), # 34 (P("[white rabbit]"), S("big white rabbit"), None), # 35 (P("[* white rabbit]"), S("big white rabbit"), "big white rabbit"), # 36 (P("[big * rabbit]"), S("big white rabbit"), "big white rabbit"), # 37 (P("big [big * rabbit]"), S("big white rabbit"), "big white rabbit"), # 38 (P("[*+ rabbit]"), S("big white rabbit"), None), # 39 bad pattern: "+" is literal )): m = pattern.match(test) self.assertTrue(getattr(m, "string", None) == match) # Assert chunk with head at the front. s = S("Felix the cat") self.assertEqual(P("felix").match(s).string, "Felix the cat") # Assert negation + custom greedy() function. s = S("the big white rabbit") g = lambda chunk, constraint: len([w for w in chunk if not constraint.match(w)]) == 0 self.assertEqual(P("!white").match(s).string, "the big white rabbit") # a rabbit != white self.assertEqual(P("!white", greedy=g).match(s), None) # a white rabbit == white # Assert taxonomy items with spaces. s = S("Bugs Bunny is a giant talking rabbit.") t = search.Taxonomy() t.append("rabbit", type="rodent") t.append("Bugs Bunny", type="rabbit") self.assertEqual(P("RABBIT", taxonomy=t).match(s).string, "Bugs Bunny") # Assert None, the syntax cannot handle taxonomy items that span multiple chunks. s = S("Elmer Fudd fires a cannon") t = search.Taxonomy() t.append("fire cannon", type="violence") self.assertEqual(P("VIOLENCE").match(s), None) # Assert regular expressions. s = S("a sack with 3.5 rabbits") p = search.Pattern.fromstring("[] NNS") p[0].words.append(re.compile(r"[0-9|\.]+")) self.assertEqual(p.match(s).string, "3.5 rabbits") print("pattern.search.Pattern.match()") def test_search(self): # Assert one match containing all words. v = search.Pattern.fromstring("*+") v = v.search("one two three") self.assertEqual(v[0].string, "one two three") # Assert one match for each word. v = search.Pattern.fromstring("*") v = v.search("one two three") self.assertEqual(v[0].string, "one") self.assertEqual(v[1].string, "two") self.assertEqual(v[2].string, "three") # Assert all variations are matched (sentence starts with a NN* which must be caught). v = search.Pattern.fromstring("(DT) JJ?+ NN*") v = v.search(Sentence(parse("dogs, black cats and a big white rabbit"))) self.assertEqual(v[0].string, "dogs") self.assertEqual(v[1].string, "black cats") self.assertEqual(v[2].string, "a big white rabbit") v = search.Pattern.fromstring("NN*") print("pattern.search.Pattern.search()") def test_convergence(self): # Test with random sentences and random patterns to see if it crashes. w = ("big", "white", "rabbit", "black", "cats", "is", "was", "going", "to", "sleep", "sleepy", "very", "or") x = ("DT?", "JJ?+", "NN*", "VP?", "cat", "[*]") for i in range(100): s = " ".join(random.choice(w) for i in range(20)) s = Sentence(parse(s, lemmata=True)) p = " ".join(random.choice(x) for i in range(5)) p = search.Pattern.fromstring(p) p.search(s) def test_compile_function(self): # Assert creating and caching Pattern with compile(). t = search.Taxonomy() p = search.compile("JJ?+ NN*", search.STRICT, taxonomy=t) self.assertEqual(p.strict, True) self.assertEqual(p[0].optional, True) self.assertEqual(p[0].tags, ["JJ"]) self.assertEqual(p[1].tags, ["NN*"]) self.assertEqual(p[1].taxonomy, t) # Assert regular expression input. p = search.compile(re.compile(r"[0-9|\.]+")) self.assertTrue(isinstance(p[0].words[0], search.regexp)) # Assert TypeError for other input. self.assertRaises(TypeError, search.compile, 1) print("pattern.search.compile()") def test_match_function(self): # Assert match() function. s = Sentence(parse("Go on Bors, chop his head off!")) m1 = search.match("chop NP off", s, strict=False) m2 = search.match("chop NP+ off", s, strict=True) self.assertEqual(m1.constituents()[1].string, "his head") self.assertEqual(m2.constituents()[1].string, "his head") print("pattern.search.match()") def test_search_function(self): # Assert search() function. s = Sentence(parse("Go on Bors, chop his head off!")) m = search.search("PRP*? NN*", s) self.assertEqual(m[0].string, "Bors") self.assertEqual(m[1].string, "his head") print("pattern.search.search()") def test_escape(self): # Assert escape() function. self.assertEqual(search.escape("{}[]()_|!*+^."), "\\{\\}\\[\\]\\(\\)\\_\\|\\!\\*\\+\\^.") print("pattern.search.escape()") #--------------------------------------------------------------------------------------------------- class TestMatch(unittest.TestCase): def setUp(self): pass def test_match(self): # Assert Match properties. s = Sentence(parse("Death awaits you all with nasty, big, pointy teeth.")) p = search.Pattern(sequence=[ search.Constraint(tags=["JJ"], optional=True), search.Constraint(tags=["NN*"])]) m = p.search(s) self.assertTrue(isinstance(m, list)) self.assertEqual(m[0].pattern, p) self.assertEqual(m[1].pattern, p) self.assertEqual(m[0].words, [s.words[0]]) self.assertEqual(m[1].words, [s.words[-3], s.words[-2]]) # Assert contraint "NN*" links to "Death" and "teeth", and "JJ" to "pointy". self.assertEqual(m[0].constraint(s.words[0]), p[1]) self.assertEqual(m[1].constraint(s.words[-3]), p[0]) self.assertEqual(m[1].constraint(s.words[-2]), p[1]) # Assert constraints "JJ NN*" links to chunk "pointy teeth". self.assertEqual(m[1].constraints(s.chunks[-1]), [p[0], p[1]]) # Assert Match.constituents() by constraint, constraint index and list of indices. self.assertEqual(m[1].constituents(), [s.words[-3], s.words[-2]]) self.assertEqual(m[1].constituents(constraint=p[0]), [s.words[-3]]) self.assertEqual(m[1].constituents(constraint=1), [s.words[-2]]) self.assertEqual(m[1].constituents(constraint=(0, 1)), [s.words[-3], s.words[-2]]) # Assert Match.string. self.assertEqual(m[1].string, "pointy teeth") print("pattern.search.Match") def test_group(self): # Assert Match groups. s = Sentence(parse("the big black cat eats a tasty fish")) m = search.search("DT {JJ+} NN", s) self.assertEqual(m[0].group(1).string, "big black") self.assertEqual(m[1].group(1).string, "tasty") # Assert nested groups (and syntax with additional spaces). m = search.search("DT { JJ { JJ { NN }}}", s) self.assertEqual(m[0].group(1).string, "big black cat") self.assertEqual(m[0].group(2).string, "black cat") self.assertEqual(m[0].group(3).string, "cat") # Assert chunked groups. m = search.search("NP {VP NP}", s) v = m[0].group(1, chunked=True) self.assertEqual(v[0].string, "eats") self.assertEqual(v[1].string, "a tasty fish") print("pattern.search.Match.group()") def test_group_ordering(self): # Assert group parser ordering (opened-first). c1 = search.Constraint("1") c2 = search.Constraint("2") c3 = search.Constraint("3") c4 = search.Constraint("4") p = search.Pattern([c1, [c2, [[c3], c4]]]) self.assertEqual(p.groups[0][0].words[0], "2") self.assertEqual(p.groups[0][1].words[0], "3") self.assertEqual(p.groups[0][2].words[0], "4") self.assertEqual(p.groups[1][0].words[0], "3") self.assertEqual(p.groups[1][1].words[0], "4") self.assertEqual(p.groups[2][0].words[0], "3") p = search.Pattern.fromstring("1 {2 {{3} 4}}") self.assertEqual(p.groups[0][0].words[0], "2") self.assertEqual(p.groups[0][1].words[0], "3") self.assertEqual(p.groups[0][2].words[0], "4") self.assertEqual(p.groups[1][0].words[0], "3") self.assertEqual(p.groups[1][1].words[0], "4") self.assertEqual(p.groups[2][0].words[0], "3") p = search.Pattern.fromstring("1 {2} {3} 4") self.assertEqual(p.groups[0][0].words[0], "2") self.assertEqual(p.groups[1][0].words[0], "3") #--------------------------------------------------------------------------------------------------- def suite(): suite = unittest.TestSuite() suite.addTest(unittest.TestLoader().loadTestsFromTestCase(TestUtilityFunctions)) suite.addTest(unittest.TestLoader().loadTestsFromTestCase(TestTaxonomy)) suite.addTest(unittest.TestLoader().loadTestsFromTestCase(TestConstraint)) suite.addTest(unittest.TestLoader().loadTestsFromTestCase(TestPattern)) suite.addTest(unittest.TestLoader().loadTestsFromTestCase(TestMatch)) return suite if __name__ == "__main__": result = unittest.TextTestRunner(verbosity=1).run(suite()) sys.exit(not result.wasSuccessful())