Ejemplo n.º 1
0
    def test_parse_string_rewrite(self):
        """

        :return:
        """
        str_1 = "<? a_header ?>some introducing text<!-- a very long comment -->" \
                "< a_tag> some text< an_other_beacon /></a_tag>"
        rep_text_1 = "some introducing text"
        rep_comments_1 = [
            Comment("a very long comment"),
        ]
        rep_headers_1 = Header("a_header")
        rep_root_element_1 = Element("a_tag", text="some text")
        rep_root_element_1.append(Element("an_other_beacon"))
        test_1 = parse_xml_string_rewrite(str_1, verbose=True)
        self.assertEqual(len(test_1), 4)
        self.assertEqual(test_1[0], rep_text_1)
        self.assertTrue(isinstance(test_1[1], list))
        for (test, ref) in zip(test_1[1], rep_comments_1):
            self.assertTrue(test == ref)
        self.assertTrue(test_1[2] == rep_headers_1)
        self.assertTrue(test_1[3] == rep_root_element_1)
        str_2 = "<!-- a very long comment -->"
        test_2 = parse_xml_string_rewrite(str_2)
        self.assertEqual(len(test_2), 4)
        self.assertEqual(test_2[0], "")
        for (test, ref) in zip(test_2[1], rep_comments_1):
            self.assertTrue(test == ref)
        self.assertIsNone(test_2[2])
        self.assertIsNone(test_2[3])
        str_3 = "< a_tag> some text< an_other_beacon /></a_tag>< a_third_beacon />"
        with self.assertRaises(Exception):
            parse_xml_string_rewrite(str_3)
Ejemplo n.º 2
0
    def setUp(self):
        """

        :return:
        """
        a_dict = OrderedDict()
        a_dict["an_other_key"] = "a value"
        a_dict["a_key"] = 5
        self.my_element = Element("some tag", attrib=a_dict)
        self.my_other_element = Element("an other tag",
                                        text="some text",
                                        attrib=a_dict)
        self.my_other_element.append(Comment("a comment"))
        self.my_other_element.append(copy(self.my_element))
Ejemplo n.º 3
0
    def setUp(self):
        """

        :return:
        """
        self.my_beacon = Beacon()
        self.my_comment = Comment("A new comment !")
        self.my_header = Header(
            "A header", OrderedDict(an_attrib="a_value", an_other_attrib=6))
        self.my_element = Element("An element",
                                  text="A text",
                                  attrib=OrderedDict(an_attrib="a_value",
                                                     an_other_attrib=6))
        self.my_element.append(self.my_comment)
Ejemplo n.º 4
0
    def test_equality(self):
        """

        :return:
        """
        # Test __eq__
        an_element = Element("some tag")
        self.assertFalse(an_element == self.my_element)
        an_element = Element("some tag",
                             attrib=dict(a_key=4, an_other="a value"))
        self.assertFalse(an_element == self.my_element)
        a_dict = OrderedDict()
        a_dict["an_other_key"] = "a value"
        a_dict["a_key"] = 5
        an_element.attrib = a_dict
        self.assertTrue(an_element == self.my_element)
Ejemplo n.º 5
0
    def test_one_part_element(self):
        """

        :return:
        """
        str_1 = ' < an_element attr ="5" attr2="3>=2"/> <an_element /> '
        str_2 = ' <an_element />'
        test_dict = OrderedDict()
        test_dict["attr"] = "5"
        test_dict["attr2"] = "3>=2"
        rep_str_1, rep_element_1 = _find_one_part_element(str_1, verbose=True)
        self.assertEqual(rep_str_1, str_2)
        self.assertTrue(
            rep_element_1 == Element(tag="an_element", attrib=test_dict))
        rep_str_2, rep_element_2 = _find_one_part_element(str_2)
        self.assertEqual(rep_str_2, "")
        self.assertTrue(rep_element_2 == Element(tag="an_element"))
