File: test_524_block_reference_manager.py

package info (click to toggle)
ezdxf 1.4.1-1
  • links: PTS, VCS
  • area: main
  • in suites: forky, sid, trixie
  • size: 104,528 kB
  • sloc: python: 182,341; makefile: 116; lisp: 20; ansic: 4
file content (186 lines) | stat: -rw-r--r-- 5,624 bytes parent folder | download
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
#  Copyright (c) 2021, Manfred Moitzi
#  License: MIT License

import pytest

import ezdxf
from ezdxf.blkrefs import BlockReferenceCounter, find_unreferenced_blocks


def test_non_exiting_handles_return_0():
    doc = ezdxf.new()
    ref_counter = BlockReferenceCounter(doc)
    assert ref_counter.by_handle("xyz") == 0, "not existing handles should return 0"
    assert ref_counter.by_name("xyz") == 0, "not existing block name should return 0"


def test_access_interface():
    doc = ezdxf.new()
    msp = doc.modelspace()
    block = doc.blocks.new("First")
    msp.add_blockref("First", (0, 0))
    ref_counter = BlockReferenceCounter(doc)
    assert ref_counter.by_handle(block.block_record_handle) == 1
    assert ref_counter.by_name("First") == 1


def test_count_simple_references():
    count = 10
    doc = ezdxf.new()
    doc.blocks.new("First")
    msp = doc.modelspace()
    psp = doc.layout()
    for _ in range(count):
        msp.add_blockref("First", (0, 0))
        psp.add_blockref("First", (0, 0))
    ref_counter = BlockReferenceCounter(doc)
    assert ref_counter.by_name("First") == 20


def test_count_nested_block_references():
    count = 10
    doc = ezdxf.new()
    block1 = doc.blocks.new("First")
    block2 = doc.blocks.new("Second")
    block1.add_blockref(block2.dxf.name, (0, 0))

    msp = doc.modelspace()
    for _ in range(count):
        msp.add_blockref("First", (0, 0))
    ref_counter = BlockReferenceCounter(doc)
    assert ref_counter.by_name("First") == 10
    assert ref_counter.by_name("Second") == 1, "referenced only once in block First"


def test_count_references_used_in_xdata():
    doc = ezdxf.new()
    msp = doc.modelspace()
    block = doc.blocks.new("First")
    handle = block.block_record.dxf.handle
    line = msp.add_line((0, 0), (1, 0))

    # attach XDATA handle to block reference
    line.set_xdata("ezdxf", [(1005, handle)])
    ref_counter = BlockReferenceCounter(doc)
    assert ref_counter.by_handle(handle) == 1


def test_count_references_used_in_app_data():
    doc = ezdxf.new()
    msp = doc.modelspace()
    block = doc.blocks.new("First")
    handle = block.block_record.dxf.handle
    line = msp.add_line((0, 0), (1, 0))

    # attach XDATA handle to block reference
    line.set_app_data("ezdxf", [(320, handle), (480, handle)])
    ref_counter = BlockReferenceCounter(doc)
    assert ref_counter.by_handle(handle) == 2


def test_count_references_used_in_xrecord():
    doc = ezdxf.new()
    block = doc.blocks.new("First")
    handle = block.block_record.dxf.handle
    xrecord = doc.rootdict.add_xrecord("Test")
    xrecord.reset([(320, handle), (330, handle), (480, handle)])

    ref_counter = BlockReferenceCounter(doc)
    assert ref_counter.by_handle(handle) == 3


def test_count_references_in_header_section():
    doc = ezdxf.new()
    doc.blocks.new("Arrow")
    for var_name in ("$DIMBLK", "$DIMBLK1", "$DIMBLK2", "$DIMLDRBLK"):
        doc.header[var_name] = "Arrow"

    ref_counter = BlockReferenceCounter(doc)
    assert ref_counter.by_name("Arrow") == 4


def test_count_references_in_dimstyle():
    doc = ezdxf.new()
    doc.blocks.new("Arrow")
    dimstyle = doc.dimstyles.new("Test")
    dimstyle.dxf.dimblk = "Arrow"
    dimstyle.dxf.dimblk1 = "Arrow"
    dimstyle.dxf.dimblk2 = "Arrow"
    dimstyle.dxf.dimldrblk = "Arrow"

    ref_counter = BlockReferenceCounter(doc)
    assert ref_counter.by_name("Arrow") == 4


def test_count_references_in_leader():
    doc = ezdxf.new()
    doc.blocks.new("Arrow")
    msp = doc.modelspace()
    msp.add_leader(
        vertices=[(0, 0), (1, 0)],
        override={
            "dimblk": "Arrow",  # ignored by LEADER
            "dimblk1": "Arrow",  # ignored by LEADER
            "dimblk2": "Arrow",  # ignored by LEADER
            "dimldrblk": "Arrow",  # stored in XDATA
        },
    )

    ref_counter = BlockReferenceCounter(doc)
    assert ref_counter.by_name("Arrow") == 1


def test_count_references_for_anonymous_dimension_block():
    doc = ezdxf.new()
    msp = doc.modelspace()
    dim = msp.add_linear_dim(
        base=(25, 10),
        p1=(0, 0),
        p2=(50, 0),
    )
    dim.render()
    ref_counter = BlockReferenceCounter(doc)
    assert ref_counter.by_name(dim.dimension.dxf.geometry) == 1


def test_count_references_in_mleader_style():
    doc = ezdxf.new()
    arrow = doc.blocks.new("Arrow")
    arrow_handle = arrow.block_record.dxf.handle
    block = doc.blocks.new("Block")
    block_handle = block.block_record.dxf.handle
    mleader_style = doc.mleader_styles.new("Test")
    mleader_style.dxf.arrow_head_handle = arrow_handle
    mleader_style.dxf.block_record_handle = block_handle

    ref_counter = BlockReferenceCounter(doc)
    assert ref_counter.by_handle(arrow_handle) == 1
    assert ref_counter.by_handle(block_handle) == 1


class TestFindUnreferencedBlocks:
    def test_empty_document_has_no_unreferenced_blocks(self):
        doc = ezdxf.new()

        assert len(find_unreferenced_blocks(doc)) == 0

    def test_add_unreferenced_block(self):
        doc = ezdxf.new()
        doc.blocks.new("DUMMY")

        names = find_unreferenced_blocks(doc)
        assert len(names) == 1, "one unreferenced block expected"
        assert "DUMMY" in names, "name of unreferenced block expected"

    def test_add_referenced_block(self):
        doc = ezdxf.new()
        doc.blocks.new("DUMMY")
        msp = doc.modelspace()
        msp.add_blockref("DUMMY", (0, 0))

        names = find_unreferenced_blocks(doc)
        assert len(names) == 0, "no unreferenced block expected"


if __name__ == "__main__":
    pytest.main([__file__])