You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
184 lines
5.0 KiB
Python
184 lines
5.0 KiB
Python
# type: ignore
|
|
|
|
from typing import List, Tuple, Iterable
|
|
from itertools import chain
|
|
from io import BytesIO, BufferedIOBase
|
|
import struct
|
|
|
|
import pytest # type: ignore
|
|
import numpy
|
|
from numpy.testing import assert_equal
|
|
|
|
from .utils import HEADER, FOOTER
|
|
from ..basic import write_uint, write_sint, read_uint, read_sint, write_bstring, write_byte, PathExtensionScheme
|
|
from ..basic import InvalidRecordError, InvalidDataError
|
|
from ..main import OasisLayout
|
|
|
|
|
|
def base_tests(layout: OasisLayout) -> None:
|
|
assert layout.version.string == '1.0'
|
|
assert layout.unit == 1000
|
|
assert layout.validation.checksum_type == 0
|
|
|
|
assert not layout.properties
|
|
assert not layout.propnames
|
|
assert not layout.xnames
|
|
assert not layout.textstrings
|
|
assert not layout.cellnames
|
|
assert not layout.layers
|
|
|
|
assert len(layout.cells) == 1
|
|
assert layout.cells[0].name.string == 'ABCDH'
|
|
assert not layout.cells[0].properties
|
|
|
|
|
|
def write_file_1(buf: BufferedIOBase) -> BufferedIOBase:
|
|
'''
|
|
'''
|
|
buf.write(HEADER)
|
|
|
|
write_uint(buf, 14) # CELL record (explicit)
|
|
write_bstring(buf, b'ABCDH') # Cell name
|
|
|
|
cblock_data = bytes.fromhex('''
|
|
22 00 b0 02 b2 02 13
|
|
a9 66 60 98 c3 32 89 e5 0e e3 1b 61 91 4a c6 15
|
|
ac 8f 58 3a f8 be f0 8a 5a b0 30 57 5f 64 6d e4
|
|
4f bd c8 7a 87 ed 81 f8 02 79 a0 88 68 f5 42 b6
|
|
4e be 80 99 4c 3b 99 35 97 30 4f 14 d7 3c 14 f4
|
|
52 50 e4 24 e3 0b f6 9b c2 1a 9a 27 18 57 4b 8a
|
|
04 ae 65 3f 12 04 24 36 0b 8b 2c f2 e9 14 16 3d
|
|
c6 73 92 4d 64 21 e3 0b 9e cf 9a 15 4f 59 6f 08
|
|
83 cc 5d c8 f8 91 7b 25 7f ea 4e e6 03 3c 5b a4
|
|
66 88 01 85 d8 37 b2 fc 64 bd c8 25 5a 79 92 b1
|
|
99 4b a3 93 65 26 7b 33 bf e6 69 b6 39 7c a9 4b
|
|
40 2e e1 3b 28 a6 79 82 69 41 98 f6 14 ae 60 9b
|
|
d7 4c a2 9a 3d 8c 37 f9 6c 03 3f 32 b6 68 2c 64
|
|
5c cb f3 9a 49 f3 33 e3 0c a6 dd da 29 2f 98 76
|
|
80 d4 73 df 64 f9 cb b3 58 33 60 36 d3 13 d6 9b
|
|
9c b6 9a 3b 98 5f b2 07 2e 64 dc c9 7c 91 4b 24
|
|
f8 08 cb 6e 45 8d 47 32 1d 12 77 b8 81 4a 59 17
|
|
68 6a 1f 60 df 28 ac a9 3d 85 b5 5b b6 62 0a ff
|
|
0c 69 90 7b 36 b3 6c 65 d3 9c c9 f4 40 b1 93 a5
|
|
47 e0 32 7f 8a e6 54 d6 93 6c a2 0f 14 17 c8 03
|
|
00''')
|
|
for byte in cblock_data:
|
|
write_byte(buf, byte)
|
|
|
|
buf.write(FOOTER)
|
|
return buf
|
|
|
|
|
|
def test_file_1() -> None:
|
|
buf = write_file_1(BytesIO())
|
|
|
|
buf.seek(0)
|
|
layout = OasisLayout.read(buf)
|
|
|
|
base_tests(layout)
|
|
|
|
geometry = layout.cells[0].geometry
|
|
assert len(geometry) == 10
|
|
|
|
for ii, gg in enumerate(geometry):
|
|
msg = f'Failed on geometry {ii}'
|
|
assert gg.x == [110, 900, 1520, -370, 1690, -50, 180, 1540, 970, 2160][ii], msg
|
|
assert gg.y == [1270, 890, 2000, 1260, 1420, 850, 860, 750, 1740, 2000][ii], msg
|
|
if ii == 0:
|
|
assert gg.layer == 0, msg
|
|
else:
|
|
assert gg.layer == 1, msg
|
|
assert gg.datatype == 0, msg
|
|
|
|
assert not gg.properties, msg
|
|
assert gg.repetition is None, msg
|
|
|
|
assert geometry[0].height == 530
|
|
assert geometry[0].width == 540
|
|
assert geometry[1].height == 610
|
|
assert geometry[1].width == 680
|
|
|
|
assert_equal(geometry[2].point_list,
|
|
[[-30, -360], [480, -50], [180, 430], [-630, -20]])
|
|
|
|
assert_equal(geometry[3].point_list,
|
|
[[-30, -400],
|
|
[450, 40],
|
|
[70, -220],
|
|
[10, 210],
|
|
[740, -20],
|
|
[0, 660],
|
|
[570, 10],
|
|
[50, 500],
|
|
[630, 20],
|
|
[10, 100],
|
|
[-810, 10],
|
|
[20, -470],
|
|
[-660, 0],
|
|
[20, -470],
|
|
[-620, 10],
|
|
[0, 610],
|
|
[610, -10],
|
|
[0, -100],
|
|
[210, 10],
|
|
[40, 820],
|
|
[-1340, 60],
|
|
[30, -1370]])
|
|
|
|
assert_equal(geometry[4].point_list,
|
|
[[40, -760], [490, -50], [110, 800], [-640, 10]])
|
|
|
|
assert_equal(geometry[5].point_list,
|
|
[[140, -380],
|
|
[340, -10],
|
|
[30, -100],
|
|
[-320, 20],
|
|
[130, -460],
|
|
[-480, -20],
|
|
[-210, 910],
|
|
[370, 40]])
|
|
|
|
assert_equal(geometry[6].point_list,
|
|
[[720, -20],
|
|
[20, 20],
|
|
[690, 0],
|
|
[-10, 650],
|
|
[-20, 30],
|
|
[-90, -10],
|
|
[10, 70],
|
|
[470, -30],
|
|
[20, -120],
|
|
[-320, 0],
|
|
[40, -790],
|
|
[-90, -20],
|
|
[-60, 140],
|
|
[-1390, 50],
|
|
[10, 30]])
|
|
|
|
assert_equal(geometry[7].point_list,
|
|
[[150, -830],
|
|
[-1320, 40],
|
|
[-70, 370],
|
|
[310, -30],
|
|
[10, 220],
|
|
[250, -40],
|
|
[40, -220],
|
|
[340, 10],
|
|
[-20, 290],
|
|
[-1070, 20],
|
|
[0, 230],
|
|
[1380, -60]])
|
|
|
|
assert_equal(geometry[8].point_list,
|
|
[[330, 0], [-10, 480], [620, -20], [-10, 330], [-930, 60], [0, -850]])
|
|
|
|
assert_equal(geometry[9].point_list,
|
|
[[-140, -410],
|
|
[10, -140],
|
|
[270, 0],
|
|
[130, 1030],
|
|
[-500, 50],
|
|
[10, -330],
|
|
[210, -10],
|
|
[10, -190]])
|