Ejemplo n.º 6
0
    def test_generate_list_from_xml_string(self):
        """

        :return:
        """
        str_1 = "<!-- a very long comment -->< a_tag> some text< an_other_beacon /></a_tag>"
        rep_1 = [(0, "comment", Comment("a very long comment")),
                 (0, "start_two_parts_element", Element("a_tag")),
                 (1, "text", "some text"),
                 (1, "single_part_element", Element("an_other_beacon")),
                 (0, "end_two_parts_element", None)]
        test_1 = generate_list_from_xml_string(str_1, verbose=True)
        for (test, ref) in zip(test_1, rep_1):
            self.assertTrue(test == ref)
        str_2 = "<!-- toto"
        with self.assertRaises(Exception):
            generate_list_from_xml_string(str_2)
Ejemplo n.º 7
0
    def test_set_text(self):
        """

        :return:
        """
        # Test set_text
        my_element = Element("a tag")
        text1 = "some text"
        text2 = "an other set of text"
        self.assertIsNone(my_element.text)
        my_element.set_text(text1)
        self.assertEqual(my_element.text, text1)
        my_element.set_text(text2)
        self.assertEqual(my_element.text, "\n".join([text1, text2]))
Ejemplo n.º 8
0
    def test_dump(self):
        """

        :return:
        """
        # Test dump
        self.assertEqual(Element("a tag").dump(), '<a tag/>')
        an_element = Element("a tag")
        an_element.append(Comment("a comment"))
        self.assertEqual(an_element.dump(),
                         '<a tag>\n\t<!--a comment-->\n</a tag>')
        self.assertEqual(
            Element("a tag", text="a text").dump(), '<a tag> a text </a tag>')
        self.assertEqual(self.my_element.dump(),
                         '<some tag an_other_key="a value" a_key="5"/>')
        self.assertEqual(
            self.my_other_element.dump(),
            '<an other tag an_other_key="a value" a_key="5">\tsome text\n\t<!--a comment-->\n\t'
            '<some tag an_other_key="a value" a_key="5"/>\n</an other tag>')
Ejemplo n.º 9
0
    def test_create_element(self):
        """

        :return:
        """
        with self.assertRaises(TypeError):
            Element()
        a = Element("a tag")
        self.assertEqual(a.level, 0)
        self.assertEqual(a.tag, "a tag")
        self.assertDictEqual(a.attrib, OrderedDict())
        self.assertIsNone(a.text)
        self.assertEqual(a.children, list())
        b = Element("an other tag",
                    text="a text",
                    attrib=OrderedDict(my_attrib=["a value", 6]))
        self.assertEqual(b.level, 0)
        self.assertEqual(b.tag, "an other tag")
        self.assertEqual(b.text, "a text")
        self.assertEqual(b.children, list())
        self.assertDictEqual(b.attrib, OrderedDict(my_attrib=["a value", 6]))
        b.append(a)
        self.assertEqual(b.children, [a])
Ejemplo n.º 10
0
    def test_children_management(self):
        """

        :return:
        """
        # Test append, extend, insert, remove
        my_element = Element("a tag")
        my_comment = Comment("a comment")
        my_other_element = Element("an other tag", text="my value is 5")
        self.assertEqual(len(my_element), 0)
        my_element.extend([my_comment, my_other_element])
        self.assertEqual(len(my_element), 2)
        self.assertEqual(my_element.children, [my_comment, my_other_element])
        with self.assertRaises(ValueError):
            my_element.remove(self.my_element)
        my_element.remove(my_comment)
        self.assertEqual(len(my_element), 1)
        self.assertEqual(my_element.children, [my_other_element])
        my_element.append(self.my_element)
        self.assertEqual(len(my_element), 2)
        self.assertEqual(my_element.children,
                         [my_other_element, self.my_element])
        my_element.insert(1, my_comment)
        self.assertEqual(len(my_element), 3)
        self.assertEqual(my_element.children,
                         [my_other_element, my_comment, self.my_element])
        self.assertTrue(my_element[0] == my_other_element)
        my_element[0] = my_comment
        self.assertTrue(my_element[0] == my_comment)
        del my_element[0]
        self.assertEqual(my_element.children, [my_comment, self.my_element])
        with self.assertRaises(TypeError):
            my_element.append("a string")
        with self.assertRaises(TypeError):
            my_element.insert(2, "a string")
        with self.assertRaises(TypeError):
            my_element.remove("a string")
        with self.assertRaises(TypeError):
            my_element.extend(
                ["an element", my_comment,
                 dict(a_key="a_value")])
