Python struct.find函数代码示例

    def test_compile_reg_put_replace_whole_tree(self):
        root = self.tree_with_paragraphs()

        change2a = {
            'action': 'PUT',
            'node': {
                'text': 'new text',
                'label': ['205', '2', 'a'],
                'node_type': 'regtext'}}

        change2a1 = {
            'action': 'PUT',
            'node': {
                'text': '2a1 text',
                'label': ['205', '2', 'a', '1'],
                'node_type': 'regtext'}}

        notice_changes = {
            '205-2-a-1': [change2a1],
            '205-2-a': [change2a]
        }

        reg = compiler.compile_regulation(root, notice_changes)

        added_node = find(reg, '205-2-a')
        self.assertEqual(added_node.text, 'new text')

        deeper = find(reg, '205-2-a-1')
        self.assertEqual(deeper.text, '2a1 text')

    def test_compile_designate(self):
        root = self.tree_with_subparts()
        change = {
            'action': 'POST',
            'subpart': ['205', 'Subpart', 'B'],
            'node': {
                'text': '2 text',
                'label': ['205', '2'],
                'node_type': 'regtext'}}

        notice_changes = {'205-2': [change]}
        reg = compiler.compile_regulation(root, notice_changes)

        subpart_b = find(reg, '205-Subpart-B')
        self.assertEqual(len(subpart_b.children), 1)

        subpart_a = find(reg, '205-Subpart-A')
        self.assertEqual(len(subpart_a.children), 0)

        change = {
            'action': 'DESIGNATE',
            'destination': ['205', 'Subpart', 'A']}

        notice_changes = {'205-2': [change]}

        new_reg = compiler.compile_regulation(reg, notice_changes)

        self.assertEqual(None, find(new_reg, '205-Subpart-B'))

        subpart_a = find(new_reg, '205-Subpart-A')
        self.assertEqual(len(subpart_a.children), 1)

    def test_compile_designate(self):
        root = self.tree_with_subparts()
        change = {
            "action": "POST",
            "subpart": ["205", "Subpart", "B"],
            "node": Node(text="2 text", label=["205", "2"], node_type=Node.REGTEXT),
        }

        notice_changes = {"205-2": [change]}
        reg = compiler.compile_regulation(root, notice_changes)

        subpart_b = find(reg, "205-Subpart-B")
        self.assertEqual(len(subpart_b.children), 1)

        subpart_a = find(reg, "205-Subpart-A")
        self.assertEqual(len(subpart_a.children), 0)

        change = {"action": "DESIGNATE", "destination": ["205", "Subpart", "A"]}

        notice_changes = {"205-2": [change]}

        new_reg = compiler.compile_regulation(reg, notice_changes)

        self.assertEqual(None, find(new_reg, "205-Subpart-B"))

        subpart_a = find(new_reg, "205-Subpart-A")
        self.assertEqual(len(subpart_a.children), 1)

    def test_create_empty(self):
        root = self.tree_with_paragraphs()
        reg_tree = compiler.RegulationTree(root)
        reg_tree.create_empty_node("205-4-a")

        node = find(reg_tree.tree, "205-4-a")
        self.assertNotEqual(None, node)
        self.assertEqual(node.label, ["205", "4", "a"])
        self.assertEqual(node.node_type, Node.REGTEXT)

        node = Node(label=["205", "M2"], title="Appendix M2", node_type=Node.APPENDIX)
        reg_tree.add_node(node)
        reg_tree.create_empty_node("205-M2-1")
        node = find(reg_tree.tree, "205-M2-1")
        self.assertNotEqual(None, node)
        self.assertEqual(node.label, ["205", "M2", "1"])
        self.assertEqual(node.node_type, Node.APPENDIX)

        node = Node(label=["205", Node.INTERP_MARK], title="Supplement I", node_type=Node.INTERP)
        reg_tree.add_node(node)
        reg_tree.create_empty_node("205-3-Interp")
        node = find(reg_tree.tree, "205-3-Interp")
        self.assertNotEqual(None, node)
        self.assertEqual(node.label, ["205", "3", Node.INTERP_MARK])
        self.assertEqual(node.node_type, Node.INTERP)

    def test_create_empty(self):
        root = self.tree_with_paragraphs()
        reg_tree = compiler.RegulationTree(root)
        reg_tree.create_empty_node('205-4-a')

        node = find(reg_tree.tree, '205-4-a')
        self.assertNotEqual(None, node)
        self.assertEqual(node.label, ['205', '4', 'a'])
        self.assertEqual(node.node_type, Node.REGTEXT)

        node = Node(label=['205', 'M2'], title='Appendix M2',
                    node_type=Node.APPENDIX)
        reg_tree.add_node(node)
        reg_tree.create_empty_node('205-M2-1')
        node = find(reg_tree.tree, '205-M2-1')
        self.assertNotEqual(None, node)
        self.assertEqual(node.label, ['205', 'M2', '1'])
        self.assertEqual(node.node_type, Node.APPENDIX)

        node = Node(label=['205', Node.INTERP_MARK], title='Supplement I',
                    node_type=Node.INTERP)
        reg_tree.add_node(node)
        reg_tree.create_empty_node('205-3-Interp')
        node = find(reg_tree.tree, '205-3-Interp')
        self.assertNotEqual(None, node)
        self.assertEqual(node.label, ['205', '3', Node.INTERP_MARK])
        self.assertEqual(node.node_type, Node.INTERP)

    def move_to_subpart(self, label, subpart_label):
        """ Move an existing node to another subpart. If the new subpart
        doesn't exist, create it. """
        if len(label.split('-')) != 2:
            logger.error(
                "Trying to move a non-section into a subpart: %s -> %s",
                label, subpart_label)
            return

        destination = find(self.tree, '-'.join(subpart_label))

        if destination is None:
            destination = self.create_new_subpart(subpart_label)

        subpart_with_node = find_parent(self.tree, label)

        if destination and subpart_with_node:
            node = find(subpart_with_node, label)
            other_children = [c for c in subpart_with_node.children
                              if c.label_id() != label]
            subpart_with_node.children = other_children
            destination.children = self.add_child(destination.children, node)

            if not subpart_with_node.children:
                self.delete('-'.join(subpart_with_node.label))

 def test_compile_reg_move_wrong_reg(self):
     """Changes applied to other regulations shouldn't affect the
     regulation we care about, even if that has the same textual prefix"""
     root = self.tree_with_paragraphs()
     notice_changes = {"2055-2-a": [{"action": "MOVE", "destination": ["2055", "2", "b"]}]}
     reg = compiler.compile_regulation(root, notice_changes)
     self.assertEqual(find(reg, "205-2-a").text, "n2a")
     self.assertEqual(find(reg, "205-2-b").text, "n2b")
     self.assertEqual(find(reg, "2055-2-b"), None)

    def test_delete_section_in_subpart(self):
        """Verify that we can delete a section within a subpart"""
        root = self.tree_with_subparts()
        root.children[0].children = [Node(label=['205', '12'])]
        reg_tree = compiler.RegulationTree(root)

        self.assertNotEqual(None, find(reg_tree.tree, '205-12'))
        reg_tree.delete('205-12')
        self.assertEqual(None, find(reg_tree.tree, '205-12'))

    def add_section(self, node, subpart_label):
        """ Add a new section to a subpart. """

        existing = find(self.tree, node.label_id())
        if existing and is_reserved_node(existing):
            logging.warning('Replacing reserved node: {0}'.format(node.label_id()))
            self.replace_node_and_subtree(node)
        else:
            subpart = find(self.tree, '-'.join(subpart_label))
            subpart.children = self.add_child(subpart.children, node)

 def test_compile_reg_move_wrong_reg(self):
     """Changes applied to other regulations shouldn't affect the
     regulation we care about, even if that has the same textual prefix"""
     root = self.tree_with_paragraphs()
     notice_changes = {'2055-2-a': [{'action': 'MOVE',
                                    'destination': ['2055', '2', 'b']}]}
     reg = compiler.compile_regulation(root, notice_changes)
     self.assertEqual(find(reg, '205-2-a').text, 'n2a')
     self.assertEqual(find(reg, '205-2-b').text, 'n2b')
     self.assertEqual(find(reg, '2055-2-b'), None)

    def test_delete(self):
        root = self.tree_with_paragraphs()
        reg_tree = compiler.RegulationTree(root)

        self.assertNotEqual(None, find(reg_tree.tree, '205-2-a'))
        reg_tree.delete('205-2-a')
        self.assertEqual(None, find(reg_tree.tree, '205-2-a'))

        # Verify this doesn't cause an error
        reg_tree.delete('205-2-a')

    def test_replace_node_heading(self):
        root = self.tree_with_paragraphs()
        n2a = find(root, "205-2-a")
        n2a.text = "Previous keyterm. Remainder."
        reg_tree = compiler.RegulationTree(root)

        change = {"node": Node(text="Replaced.")}
        reg_tree.replace_node_heading("205-2-a", change)

        changed_node = find(reg_tree.tree, "205-2-a")
        self.assertEqual(changed_node.text, "Replaced. Remainder.")

    def test_replace_node_heading(self):
        root = self.tree_with_paragraphs()
        n2a = find(root, '205-2-a')
        n2a.text = 'Previous keyterm. Remainder.'
        reg_tree = compiler.RegulationTree(root)

        change = {'node': {'text': 'Replaced.'}}
        reg_tree.replace_node_heading('205-2-a', change)

        changed_node = find(reg_tree.tree, '205-2-a')
        self.assertEqual(changed_node.text, 'Replaced. Remainder.')

    def test_move_to_subpart(self):
        sect5, sect7 = Node(label=["111", "5"]), Node(label=["111", "7"])
        sub_a = Node(label=["111", "Subpart", "A"], node_type=Node.SUBPART, children=[sect5])
        sub_b = Node(label=["111", "Subpart", "B"], node_type=Node.SUBPART, children=[sect7])

        root = Node(children=[sub_a, sub_b], label=["111"])
        tree = compiler.RegulationTree(root)
        tree.move_to_subpart("111-5", sub_b.label)
        sub_b = find(tree.tree, "111-Subpart-B")
        sect5, sect7 = find(tree.tree, "111-5"), find(tree.tree, "111-7")
        self.assertEqual([sub_b], tree.tree.children)
        self.assertEqual([sect5, sect7], sub_b.children)

    def test_reserve_existing(self):
        root = self.tree_with_paragraphs()
        reg_tree = compiler.RegulationTree(root)

        before_reserve = find(reg_tree.tree, '205-2-a')
        self.assertNotEqual(before_reserve.text, '[Reserved]')

        n2 = Node('[Reserved]', label=['205', '2'])
        reg_tree.reserve('205-2', n2)
        after_reserve = find(reg_tree.tree, '205-2')
        self.assertEqual(after_reserve.text, '[Reserved]')

        reserve_child = find(reg_tree.tree, '205-2-a')
        self.assertEqual(None, reserve_child)