def test_is_empty(self): """is_empty()""" # Check return True for len(self.kchar) == 0, otherwise return False. abc = b_Sym_kchar("abc", ('a', 'b', 'c'), 0) self.assertTrue(abc.is_empty() == False) empty = b_Sym_kchar("empty", (), 1) self.assertTrue(empty.is_empty() == True)
def test_is_empty(self): """is_empty()""" # Check return True for len(self.kchar) == 0, otherwise return False. abc = b_Sym_kchar("abc", ('a', 'b', 'c'), 0) self.assertTrue(abc.is_empty() == False) empty = b_Sym_kchar("empty", (), 1) self.assertTrue(empty.is_empty() == True)
def test_compute_double_stride(self): """compute_double_stride()""" # compute_double_stride(compSymbol, reverse, last, local_chars): # Test with compSymbol of type sym_kchar. # If is reverse True, check in result kchar reverse sort self and comp. # Check in result kchar that last value is same as called. # Chech that local_chars[i] for i in len(local_chars) have value # local_chars[i] = local_chars[i] - compSymbol.kchar[i] ab = b_Sym_kchar("ab", ('a', 'b'), 0) ef = b_Sym_kchar("ef", ('e', 'f'), 1) local_chars = list() chars = set() for i in range(0, 256): chars.add(chr(i)) local_chars.append(chars.copy()) new_kchar = ab.compute_double_stride(ef, False, 2, local_chars)[0] new_local_chars = \ ab.compute_double_stride(ef, False, 2, local_chars)[1] reference_kchar = b_Sym_kchar("abef", ('a', 'b', 'e', 'f'), 2) reference_kchar_2 = \ b_Sym_kchar("abef", ('a', 'b', 'e', 'f'), 2) reference_kchar.last = 2 reference_kchar_2.last = 2 reference_local_chars = local_chars[0] - set([ef.kchar]) self.assertTrue(new_kchar == reference_kchar or new_kchar == reference_kchar_2) self.assertTrue(new_local_chars[0] == reference_local_chars) self.assertTrue(new_kchar.last == 2) # reverse = True ab = b_Sym_kchar("ab", ('a', 'b'), 0) ef = b_Sym_kchar("ef", ('e', 'f'), 1) local_chars = list() chars = set() for i in range(0, 256): chars.add(chr(i)) local_chars.append(chars.copy()) new_kchar = ab.compute_double_stride(ef, True, 2, local_chars)[0] new_local_chars = \ ab.compute_double_stride(ef, True, 2, local_chars)[1] reference_kchar = b_Sym_kchar("efab", ('e', 'f', 'a', 'b'), 2) reference_kchar_2 = \ b_Sym_kchar("efab", ('e', 'f', 'a', 'b'), 2) reference_kchar.last = 2 reference_kchar_2.last = 2 reference_local_chars = local_chars[0] - set([ab.kchar]) self.assertTrue(new_kchar == reference_kchar or new_kchar == reference_kchar_2) self.assertTrue(new_local_chars[0] == reference_local_chars) self.assertTrue(new_kchar.last == 2)
def test_compute_double_stride(self): """compute_double_stride()""" # compute_double_stride(compSymbol, reverse, last, local_chars): # Test with compSymbol of type sym_kchar. # If is reverse True, check in result kchar reverse sort self and comp. # Check in result kchar that last value is same as called. # Chech that local_chars[i] for i in len(local_chars) have value # local_chars[i] = local_chars[i] - compSymbol.kchar[i] ab = b_Sym_kchar("ab", ('a', 'b'), 0) ef = b_Sym_kchar("ef", ('e', 'f'), 1) local_chars = list() chars = set() for i in range(0, 256): chars.add(chr(i)) local_chars.append(chars.copy()) new_kchar = ab.compute_double_stride(ef, False, 2, local_chars)[0] new_local_chars = \ ab.compute_double_stride(ef, False, 2, local_chars)[1] reference_kchar = b_Sym_kchar("abef", ('a', 'b', 'e', 'f'), 2) reference_kchar_2 = \ b_Sym_kchar("abef", ('a', 'b', 'e', 'f'), 2) reference_kchar.last = 2 reference_kchar_2.last = 2 reference_local_chars = local_chars[0] - set([ef.kchar]) self.assertTrue(new_kchar == reference_kchar or new_kchar == reference_kchar_2) self.assertTrue(new_local_chars[0] == reference_local_chars) self.assertTrue(new_kchar.last == 2) # reverse = True ab = b_Sym_kchar("ab", ('a', 'b'), 0) ef = b_Sym_kchar("ef", ('e', 'f'), 1) local_chars = list() chars = set() for i in range(0, 256): chars.add(chr(i)) local_chars.append(chars.copy()) new_kchar = ab.compute_double_stride(ef, True, 2, local_chars)[0] new_local_chars = \ ab.compute_double_stride(ef, True, 2, local_chars)[1] reference_kchar = b_Sym_kchar("efab", ('e', 'f', 'a', 'b'), 2) reference_kchar_2 = \ b_Sym_kchar("efab", ('e', 'f', 'a', 'b'), 2) reference_kchar.last = 2 reference_kchar_2.last = 2 reference_local_chars = local_chars[0] - set([ab.kchar]) self.assertTrue(new_kchar == reference_kchar or new_kchar == reference_kchar_2) self.assertTrue(new_local_chars[0] == reference_local_chars) self.assertTrue(new_kchar.last == 2)
def test_get_support_type(self): """get_support_type()""" # Check return [b_symbol.io_mapper["b_Sym_char"], # b_symbol.io_mapper["b_Sym_char_class"], # b_symbol.io_mapper["b_Sym_string"], # b_symbol.io_mapper["b_Sym_kchar"]] abc = b_Sym_kchar("abc", ('a', 'b', 'c'), 0) self.assertTrue(abc.get_support_type() == [io_mapper["b_Sym_char"], io_mapper["b_Sym_char_class"], io_mapper["b_Sym_string"], io_mapper["b_Sym_kchar"]])
def test_get_support_type(self): """get_support_type()""" # Check return [b_symbol.io_mapper["b_Sym_char"], # b_symbol.io_mapper["b_Sym_char_class"], # b_symbol.io_mapper["b_Sym_string"], # b_symbol.io_mapper["b_Sym_kchar"]] abc = b_Sym_kchar("abc", ('a', 'b', 'c'), 0) self.assertTrue(abc.get_support_type() == [ io_mapper["b_Sym_char"], io_mapper["b_Sym_char_class"], io_mapper["b_Sym_string"], io_mapper["b_Sym_kchar"] ])
def test_collision(self): """collision()""" # method collision(set_of_symbols): # Try with suitable objects of class sym_kchar and check correct # result - is / is not collision. abc = b_Sym_kchar("abc", ('a', 'b', 'c'), 0) ac = b_Sym_char_class("ac", set(['a', 'c']), 1) b = b_Sym_char("b", 'b', 2) efg = b_Sym_kchar("efg", ('e', 'f', 'g'), 3) set_of_symbols = set([efg, ac, b]) self.assertTrue(abc.collision(set_of_symbols) == False) a = b_Sym_char("a", 'a', 4) set_of_symbols.add(a) self.assertTrue(abc.collision(set_of_symbols) == False) cba = b_Sym_kchar("cba", ('c', 'b', 'a'), 5) set_of_symbols.add(cba) self.assertTrue(abc.collision(set_of_symbols) == False) abc_2 = b_Sym_kchar("abc", ('a', 'b', 'c'), 6) set_of_symbols.add(abc_2) self.assertTrue(abc.collision(set_of_symbols) == True)
def test_collision(self): """collision()""" # method collision(set_of_symbols): # Try with suitable objects of class sym_kchar and check correct # result - is / is not collision. abc = b_Sym_kchar("abc", ('a', 'b', 'c'), 0) ac = b_Sym_char_class("ac", set(['a', 'c']), 1) b = b_Sym_char("b", 'b', 2) efg = b_Sym_kchar("efg", ('e', 'f', 'g'), 3) set_of_symbols = set([efg, ac, b]) self.assertTrue(abc.collision(set_of_symbols) == False) a = b_Sym_char("a", 'a', 4) set_of_symbols.add(a) self.assertTrue(abc.collision(set_of_symbols) == False) cba = b_Sym_kchar("cba", ('c', 'b', 'a'), 5) set_of_symbols.add(cba) self.assertTrue(abc.collision(set_of_symbols) == False) abc_2 = b_Sym_kchar("abc", ('a', 'b', 'c'), 6) set_of_symbols.add(abc_2) self.assertTrue(abc.collision(set_of_symbols) == True)
def test_accept(self): """accept()""" # method accept(text): # Check if len(text) < len(self.kchar) then is thrown exception # symbol_string_to_short. abc = b_Sym_kchar("abc", ('a', 'b', 'c'), 0) try: abc.accept("ab") self.assertTrue(False) except symbol_string_to_short: self.assertTrue(True) # If begin of text is same as any combination of kchar then return # text[len(self.kchar):] abc = b_Sym_kchar("abc", ('a', 'b', 'c'), 0) self.assertTrue(abc.accept("abcdef") == "def") # In case there is no combination then thrown exception # symbol_accept_exception. try: abc.accept("wrong_text") self.assertTrue(False) except symbol_accept_exception: self.assertTrue(True)
def test_accept(self): """accept()""" # method accept(text): # Check if len(text) < len(self.kchar) then is thrown exception # symbol_string_to_short. abc = b_Sym_kchar("abc", ('a', 'b', 'c'), 0) try: abc.accept("ab") self.assertTrue(False) except symbol_string_to_short: self.assertTrue(True) # If begin of text is same as any combination of kchar then return # text[len(self.kchar):] abc = b_Sym_kchar("abc", ('a', 'b', 'c'), 0) self.assertTrue(abc.accept("abcdef") == "def") # In case there is no combination then thrown exception # symbol_accept_exception. try: abc.accept("wrong_text") self.assertTrue(False) except symbol_accept_exception: self.assertTrue(True)
def test_decode_symbol(self): """decode_symbol()""" # Test if different types of symbols are decoded correctly and # the symbol was removed from the beginning of input string. aut = PHF_DFA() aut._automaton.alphabet[0] = b_Sym_char_class("ch0", set(['a', 'b']), 0) aut._automaton.alphabet[1] = b_Sym_char_class("ch1", set(['c', 'd']), 1) aut._automaton.alphabet[2] = b_Sym_char_class("ch2", set(['e', 'f']), 2) aut._automaton.alphabet[3] = b_Sym_char("ch3", "g", 3) aut._automaton.alphabet[4] = b_Sym_kchar("ch4", (frozenset(['1', '2']), frozenset(['1', '2'])), 4) self.assertEqual(aut.decode_symbol("abeg112"), ("beg112", 0)) self.assertEqual(aut.decode_symbol("beg112"), ("eg112", 0)) self.assertEqual(aut.decode_symbol("eg112"), ("g112", 2)) self.assertEqual(aut.decode_symbol("g112"), ("112", 3)) self.assertEqual(aut.decode_symbol("112"), ("2", 4)) # Nonexistent symbol is removed from the string and -1 is returned self.assertEqual(aut.decode_symbol("2"), ("", -1))
def test_import_symbol(self): """import_symbol()""" # Check that is from test_repr created and returned correct object # having set self._id on tid and all parametrs are correct set. abc = b_Sym_kchar("abc", ('a', 'b', 'c'), 0) abc.import_symbol("40000|65|66|67", 1) self.assertTrue(abc.kchar == ('e', 'f', 'g')) self.assertTrue(abc._id == 1) self.assertTrue(abc._text == "{efg}") # Check if is text_repr of different type, then is thrown exception # symbol_import_exception. try: abc.import_symbol("0|65|66|67", 1) self.assertTrue(False) except symbol_import_exception: self.assertTrue(True)
def test_import_symbol(self): """import_symbol()""" # Check that is from test_repr created and returned correct object # having set self._id on tid and all parametrs are correct set. abc = b_Sym_kchar("abc", ('a', 'b', 'c'), 0) abc.import_symbol("40000|65|66|67", 1) self.assertTrue(abc.kchar == ('e', 'f', 'g')) self.assertTrue(abc._id == 1) self.assertTrue(abc._text == "{efg}") # Check if is text_repr of different type, then is thrown exception # symbol_import_exception. try: abc.import_symbol("0|65|66|67", 1) self.assertTrue(False) except symbol_import_exception: self.assertTrue(True)
def test_compute_equal(self): """compute_equal()""" # method compute_equal(other): # If is other type sym_kchar, then return True if are arguments # kchar same. abc = b_Sym_kchar("abc", ('a', 'b', 'c'), 0) efg = b_Sym_kchar("efg", ('e', 'f', 'g'), 1) self.assertTrue(abc.compute_equal(efg) == False) abc_2 = b_Sym_kchar( "abc", (frozenset(['a']), frozenset(['b']), frozenset(['c'])), 2) self.assertTrue(abc.compute_equal(abc_2) == True) # If is other type sym_string, then return True if is # len(other.string) == len(self.kchar), all subsymbols kchar have # length one (len(self.kchar[i]) == 1) and value string is straight # value kchar. kchar_abc = b_Sym_kchar("abc", ('a', 'b', 'c'), 0) string_abc = b_Sym_string("abc", "abc", 1) string_abcde = b_Sym_string("abcde", "abcde", 2) self.assertTrue(kchar_abc.compute_equal(string_abc) == True) self.assertTrue(kchar_abc.compute_equal(string_abcde) == False) # If is other type sym_char, then return True if is # len(self.kchar) == 1 and len(self.kchar[0]) == 1 and their # arguments are same. kchar_a = b_Sym_kchar("kchar_a", ('a'), 0) a = b_Sym_char("a", 'a', 1) self.assertTrue(kchar_a.compute_equal(a) == True) b = b_Sym_char("b", 'b', 2) self.assertTrue(kchar_a.compute_equal(b) == False) # If is other type sym_char_class, then return True if is # len(self.kchar) == 1 and len(other.charClass) == len(self.kchar[0]) # and values of arguments are same. kchar_abc = b_Sym_kchar("kchar_[abc]", (frozenset(['a', 'b', 'c']), ), 0) set_abc = b_Sym_char_class("[abc]", set(['a', 'b', 'c']), 1) self.assertTrue(kchar_abc.compute_equal(set_abc) == True) cd = b_Sym_char_class("set(['c', 'd'])", set(['c', 'd']), 2) self.assertTrue(kchar_abc.compute_equal(cd) == False)
def test_compute_equal(self): """compute_equal()""" # method compute_equal(other): # If is other type sym_kchar, then return True if are arguments # kchar same. abc = b_Sym_kchar("abc", ('a', 'b', 'c'), 0) efg = b_Sym_kchar("efg", ('e', 'f', 'g'), 1) self.assertTrue(abc.compute_equal(efg) == False) abc_2 = b_Sym_kchar("abc", (frozenset(['a']), frozenset(['b']), frozenset(['c'])), 2) self.assertTrue(abc.compute_equal(abc_2) == True) # If is other type sym_string, then return True if is # len(other.string) == len(self.kchar), all subsymbols kchar have # length one (len(self.kchar[i]) == 1) and value string is straight # value kchar. kchar_abc = b_Sym_kchar("abc", ('a', 'b', 'c'), 0) string_abc = b_Sym_string("abc", "abc", 1) string_abcde = b_Sym_string("abcde", "abcde", 2) self.assertTrue(kchar_abc.compute_equal(string_abc) == True) self.assertTrue(kchar_abc.compute_equal(string_abcde) == False) # If is other type sym_char, then return True if is # len(self.kchar) == 1 and len(self.kchar[0]) == 1 and their # arguments are same. kchar_a = b_Sym_kchar("kchar_a", ('a'), 0) a = b_Sym_char("a", 'a', 1) self.assertTrue(kchar_a.compute_equal(a) == True) b = b_Sym_char("b", 'b', 2) self.assertTrue(kchar_a.compute_equal(b) == False) # If is other type sym_char_class, then return True if is # len(self.kchar) == 1 and len(other.charClass) == len(self.kchar[0]) # and values of arguments are same. kchar_abc = b_Sym_kchar("kchar_[abc]", (frozenset(['a', 'b', 'c']),), 0) set_abc = b_Sym_char_class("[abc]", set(['a', 'b', 'c']), 1) self.assertTrue(kchar_abc.compute_equal(set_abc) == True) cd = b_Sym_char_class("set(['c', 'd'])", set(['c', 'd']), 2) self.assertTrue(kchar_abc.compute_equal(cd) == False)
def test___str__(self): """__str__()""" # Check output str(self.kchar). abc = b_Sym_kchar("abc", ('a', 'b', 'c'), 0) self.assertTrue(abc.__str__() == str(abc.kchar))
def test___hash__(self): """__hash__()""" # Check return hash(self.kchar). abc = b_Sym_kchar("abc", ('a', 'b', 'c'), 0) self.assertTrue(abc.__hash__() == hash(abc.kchar))
def test___repr__(self): """__repr__()""" # Check return repr(self.kchar). abc = b_Sym_kchar("abc", ('a', 'b', 'c'), 0) self.assertTrue(abc.__repr__() == repr(abc.kchar))
def test___hash__(self): """__hash__()""" # Check return hash(self.kchar). abc = b_Sym_kchar("abc", ('a', 'b', 'c'), 0) self.assertTrue(abc.__hash__() == hash(abc.kchar))
def test___str__(self): """__str__()""" # Check output str(self.kchar). abc = b_Sym_kchar("abc", ('a', 'b', 'c'), 0) self.assertTrue(abc.__str__() == str(abc.kchar))
def test___repr__(self): """__repr__()""" # Check return repr(self.kchar). abc = b_Sym_kchar("abc", ('a', 'b', 'c'), 0) self.assertTrue(abc.__repr__() == repr(abc.kchar))
def test_compute_double_stride(self): """compute_double_stride()""" # Method compute_double_stride(compSymbol, reverse, last, local_chars) # Test with compSymbol type sym_char and sym_char_class. # If the reverse is True then change order self and compSymbol. # compSymbol type sym_char ; reverse = False a = b_Sym_char('a', 'a', 0) b = b_Sym_char('b', 'b', 1) local_chars = list() chars = set() for i in range(0, 256): chars.add(chr(i)) local_chars.append(chars) new_kchar = a.compute_double_stride(b, False, 2, local_chars)[0] new_local_chars = a.compute_double_stride(b, False, 2, local_chars)[1] reference_kchar = b_Sym_kchar("ab", ('a', 'b'), 2) reference_kchar_2 = \ b_Sym_kchar("ab", (frozenset(['a']),frozenset(['b'])), 2) reference_kchar.last = 2 reference_kchar_2.last = 2 reference_local_chars = local_chars[0] - set([b.char]) self.assertTrue(new_kchar == reference_kchar or new_kchar == reference_kchar_2) self.assertTrue(new_local_chars[0] == reference_local_chars) self.assertTrue(new_kchar.last == 2) # compSymbol type sym_char_class ; reverse = False a = b_Sym_char('a', 'a', 0) bc = b_Sym_char_class("set(['b', 'c'])", set(['b', 'c']), 1) local_chars = list() chars = set() for i in range(0, 256): chars.add(chr(i)) local_chars.append(chars) new_kchar = a.compute_double_stride(bc, False, 3, local_chars)[0] new_local_chars = a.compute_double_stride(bc, False, 3, local_chars)[1] reference_kchar = b_Sym_kchar("a[bc]", ('a', set(['b', 'c'])), 2) reference_kchar_2 = \ b_Sym_kchar("a[bc]", (frozenset(['a']),frozenset(['b','c'])), 2) reference_kchar.last = 3 reference_kchar_2.last = 3 reference_local_chars = local_chars[0] - bc.charClass self.assertTrue(new_kchar == reference_kchar or new_kchar == reference_kchar_2) self.assertTrue(new_local_chars[0] == reference_local_chars) self.assertTrue(new_kchar.last == 3) # compSymbol type sym_char ; reverse = True a = b_Sym_char('a', 'a', 0) b = b_Sym_char('b', 'b', 1) local_chars = list() chars = set() for i in range(0, 256): chars.add(chr(i)) local_chars.append(chars) new_kchar = a.compute_double_stride(b, True, 2, local_chars)[0] new_local_chars = a.compute_double_stride(b, True, 2, local_chars)[1] reference_kchar = b_Sym_kchar("ba", ('b', 'a'), 2) reference_kchar_2 = \ b_Sym_kchar("ba", (frozenset(['b']),frozenset(['a'])), 2) reference_kchar.last = 2 reference_kchar_2.last = 2 reference_local_chars = local_chars[0] - set([a.char]) self.assertTrue(new_kchar == reference_kchar or new_kchar == reference_kchar_2) self.assertTrue(new_local_chars[0] == reference_local_chars) self.assertTrue(new_kchar.last == 2)
def test_export_symbol(self): """export_symbol()""" # Check correct output. abc = b_Sym_kchar("abc", ('a', 'b', 'c'), 0) self.assertTrue(abc.export_symbol() == "40000|61|62|63")
def test_compute_double_stride(self): """compute_double_stride()""" # Method compute_double_stride(compSymbol, reverse, last, local_chars) # Test with compSymbol type sym_char and sym_char_class. # If the reverse is True then change order self and compSymbol. # compSymbol type sym_char ; reverse = False a = b_Sym_char('a', 'a', 0) b = b_Sym_char('b', 'b', 1) local_chars = list() chars = set() for i in range(0,256): chars.add(chr(i)) local_chars.append(chars) new_kchar = a.compute_double_stride(b, False, 2, local_chars)[0] new_local_chars = a.compute_double_stride(b, False, 2, local_chars)[1] reference_kchar = b_Sym_kchar("ab", ('a','b'), 2) reference_kchar_2 = \ b_Sym_kchar("ab", (frozenset(['a']),frozenset(['b'])), 2) reference_kchar.last = 2 reference_kchar_2.last = 2 reference_local_chars = local_chars[0] - set([b.char]) self.assertTrue(new_kchar == reference_kchar or new_kchar == reference_kchar_2) self.assertTrue(new_local_chars[0] == reference_local_chars) self.assertTrue(new_kchar.last == 2) # compSymbol type sym_char_class ; reverse = False a = b_Sym_char('a', 'a', 0) bc = b_Sym_char_class("set(['b', 'c'])", set(['b', 'c']), 1) local_chars = list() chars = set() for i in range(0,256): chars.add(chr(i)) local_chars.append(chars) new_kchar = a.compute_double_stride(bc, False, 3, local_chars)[0] new_local_chars = a.compute_double_stride(bc, False, 3, local_chars)[1] reference_kchar = b_Sym_kchar("a[bc]", ('a',set(['b', 'c'])), 2) reference_kchar_2 = \ b_Sym_kchar("a[bc]", (frozenset(['a']),frozenset(['b','c'])), 2) reference_kchar.last = 3 reference_kchar_2.last = 3 reference_local_chars = local_chars[0] - bc.charClass self.assertTrue(new_kchar == reference_kchar or new_kchar == reference_kchar_2) self.assertTrue(new_local_chars[0] == reference_local_chars) self.assertTrue(new_kchar.last == 3) # compSymbol type sym_char ; reverse = True a = b_Sym_char('a', 'a', 0) b = b_Sym_char('b', 'b', 1) local_chars = list() chars = set() for i in range(0,256): chars.add(chr(i)) local_chars.append(chars) new_kchar = a.compute_double_stride(b, True, 2, local_chars)[0] new_local_chars = a.compute_double_stride(b, True, 2, local_chars)[1] reference_kchar = b_Sym_kchar("ba", ('b','a'), 2) reference_kchar_2 = \ b_Sym_kchar("ba", (frozenset(['b']),frozenset(['a'])), 2) reference_kchar.last = 2 reference_kchar_2.last = 2 reference_local_chars = local_chars[0] - set([a.char]) self.assertTrue(new_kchar == reference_kchar or new_kchar == reference_kchar_2) self.assertTrue(new_local_chars[0] == reference_local_chars) self.assertTrue(new_kchar.last == 2)
def test_export_symbol(self): """export_symbol()""" # Check correct output. abc = b_Sym_kchar("abc", ('a', 'b', 'c'), 0) self.assertTrue(abc.export_symbol() == "40000|61|62|63")