Ejemplo n.º 11
0
class TestElement(unittest.TestCase):
    """

    """
    def setUp(self):
        """

        :return:
        """
        a_dict = OrderedDict()
        a_dict["an_other_key"] = "a value"
        a_dict["a_key"] = 5
        self.my_element = Element("some tag", attrib=a_dict)
        self.my_other_element = Element("an other tag",
                                        text="some text",
                                        attrib=a_dict)
        self.my_other_element.append(Comment("a comment"))
        self.my_other_element.append(copy(self.my_element))

    def test_create_element(self):
        """

        :return:
        """
        with self.assertRaises(TypeError):
            Element()
        a = Element("a tag")
        self.assertEqual(a.level, 0)
        self.assertEqual(a.tag, "a tag")
        self.assertDictEqual(a.attrib, OrderedDict())
        self.assertIsNone(a.text)
        self.assertEqual(a.children, list())
        b = Element("an other tag",
                    text="a text",
                    attrib=OrderedDict(my_attrib=["a value", 6]))
        self.assertEqual(b.level, 0)
        self.assertEqual(b.tag, "an other tag")
        self.assertEqual(b.text, "a text")
        self.assertEqual(b.children, list())
        self.assertDictEqual(b.attrib, OrderedDict(my_attrib=["a value", 6]))
        b.append(a)
        self.assertEqual(b.children, [a])

    def test_equality(self):
        """

        :return:
        """
        # Test __eq__
        an_element = Element("some tag")
        self.assertFalse(an_element == self.my_element)
        an_element = Element("some tag",
                             attrib=dict(a_key=4, an_other="a value"))
        self.assertFalse(an_element == self.my_element)
        a_dict = OrderedDict()
        a_dict["an_other_key"] = "a value"
        a_dict["a_key"] = 5
        an_element.attrib = a_dict
        self.assertTrue(an_element == self.my_element)

    def test_representation(self):
        """

        :return:
        """
        # Test __str__ and __repr__
        self.assertEqual(str(self.my_element),
                         '<some tag an_other_key="a value" a_key="5"/>')
        self.assertEqual(repr(self.my_element),
                         '<some tag an_other_key="a value" a_key="5"/>')
        an_other_header = Header("a tag")
        self.assertEqual(
            str(self.my_other_element),
            '<an other tag an_other_key="a value" a_key="5">\tsome text\n\t<!--a comment-->\n\t'
            '<some tag an_other_key="a value" a_key="5"/>\n</an other tag>')
        self.assertEqual(
            repr(self.my_other_element),
            '<an other tag an_other_key="a value" a_key="5">\tsome text\n\t<!--a comment-->\n\t'
            '<some tag an_other_key="a value" a_key="5"/>\n</an other tag>')

    def test_length(self):
        """

        :return:
        """
        # Test __len__
        self.assertEqual(len(self.my_element), 0)
        self.assertEqual(len(self.my_other_element), 2)

    def test_set_text(self):
        """

        :return:
        """
        # Test set_text
        my_element = Element("a tag")
        text1 = "some text"
        text2 = "an other set of text"
        self.assertIsNone(my_element.text)
        my_element.set_text(text1)
        self.assertEqual(my_element.text, text1)
        my_element.set_text(text2)
        self.assertEqual(my_element.text, "\n".join([text1, text2]))

    def test_dump(self):
        """

        :return:
        """
        # Test dump
        self.assertEqual(Element("a tag").dump(), '<a tag/>')
        an_element = Element("a tag")
        an_element.append(Comment("a comment"))
        self.assertEqual(an_element.dump(),
                         '<a tag>\n\t<!--a comment-->\n</a tag>')
        self.assertEqual(
            Element("a tag", text="a text").dump(), '<a tag> a text </a tag>')
        self.assertEqual(self.my_element.dump(),
                         '<some tag an_other_key="a value" a_key="5"/>')
        self.assertEqual(
            self.my_other_element.dump(),
            '<an other tag an_other_key="a value" a_key="5">\tsome text\n\t<!--a comment-->\n\t'
            '<some tag an_other_key="a value" a_key="5"/>\n</an other tag>')

    def test_copy(self):
        """

        :return:
        """
        # Test __copy__
        an_other_element = copy(self.my_other_element)
        self.assertTrue(isinstance(an_other_element, Element))
        self.assertEqual(an_other_element.level, self.my_other_element.level)
        self.assertEqual(an_other_element.tag, self.my_other_element.tag)
        self.assertDictEqual(an_other_element.attrib,
                             self.my_other_element.attrib)
        self.assertEqual(an_other_element.text, self.my_other_element.text)
        self.assertEqual(an_other_element.children,
                         self.my_other_element.children)

    def test_dump_attrib(self):
        """

        :return:
        """
        # Test _dump_attrib
        self.assertEqual(self.my_element._dump_attrib(),
                         'an_other_key="a value" a_key="5"')
        self.assertEqual(self.my_element._dump_attrib(sort=True),
                         'a_key="5" an_other_key="a value"')

    def test_children_management(self):
        """

        :return:
        """
        # Test append, extend, insert, remove
        my_element = Element("a tag")
        my_comment = Comment("a comment")
        my_other_element = Element("an other tag", text="my value is 5")
        self.assertEqual(len(my_element), 0)
        my_element.extend([my_comment, my_other_element])
        self.assertEqual(len(my_element), 2)
        self.assertEqual(my_element.children, [my_comment, my_other_element])
        with self.assertRaises(ValueError):
            my_element.remove(self.my_element)
        my_element.remove(my_comment)
        self.assertEqual(len(my_element), 1)
        self.assertEqual(my_element.children, [my_other_element])
        my_element.append(self.my_element)
        self.assertEqual(len(my_element), 2)
        self.assertEqual(my_element.children,
                         [my_other_element, self.my_element])
        my_element.insert(1, my_comment)
        self.assertEqual(len(my_element), 3)
        self.assertEqual(my_element.children,
                         [my_other_element, my_comment, self.my_element])
        self.assertTrue(my_element[0] == my_other_element)
        my_element[0] = my_comment
        self.assertTrue(my_element[0] == my_comment)
        del my_element[0]
        self.assertEqual(my_element.children, [my_comment, self.my_element])
        with self.assertRaises(TypeError):
            my_element.append("a string")
        with self.assertRaises(TypeError):
            my_element.insert(2, "a string")
        with self.assertRaises(TypeError):
            my_element.remove("a string")
        with self.assertRaises(TypeError):
            my_element.extend(
                ["an element", my_comment,
                 dict(a_key="a_value")])

    def test_update_level(self):
        """

        :return:
        """
        # Test update_level
        self.assertEqual(self.my_other_element.level, 0)
        for elt in self.my_other_element.children:
            self.assertEqual(elt.level, 1)
        self.my_other_element.update_level(0)
        self.assertEqual(self.my_other_element.level, 0)
        for elt in self.my_other_element.children:
            self.assertEqual(elt.level, 1)
        self.my_other_element.update_level(5)
        self.assertEqual(self.my_other_element.level, 5)
        for elt in self.my_other_element.children:
            self.assertEqual(elt.level, 6)
        self.my_other_element.update_level(0)
        self.assertEqual(self.my_other_element.level, 0)
        for elt in self.my_other_element.children:
            self.assertEqual(elt.level, 1)

    def test_dump_children(self):
        """

        :return:
        """
        self.assertEqual(self.my_element._dump_children(), "")
        self.assertEqual(
            self.my_other_element._dump_children(),
            '\t<!--a comment-->\n\t<some tag an_other_key="a value" a_key="5"/>'
        )
