def test_iterator_escape_whitespaces(self): uut = StringConverter("ta, chi, tsu, te, \\ to", list_delimiters=",") self.assertEqual(list(uut), ["ta", "chi", "tsu", "te", " to"]) uut = StringConverter(r"/**, \ *\ , \ */", list_delimiters=",") self.assertEqual(list(uut), ["/**", " * ", " */"]) uut = StringConverter( "abc\\\\ , def\\ \\ \\ , \\\\ unstrip \\\\\\ ", list_delimiters=",") self.assertEqual(list(uut), ["abc\\", "def ", "\\ unstrip \\ "])
def __init__(self, key, value, origin='', strip_whitespaces=True, list_delimiters=(',', ';'), from_cli=False, remove_empty_iter_elements=True, to_append=False): """ Initializes a new Setting, :param key: The key of the Setting. :param value: The value, if you apply conversions to this object these will be applied to this value. :param origin: The originating file. This will be used for path conversions and the last part will be stripped of. If you want to specify a directory as origin be sure to end it with a directory separator. :param strip_whitespaces: Whether to strip whitespaces from the value or not :param list_delimiters: Delimiters for list conversion :param from_cli: True if this setting was read by the CliParser. :param remove_empty_iter_elements: Whether to remove empty elements in iterable values. :param to_append: The boolean value if setting value needs to be appended to a setting in the defaults of a section. """ if not isinstance(from_cli, bool): raise TypeError('from_cli needs to be a boolean value.') if not isinstance(to_append, bool): raise TypeError('to_append needs to be a boolean value.') self.to_append = to_append StringConverter.__init__( self, value, strip_whitespaces=strip_whitespaces, list_delimiters=list_delimiters, remove_empty_iter_elements=remove_empty_iter_elements) self.from_cli = from_cli self.key = key self.origin = str(origin)
def test_url(self): valid_urls = ( # Scheme tests "http://url.com", "https://url.com", "url.com", "ftp://url.com", "ftps://url.com", # Domain tests "http://sub.subsub.url.com", "http://sub.url.com", "http://url.co.cc", "http://localhost", "http://sub.url123.com", "http://url123.co.cc", "http://1.1.1.1", "sub.subsub.url.com", "sub.url.com", "url.co.cc", "localhost", "1.1.1.1", "255.255.255.255", "url123.com", "url123.co.cc", "sub.url123.com", # Port number "localhost:8888", "1.1.1.1:80", "url.com:123456", # Paths "url.com/", "url.co.in/", "url.com/path/to/something", "url.co.in/path/to/something", "url.com/path/to/file.php") invalid_urls = ( # Invalid types 123, True, None, # Invalid links "unknown://url.com", "123", "abcd", "url.unknown", "user:[email protected]", "http://unknownlocalhost", "local_host/path") for url in valid_urls: try: StringConverter(url).__url__() except ValueError as exception: print(exception) self.fail("URL {} raised ValueError unexpectedly.".format(url)) for url in invalid_urls: self.assertRaises(ValueError, self.uut.__url__)
def __extract_keys_and_value(self, line, delimiters, return_second_part_nonempty=False): """ This method extracts the keys and values from the give string by splitting them based on the delimiters provided. :param line: The input string. :param delimiters: A list of delimiters to split the strings on. :param return_second_part_nonempty: If no delimiter is found and this is true the contents of the string will be returned as value :return: The parsed keys and values from a line. """ key_part, value = self.__separate_by_first_occurrence( line, delimiters, True, return_second_part_nonempty) keys = list( StringConverter(key_part, list_delimiters=self.key_delimiters).__iter__( remove_backslashes=False)) return keys, value
def test_equality_comparision(self): self.assertEqual(StringConverter(" i dont know "), StringConverter("i dont know")) self.assertNotEqual(StringConverter(" dont know "), StringConverter("i dont know ")) self.assertNotEqual(StringConverter(""), StringConverter("i dont know ")) self.assertNotEqual(5, StringConverter("i dont know "))
def test_dict_escape_whitespaces(self): uut = StringConverter( "\\ : \\ , hello: \\ world, \\\\ A \\\\ : B\\ ") self.assertEqual(dict(uut), {" ": " ", "hello": " world", "\\ A \\": "B "}) uut = StringConverter(r"/**, \ *\ , \ */") self.assertEqual(dict(uut), {"/**": "", " * ": "", " */": ""}) uut = StringConverter("abc\\\\ : qew, def\\ \\ \\ ," " \\\\ unstrip \\\\\\ ") self.assertEqual(dict(uut), {"abc\\": "qew", "def ": "", "\\ unstrip \\ ": ""}) uut = StringConverter("A:B,C : D\\x \\a,42:\\n8 ", strip_whitespaces=False) self.assertEqual(dict(uut), {"A": "B", "C ": " Dx a", "42": "n8 "})
def typed_list(conversion_func): """ Creates a function that converts a setting into a list of elements each converted with the given conversion function. :param conversion_func: The conversion function that converts a string into your desired list item object. :return: A conversion function. """ return lambda setting: [ conversion_func(StringConverter(elem)) for elem in setting]
def test_iterator_remove_empty_iter_elements(self): uut = StringConverter("a, b, c, , e, , g", list_delimiters=",") self.assertEqual(list(uut), ["a", "b", "c", "e", "g"]) uut = StringConverter("a, , ,, e, , g", list_delimiters=",", remove_empty_iter_elements=True) self.assertEqual(list(uut), ["a", "e", "g"]) uut = StringConverter(",,, ,", list_delimiters=",", remove_empty_iter_elements=True) self.assertEqual(list(uut), []) uut = StringConverter("a, b, c, , e, , g", list_delimiters=",", remove_empty_iter_elements=False) self.assertEqual(list(uut), ["a", "b", "c", "", "e", "", "g"]) uut = StringConverter(",,, ,", list_delimiters=",", remove_empty_iter_elements=False) self.assertEqual(list(uut), ["", "", "", "", ""])
def ask_question(question, default=None, printer: Printer = None, typecast=str, **kwargs): """ Asks the user a question and returns the answer. :param question: String to be used as question. :param default: The default answer to be returned if the user gives a void answer to the question. :param printer: The printer object used for console interactions. If this is not given, it defaults to a ``ConsolePrinter`` which prints outputs to the console. :param typecast: Type to cast the input to. Defaults to a ``str``. :param kwargs: The additional keyword arguments are held for backwards compatibility and for future use with the ``prompt_toolkit``. :return: The response from the user. """ if printer is None: printer = ConsolePrinter() while True: printer.print(question, color="yellow", end=" ") if default: printer.print("[" + default + "]", end=" ") printer.print("") answer = input() if default and len(answer) == 0: answer = default try: answer = typecast(StringConverter(answer)) except BaseException as e: printer.print( str(e) + "\nPlease enter a valid answer.", color="blue") else: return answer
def test_float_conversion(self): self.assertEqual(float(self.uut), 1) self.uut.value = "0.5 " self.assertEqual(float(self.uut), 0.5) self.uut = StringConverter(" not a float ") self.assertRaises(ValueError, float, self.uut)
def test_dict_conversion(self): self.uut = StringConverter("test") self.assertEqual(dict(self.uut), {"test": ""}) self.uut = StringConverter("test, t") self.assertEqual(dict(self.uut), {"test": "", "t": ""}) self.uut = StringConverter("test, t: v") self.assertEqual(dict(self.uut), {"test": "", "t": "v"}) # Check escaping self.uut = StringConverter("test, t\\: v") self.assertEqual(dict(self.uut), {"test": "", "t: v": ""}) self.uut = StringConverter("test, t\\: v: t") self.assertEqual(dict(self.uut), {"test": "", "t: v": "t"}) self.uut = StringConverter("test\\, t\\: v: t") self.assertEqual(dict(self.uut), {"test, t: v": "t"}) self.uut = StringConverter("test\\, t\\: v: t\\,") self.assertEqual(dict(self.uut), {"test, t: v": "t,"}) # Check that lists ignore colons self.assertEqual(list(self.uut), ["test, t: v: t,"])
# condition_dict) and all values to floats while unset values default to 1. counting_condition_dict = typed_ordered_dict( lambda setting: condition_dict[str(setting).lower()], float, 1) default_cc_dict = counting_condition_dict(StringConverter( """ used: 0, returned: 1.4, is_condition: 0, in_condition: 1.4, in_second_level_condition: 1.4, in_third_level_condition: 1.0, is_assignee: 0, is_assigner: 0.6, loop_content: 0, second_level_loop_content, third_level_loop_content, is_param: 2, is_called: 1.4, is_call_param: 0.0, in_sum: 2.0, in_product: 0, in_binary_operation, member_accessed""")) def get_difference(function_pair, count_matrices, average_calculation, poly_postprocessing,
def test_bool_conversion(self): self.assertEqual(bool(self.uut), True) self.uut.value = "yeah" self.assertEqual(bool(self.uut), True) self.uut = StringConverter("y") self.assertEqual(bool(self.uut), True) self.uut = StringConverter("yep") self.assertEqual(bool(self.uut), True) self.uut = StringConverter("positive") self.assertEqual(bool(self.uut), True) self.uut = StringConverter("nope") self.assertEqual(bool(self.uut), False) self.uut = StringConverter("nop") self.assertEqual(bool(self.uut), False) self.uut = StringConverter("negative") self.assertEqual(bool(self.uut), False) self.uut = StringConverter(" i dont know ") self.assertRaises(ValueError, bool, self.uut)
def test_whitespace_stripping(self): self.assertEqual(str(self.uut), "1") self.uut = StringConverter("\n 1 \n", strip_whitespaces=False) self.assertEqual(str(self.uut), "\n 1 \n")
def setUp(self): self.uut = StringConverter("\n \\1 \n ")
class StringConverterTest(unittest.TestCase): def setUp(self): self.uut = StringConverter("\n \\1 \n ") def test_construction(self): self.assertRaises(TypeError, StringConverter, "test", strip_whitespaces=5) self.assertRaises(TypeError, StringConverter, "test", list_delimiters=5) def test_whitespace_stripping(self): self.assertEqual(str(self.uut), "1") self.uut = StringConverter("\n 1 \n", strip_whitespaces=False) self.assertEqual(str(self.uut), "\n 1 \n") def test_int_conversion(self): self.assertEqual(int(self.uut), 1) self.uut = StringConverter(" not an int ") self.assertRaises(ValueError, int, self.uut) def test_float_conversion(self): self.assertEqual(float(self.uut), 1) self.uut.value = "0.5 " self.assertEqual(float(self.uut), 0.5) self.uut = StringConverter(" not a float ") self.assertRaises(ValueError, float, self.uut) def test_len(self): self.assertEqual(len(self.uut), 1) def test_iterator(self): self.uut = StringConverter("a, test with!!some challenge", list_delimiters=[",", " ", "!!"]) self.assertEqual(list(self.uut), ["a", "test", "with", "some", "challenge"]) self.uut = StringConverter("a\\ \\,\\\\ test with!!some challenge", list_delimiters=[",", " ", "!!"]) self.assertEqual(list(self.uut), ["a ,\\", "test", "with", "some", "challenge"]) self.uut = StringConverter("a, test with!some \\\\\\ challenge\\ ", list_delimiters=", !", strip_whitespaces=False) self.assertEqual(list(self.uut), ["a", "test", "with", "some", "\\ challenge "]) self.uut = StringConverter("a, test with!some \\\\\\ challenge\\ ", list_delimiters=", !", strip_whitespaces=True) self.assertEqual(list(self.uut), ["a", "test", "with", "some", "\\ challenge "]) self.uut = StringConverter("testval", list_delimiters=[",", "¸"]) self.uut.value = "a\\n,bug¸g" self.assertEqual(list(self.uut), ["an", "bug", "g"]) self.assertEqual(list(self.uut.__iter__(False)), ["a\\n", "bug", "g"]) self.assertTrue("bug" in self.uut) self.assertFalse("but" in self.uut) self.uut = StringConverter("a, test, \n", list_delimiters=[","], strip_whitespaces=True) self.assertEqual(list(self.uut), ["a", "test"]) self.uut = StringConverter("a, test, \n", list_delimiters=[","], strip_whitespaces=False) self.assertEqual(list(self.uut), ["a", " test", " \n"]) uut = StringConverter("A,B,C , D\\x \\a,42,\\n8 ", strip_whitespaces=False) self.assertEqual(list(uut), ["A", "B", "C ", " Dx a", "42", "n8 "]) def test_iterator_escape_whitespaces(self): uut = StringConverter("ta, chi, tsu, te, \\ to", list_delimiters=",") self.assertEqual(list(uut), ["ta", "chi", "tsu", "te", " to"]) uut = StringConverter(r"/**, \ *\ , \ */", list_delimiters=",") self.assertEqual(list(uut), ["/**", " * ", " */"]) uut = StringConverter( "abc\\\\ , def\\ \\ \\ , \\\\ unstrip \\\\\\ ", list_delimiters=",") self.assertEqual(list(uut), ["abc\\", "def ", "\\ unstrip \\ "]) def test_iterator_remove_empty_iter_elements(self): uut = StringConverter("a, b, c, , e, , g", list_delimiters=",") self.assertEqual(list(uut), ["a", "b", "c", "e", "g"]) uut = StringConverter("a, , ,, e, , g", list_delimiters=",", remove_empty_iter_elements=True) self.assertEqual(list(uut), ["a", "e", "g"]) uut = StringConverter(",,, ,", list_delimiters=",", remove_empty_iter_elements=True) self.assertEqual(list(uut), []) uut = StringConverter("a, b, c, , e, , g", list_delimiters=",", remove_empty_iter_elements=False) self.assertEqual(list(uut), ["a", "b", "c", "", "e", "", "g"]) uut = StringConverter(",,, ,", list_delimiters=",", remove_empty_iter_elements=False) self.assertEqual(list(uut), ["", "", "", "", ""]) def test_dict_escape_whitespaces(self): uut = StringConverter( "\\ : \\ , hello: \\ world, \\\\ A \\\\ : B\\ ") self.assertEqual(dict(uut), {" ": " ", "hello": " world", "\\ A \\": "B "}) uut = StringConverter(r"/**, \ *\ , \ */") self.assertEqual(dict(uut), {"/**": "", " * ": "", " */": ""}) uut = StringConverter("abc\\\\ : qew, def\\ \\ \\ ," " \\\\ unstrip \\\\\\ ") self.assertEqual(dict(uut), {"abc\\": "qew", "def ": "", "\\ unstrip \\ ": ""}) uut = StringConverter("A:B,C : D\\x \\a,42:\\n8 ", strip_whitespaces=False) self.assertEqual(dict(uut), {"A": "B", "C ": " Dx a", "42": "n8 "}) def test_dict_conversion(self): self.uut = StringConverter("test") self.assertEqual(dict(self.uut), {"test": ""}) self.uut = StringConverter("test, t") self.assertEqual(dict(self.uut), {"test": "", "t": ""}) self.uut = StringConverter("test, t: v") self.assertEqual(dict(self.uut), {"test": "", "t": "v"}) # Check escaping self.uut = StringConverter("test, t\\: v") self.assertEqual(dict(self.uut), {"test": "", "t: v": ""}) self.uut = StringConverter("test, t\\: v: t") self.assertEqual(dict(self.uut), {"test": "", "t: v": "t"}) self.uut = StringConverter("test\\, t\\: v: t") self.assertEqual(dict(self.uut), {"test, t: v": "t"}) self.uut = StringConverter("test\\, t\\: v: t\\,") self.assertEqual(dict(self.uut), {"test, t: v": "t,"}) # Check that lists ignore colons self.assertEqual(list(self.uut), ["test, t: v: t,"]) def test_bool_conversion(self): self.assertEqual(bool(self.uut), True) self.uut.value = "yeah" self.assertEqual(bool(self.uut), True) self.uut = StringConverter("y") self.assertEqual(bool(self.uut), True) self.uut = StringConverter("yep") self.assertEqual(bool(self.uut), True) self.uut = StringConverter("positive") self.assertEqual(bool(self.uut), True) self.uut = StringConverter("nope") self.assertEqual(bool(self.uut), False) self.uut = StringConverter("nop") self.assertEqual(bool(self.uut), False) self.uut = StringConverter("negative") self.assertEqual(bool(self.uut), False) self.uut = StringConverter(" i dont know ") self.assertRaises(ValueError, bool, self.uut) def test_equality_comparision(self): self.assertEqual(StringConverter(" i dont know "), StringConverter("i dont know")) self.assertNotEqual(StringConverter(" dont know "), StringConverter("i dont know ")) self.assertNotEqual(StringConverter(""), StringConverter("i dont know ")) self.assertNotEqual(5, StringConverter("i dont know ")) def test_url(self): valid_urls = ( # Scheme tests "http://url.com", "https://url.com", "url.com", "ftp://url.com", "ftps://url.com", # Domain tests "http://sub.subsub.url.com", "http://sub.url.com", "http://url.co.cc", "http://localhost", "http://sub.url123.com", "http://url123.co.cc", "http://1.1.1.1", "sub.subsub.url.com", "sub.url.com", "url.co.cc", "localhost", "1.1.1.1", "255.255.255.255", "url123.com", "url123.co.cc", "sub.url123.com", # Port number "localhost:8888", "1.1.1.1:80", "url.com:123456", # Paths "url.com/", "url.co.in/", "url.com/path/to/something", "url.co.in/path/to/something", "url.com/path/to/file.php") invalid_urls = ( # Invalid types 123, True, None, # Invalid links "unknown://url.com", "123", "abcd", "url.unknown", "user:[email protected]", "http://unknownlocalhost", "local_host/path") for url in valid_urls: try: StringConverter(url).__url__() except ValueError as exception: print(exception) self.fail("URL {} raised ValueError unexpectedly.".format(url)) for url in invalid_urls: self.assertRaises(ValueError, self.uut.__url__)
def test_int_conversion(self): self.assertEqual(int(self.uut), 1) self.uut = StringConverter(" not an int ") self.assertRaises(ValueError, int, self.uut)
def __iter__(self, remove_backslashes=True): if self.to_append: raise ValueError('Iteration on this object is invalid because the ' 'value is incomplete. Please access the value of ' 'the setting in a section to iterate through it.') return StringConverter.__iter__(self, remove_backslashes)
def test_iterator(self): self.uut = StringConverter("a, test with!!some challenge", list_delimiters=[",", " ", "!!"]) self.assertEqual(list(self.uut), ["a", "test", "with", "some", "challenge"]) self.uut = StringConverter("a\\ \\,\\\\ test with!!some challenge", list_delimiters=[",", " ", "!!"]) self.assertEqual(list(self.uut), ["a ,\\", "test", "with", "some", "challenge"]) self.uut = StringConverter("a, test with!some \\\\\\ challenge\\ ", list_delimiters=", !", strip_whitespaces=False) self.assertEqual(list(self.uut), ["a", "test", "with", "some", "\\ challenge "]) self.uut = StringConverter("a, test with!some \\\\\\ challenge\\ ", list_delimiters=", !", strip_whitespaces=True) self.assertEqual(list(self.uut), ["a", "test", "with", "some", "\\ challenge "]) self.uut = StringConverter("testval", list_delimiters=[",", "¸"]) self.uut.value = "a\\n,bug¸g" self.assertEqual(list(self.uut), ["an", "bug", "g"]) self.assertEqual(list(self.uut.__iter__(False)), ["a\\n", "bug", "g"]) self.assertTrue("bug" in self.uut) self.assertFalse("but" in self.uut) self.uut = StringConverter("a, test, \n", list_delimiters=[","], strip_whitespaces=True) self.assertEqual(list(self.uut), ["a", "test"]) self.uut = StringConverter("a, test, \n", list_delimiters=[","], strip_whitespaces=False) self.assertEqual(list(self.uut), ["a", " test", " \n"]) uut = StringConverter("A,B,C , D\\x \\a,42,\\n8 ", strip_whitespaces=False) self.assertEqual(list(uut), ["A", "B", "C ", " Dx a", "42", "n8 "])