def test_get_all_parsers(root_parser: RootParser): """ Tests that the default parsers are there and that their number is correct """ parsers = root_parser.get_all_parsers(strict_type_matching=False) print('\n' + str(len(parsers)) + ' Root parser parsers:') pprint(parsers) assert len(parsers) == 127 parsers_str = to_str_coll(parsers) # dump(parsers_str, 'reference_parsers.json') assert parsers_str == load('reference_parsers.json')
def test_option_hints(root_parser: RootParser): """ Tests the option_hints method on the first parser available """ print('Testing option hints for parsing chain') p = root_parser.get_all_parsers(strict_type_matching=False) print(p[0].options_hints())
class AllTests(TestCase): def setUp(self): """ Creates the root parser to be used in most tests :return: """ self.root_parser = RootParser() def test_a_root_parser_capabilities(self): """ Tests that we can print the capabilities of the root parser: registered parsers and converters, supported extensions and types, etc. :return: """ p = self.root_parser.get_all_parsers(strict_type_matching=False) print('\n' + str(len(p)) + ' Root parser parsers:') pprint(p) print('Testing option hints for parsing chain') print(p[0].options_hints()) c = self.root_parser.get_all_conversion_chains() print('\n' + str(len(c[0]) + len(c[2])) + ' Root parser converters:') pprint(c) e = self.root_parser.get_all_supported_exts() print('\n' + str(len(e)) + ' Root parser supported extensions:') pprint(e) t = self.root_parser.get_all_supported_types_pretty_str() print('\n' + str(len(t)) + ' Root parser supported types:') pprint(t) print('\nRoot parser parsers by extensions:') self.root_parser.print_capabilities_by_ext(strict_type_matching=False) print('\nRoot parser parsers by types:') self.root_parser.print_capabilities_by_type(strict_type_matching=False) return def test_b_root_parser_any(self): """ Tests that we can ask the rootparser for its capabilities to parse a given type :return: """ # print self.root_parser.print_capabilities_for_type(typ=Any) # details res = self.root_parser.find_all_matching_parsers( strict=False, desired_type=AnyObject, required_ext='.cfg') match_generic, match_approx, match_exact = res[0] self.assertEquals(len(match_generic), 0) self.assertEquals(len(match_approx), 0) def test_objects_support(self): """ Tests all the supported ways to parse a simple object :return: """ # Then define the simple class representing your test case class ExecOpTest(object): def __init__(self, x: float, y: float, op: str, expected_result: float): self.x = x self.y = y self.op = op self.expected_result = expected_result def __str__(self): return self.__repr__() def __repr__(self): return str(self.x) + ' ' + self.op + ' ' + str( self.y) + ' =? ' + str(self.expected_result) # create the parser and parse a single file e = parse_item(fix_path('./test_data/objects/test_diff_1'), ExecOpTest) pprint(e) # parse all of them e = parse_collection(fix_path('./test_data/objects'), ExecOpTest) pprint(e) def test_collections(self): """ Tests all the supported ways to parse collections :return: """ l = parse_item( fix_path('./test_data/collections'), Tuple[Dict[str, int], List[int], Set[int], Tuple[str, int, str]]) print(l)