Ejemplo n.º 12
0
class TestNonSpecificMethods(unittest.TestCase):
    """

    """
    def setUp(self):
        """

        :return:
        """
        self.my_beacon = Beacon()
        self.my_comment = Comment("A new comment !")
        self.my_header = Header(
            "A header", OrderedDict(an_attrib="a_value", an_other_attrib=6))
        self.my_element = Element("An element",
                                  text="A text",
                                  attrib=OrderedDict(an_attrib="a_value",
                                                     an_other_attrib=6))
        self.my_element.append(self.my_comment)

    def test_is_xml_element(self):
        """

        :return:
        """
        # Test is_xml_element
        self.assertTrue(is_xml_element(self.my_beacon))
        self.assertTrue(is_xml_element(self.my_comment))
        self.assertTrue(is_xml_element(self.my_header))
        self.assertTrue(is_xml_element(self.my_element))
        self.assertFalse(is_xml_element("an_element"))

    def test_update_level(self):
        """

        :return:
        """
        # Test update_level
        self.assertEqual(self.my_beacon.level, 0)
        self.my_beacon.update_level(0)
        self.assertEqual(self.my_beacon.level, 0)
        self.my_comment.update_level(2)
        self.assertEqual(self.my_comment.level, 2)

    def test_correct_attrib(self):
        """

        :return:
        """
        # Test correct_attrib
        attrib = None
        with self.assertRaises(TypeError):
            self.my_beacon.correct_attrib(attrib)
        attrib = ["a_value", "an_other_value"]
        with self.assertRaises(TypeError):
            self.my_beacon.correct_attrib(attrib)
        attrib = dict(a_key="a_value", an_other_key=0)
        self.assertDictEqual(self.my_beacon.correct_attrib(attrib),
                             dict(a_key="a_value", an_other_key="0"))
        attrib = OrderedDict(a_key="a_value", an_other_key=0)
        self.assertDictEqual(self.my_beacon.correct_attrib(attrib),
                             OrderedDict(a_key="a_value", an_other_key="0"))

    def test_dict_equality(self):
        """

        :return:
        """
        a = dict(a_key="a_value", an_other_key="an_other_value")
        b = OrderedDict(a_key="a_value",
                        an_other_key="an_other_different_value")
        self.assertFalse(self.my_beacon._test_dict_equality(a, b))
        b["an_other_key"] = "an_other_value"
        self.assertTrue(self.my_beacon._test_dict_equality(a, b))
        del b["a_key"]
        self.assertFalse(self.my_beacon._test_dict_equality(a, b))
        self.assertFalse(self.my_beacon._test_dict_equality(a, "a_string"))

    def test_attrib_equality(self):
        """

        :return:
        """
        an_other_beacon = Beacon()
        an_other_beacon.update_level(5)
        an_other_beacon.an_attrib = "my_attrib"
        self.assertFalse(
            an_other_beacon._test_attribute_equality("level", self.my_beacon))
        self.assertFalse(
            an_other_beacon._test_attribute_equality("an_attrib",
                                                     self.my_beacon))
        an_other_beacon.update_level(self.my_beacon.level)
        self.assertTrue(
            an_other_beacon._test_attribute_equality("level", self.my_beacon))

    def test_dump_dict(self):
        """

        :return:
        """
        # Test _dump_dict
        attrib = OrderedDict()
        self.assertIsNone(self.my_beacon.dump_dict(attrib))
        attrib["some_key"] = "é_value"
        attrib["other_key_à"] = "0"
        self.assertEqual(self.my_beacon.dump_dict(attrib),
                         'some_key="\xe9_value" other_key_\xe0="0"')
        self.assertEqual(self.my_beacon.dump_dict(attrib, sort=True),
                         'other_key_\xe0="0" some_key="\xe9_value"')
Ejemplo n.º 13
0
    def test_generate_xml_tree_from_list(self):
        """

        :return:
        """
        list_1 = [(0, "comment", Comment("a comment")),
                  (0, "header", Header("a header")), (0, "text", "some text"),
                  (0, "single_part_element", Element("an element"))]
        test_1 = generate_xml_tree_from_list(list_1)
        self.assertTrue(isinstance(test_1[0], list))
        self.assertListEqual(test_1[0], list())
        self.assertTrue(isinstance(test_1[1], list))
        self.assertTrue(len(test_1[1]), 1)
        self.assertTrue(test_1[1][0] == Element("an element"))
        self.assertTrue(isinstance(test_1[2], list))
        self.assertTrue(len(test_1[2]), 1)
        self.assertTrue(test_1[2][0] == "some text")
        self.assertTrue(isinstance(test_1[3], list))
        self.assertTrue(len(test_1[3]), 1)
        self.assertTrue(test_1[3][0] == Comment("a comment"))
        self.assertTrue(isinstance(test_1[4], list))
        self.assertTrue(len(test_1[4]), 1)
        self.assertTrue(test_1[4][0] == Header("a header"))
        list_2 = [(1, "start_two_parts_element", Element("an element")),
                  (1, "header", Header("a header")),
                  (0, "end_two_parts_element", None)]
        with self.assertRaises(Exception):
            generate_xml_tree_from_list(list_2, verbose=True)
        list_3 = [(0, "start_two_parts_element", Element("a double element")),
                  (1, "single_part_element", Element("an element")),
                  (1, "comment", Comment("a comment")),
                  (1, "text", "some text"),
                  (1, "single_part_element", Element("an other element")),
                  (0, "end_two_parts_element", None)]
        test_3 = generate_xml_tree_from_list(list_3)
        rep_3 = Element("a double element")
        rep_3.text = "some text"
        rep_3.append(Element("an element"))
        rep_3.append(Comment("a comment"))
        rep_3.append(Element("an other element"))
        self.assertTrue(isinstance(test_3[0], list))
        self.assertListEqual(test_3[0], list())
        self.assertTrue(isinstance(test_3[1], list))
        self.assertTrue(len(test_3[1]), 1)
        self.assertTrue(test_3[1][0] == rep_3)
        self.assertTrue(isinstance(test_3[2], list))
        self.assertListEqual(test_3[2], list())
        self.assertTrue(isinstance(test_3[3], list))
        self.assertListEqual(test_3[3], list())
        self.assertTrue(isinstance(test_3[4], list))
        self.assertListEqual(test_3[4], list())
Ejemplo n.º 14
0
    def test_find_next_element(self):
        """

        :return:
        """
        str_1 = '<? a_header key="value" ?><!--some comments-->  '
        rep_1 = find_next_element(str_1, level=5, verbose=True)
        self.assertEqual(len(rep_1), 2)
        self.assertEqual(rep_1[0], "<!--some comments-->")
        self.assertTrue(isinstance(rep_1[1], tuple))
        self.assertEqual(len(rep_1[1]), 3)
        self.assertEqual(rep_1[1][0], 5)
        self.assertEqual(rep_1[1][1], "header")
        rep_elt_1 = Header("a_header", attrib=dict(key="value"))
        self.assertTrue(rep_1[1][2] == rep_elt_1)
        str_2 = " <!-- a comment with \" ' special characters < > --><? a header ?>"
        rep_2 = find_next_element(str_2, tag="a_tag")
        self.assertEqual(len(rep_2), 2)
        self.assertEqual(rep_2[0], "<? a header ?>")
        self.assertTrue(isinstance(rep_2[1], tuple))
        self.assertEqual(len(rep_2[1]), 3)
        self.assertEqual(rep_2[1][0], 0)
        self.assertEqual(rep_2[1][1], "comment")
        self.assertTrue(rep_2[1][2] == Comment(
            "a comment with \" ' special characters < >"))
        str_3 = "Some text with &lt special characters &gt to be skip < a_beacon/>"
        rep_3 = find_next_element(str_3)
        self.assertEqual(len(rep_3), 2)
        self.assertEqual(rep_3[0], "< a_beacon/>")
        self.assertTrue(isinstance(rep_3[1], tuple))
        self.assertEqual(len(rep_3[1]), 3)
        self.assertEqual(rep_3[1][0], 0)
        self.assertEqual(rep_3[1][1], "text")
        self.assertEqual(
            rep_3[1][2],
            "Some text with &lt special characters &gt to be skip")
        str_4 = ' < a_beacon key1="5" key2="value2" />'
        rep_4 = find_next_element(str_4)
        self.assertEqual(len(rep_4), 2)
        self.assertEqual(rep_4[0], "")
        self.assertTrue(isinstance(rep_4[1], tuple))
        self.assertEqual(len(rep_4[1]), 3)
        self.assertEqual(rep_4[1][0], 0)
        self.assertEqual(rep_4[1][1], "single_part_element")
        rep_elt_4 = Element("a_beacon", attrib=OrderedDict(key1="5"))
        rep_elt_4.attrib["key2"] = "value2"
        self.assertTrue(rep_4[1][2] == rep_elt_4)
        str_5 = ' < a_beacon key1="5" key2="value2" >'
        rep_5 = find_next_element(str_5)
        self.assertEqual(len(rep_5), 2)
        self.assertEqual(rep_5[0], "")
        self.assertTrue(isinstance(rep_5[1], tuple))
        self.assertEqual(len(rep_5[1]), 3)
        self.assertEqual(rep_5[1][0], 0)
        self.assertEqual(rep_5[1][1], "start_two_parts_element")
        rep_elt_5 = Element("a_beacon", attrib=OrderedDict(key1="5"))
        rep_elt_5.attrib["key2"] = "value2"
        self.assertTrue(rep_5[1][2] == rep_elt_5)
        str_6 = ' </ a_beacon >'
        rep_6 = find_next_element(str_6)
        self.assertEqual(len(rep_6), 2)
        self.assertEqual(rep_6[0], str_6.strip())
        self.assertTrue(isinstance(rep_6[1], tuple))
        self.assertEqual(len(rep_6[1]), 3)
        self.assertEqual(rep_6[1][0], 0)
        self.assertIsNone(rep_6[1][1])
        self.assertIsNone(rep_6[1][2])
        rep_7 = find_next_element(str_6, level=5)
        self.assertEqual(len(rep_7), 2)
        self.assertEqual(rep_7[0], str_6.strip())
        self.assertTrue(isinstance(rep_7[1], tuple))
        self.assertEqual(len(rep_7[1]), 3)
        self.assertEqual(rep_7[1][0], 5)
        self.assertIsNone(rep_7[1][1])
        self.assertIsNone(rep_7[1][2])
        rep_8 = find_next_element(str_6, tag="a_beacon")
        self.assertEqual(len(rep_8), 2)
        self.assertEqual(rep_8[0], str_6.strip())
        self.assertTrue(isinstance(rep_8[1], tuple))
        self.assertEqual(len(rep_8[1]), 3)
        self.assertEqual(rep_8[1][0], 0)
        self.assertIsNone(rep_8[1][1])
        self.assertIsNone(rep_8[1][2])
        rep_9 = find_next_element(str_6, level=5, tag="a_beacon")
        self.assertEqual(len(rep_9), 2)
        self.assertEqual(rep_9[0], "")
        self.assertTrue(isinstance(rep_9[1], tuple))
        self.assertEqual(len(rep_9[1]), 3)
        self.assertEqual(rep_9[1][0], 4)
        self.assertEqual(rep_9[1][1], "end_two_parts_element")
        self.assertIsNone(rep_9[1][2])
        str_10 = "<!-- toto"
        rep_10 = find_next_element(str_10)
        self.assertEqual(len(rep_10), 2)
        self.assertEqual(rep_10[0], str_10)
        self.assertTrue(isinstance(rep_10[1], tuple))
        self.assertEqual(len(rep_10[1]), 3)
        self.assertEqual(rep_10[1][0], 0)
        self.assertIsNone(rep_10[1][1])
        self.assertIsNone(rep_10[1][2])
        str_11 = "<!-- tag"
        rep_11 = find_next_element(str_11, tag="a_beacon", level=6)
        self.assertEqual(len(rep_11), 2)
        self.assertEqual(rep_11[0], str_11)
        self.assertTrue(isinstance(rep_11[1], tuple))
        self.assertEqual(len(rep_11[1]), 3)
        self.assertEqual(rep_11[1][0], 6)
        self.assertIsNone(rep_11[1][1])
        self.assertIsNone(rep_11[1][2])