Debian Codegraph @

tests/gis_tests/geos_tests/test_io.py

raw
1 import binascii
2
3 from django.contrib.gis.geos import (
4 GEOSGeometry,
5 Point,
6 Polygon,
7 WKBReader,
8 WKBWriter,
9 WKTReader,
10 WKTWriter,
11 )
12 from django.contrib.gis.geos.libgeos import geos_version_tuple
13 from django.test import SimpleTestCase
14
15
16 class GEOSIOTest(SimpleTestCase):
17 def test01_wktreader(self):
18 # Creating a WKTReader instance
19 wkt_r = WKTReader()
20 wkt = "POINT (5 23)"
21
22 # read() should return a GEOSGeometry
23 ref = GEOSGeometry(wkt)
24 g1 = wkt_r.read(wkt.encode())
25 g2 = wkt_r.read(wkt)
26
27 for geom in (g1, g2):
28 self.assertEqual(ref, geom)
29
30 # Should only accept string objects.
31 with self.assertRaises(TypeError):
32 wkt_r.read(1)
33 with self.assertRaises(TypeError):
34 wkt_r.read(memoryview(b"foo"))
35
36 def test02_wktwriter(self):
37 # Creating a WKTWriter instance, testing its ptr property.
38 wkt_w = WKTWriter()
39 with self.assertRaises(TypeError):
40 wkt_w.ptr = WKTReader.ptr_type()
41
42 ref = GEOSGeometry("POINT (5 23)")
43 ref_wkt = "POINT (5.0000000000000000 23.0000000000000000)"
44 self.assertEqual(ref_wkt, wkt_w.write(ref).decode())
45
46 def test_wktwriter_constructor_arguments(self):
47 wkt_w = WKTWriter(dim=3, trim=True, precision=3)
48 ref = GEOSGeometry("POINT (5.34562 23 1.5)")
49 if geos_version_tuple() > (3, 10):
50 ref_wkt = "POINT Z (5.346 23 1.5)"
51 else:
52 ref_wkt = "POINT Z (5.35 23 1.5)"
53 self.assertEqual(ref_wkt, wkt_w.write(ref).decode())
54
55 def test03_wkbreader(self):
56 # Creating a WKBReader instance
57 wkb_r = WKBReader()
58
59 hex_bin = b"000000000140140000000000004037000000000000"
60 hex_str = "000000000140140000000000004037000000000000"
61 wkb = memoryview(binascii.a2b_hex(hex_bin))
62 ref = GEOSGeometry(hex_bin)
63
64 # read() should return a GEOSGeometry on either a hex string or
65 # a WKB buffer.
66 g1 = wkb_r.read(wkb)
67 g2 = wkb_r.read(hex_bin)
68 g3 = wkb_r.read(hex_str)
69 for geom in (g1, g2, g3):
70 self.assertEqual(ref, geom)
71
72 bad_input = (1, 5.23, None, False)
73 for bad_wkb in bad_input:
74 with self.assertRaises(TypeError):
75 wkb_r.read(bad_wkb)
76
77 def test04_wkbwriter(self):
78 wkb_w = WKBWriter()
79
80 # Representations of 'POINT (5 23)' in hex -- one normal and
81 # the other with the byte order changed.
82 g = GEOSGeometry("POINT (5 23)")
83 hex1 = b"010100000000000000000014400000000000003740"
84 wkb1 = memoryview(binascii.a2b_hex(hex1))
85 hex2 = b"000000000140140000000000004037000000000000"
86 wkb2 = memoryview(binascii.a2b_hex(hex2))
87
88 self.assertEqual(hex1, wkb_w.write_hex(g))
89 self.assertEqual(wkb1, wkb_w.write(g))
90
91 # Ensuring bad byteorders are not accepted.
92 for bad_byteorder in (-1, 2, 523, "foo", None):
93 # Equivalent of `wkb_w.byteorder = bad_byteorder`
94 with self.assertRaises(ValueError):
95 wkb_w._set_byteorder(bad_byteorder)
96
97 # Setting the byteorder to 0 (for Big Endian)
98 wkb_w.byteorder = 0
99 self.assertEqual(hex2, wkb_w.write_hex(g))
100 self.assertEqual(wkb2, wkb_w.write(g))
101
102 # Back to Little Endian
103 wkb_w.byteorder = 1
104
105 # Now, trying out the 3D and SRID flags.
106 g = GEOSGeometry("POINT (5 23 17)")
107 g.srid = 4326
108
109 hex3d = b"0101000080000000000000144000000000000037400000000000003140"
110 wkb3d = memoryview(binascii.a2b_hex(hex3d))
111 hex3d_srid = (
112 b"01010000A0E6100000000000000000144000000000000037400000000000003140"
113 )
114 wkb3d_srid = memoryview(binascii.a2b_hex(hex3d_srid))
115
116 # Ensuring bad output dimensions are not accepted
117 for bad_outdim in (-1, 0, 1, 4, 423, "foo", None):
118 with self.assertRaisesMessage(
119 ValueError, "WKB output dimension must be 2 or 3"
120 ):
121 wkb_w.outdim = bad_outdim
122
123 # Now setting the output dimensions to be 3
124 wkb_w.outdim = 3
125
126 self.assertEqual(hex3d, wkb_w.write_hex(g))
127 self.assertEqual(wkb3d, wkb_w.write(g))
128
129 # Telling the WKBWriter to include the srid in the representation.
130 wkb_w.srid = True
131 self.assertEqual(hex3d_srid, wkb_w.write_hex(g))
132 self.assertEqual(wkb3d_srid, wkb_w.write(g))
133
134 def test_wkt_writer_trim(self):
135 wkt_w = WKTWriter()
136 self.assertFalse(wkt_w.trim)
137 self.assertEqual(
138 wkt_w.write(Point(1, 1)), b"POINT (1.0000000000000000 1.0000000000000000)"
139 )
140
141 wkt_w.trim = True
142 self.assertTrue(wkt_w.trim)
143 self.assertEqual(wkt_w.write(Point(1, 1)), b"POINT (1 1)")
144 self.assertEqual(wkt_w.write(Point(1.1, 1)), b"POINT (1.1 1)")
145 self.assertEqual(
146 wkt_w.write(Point(1.0 / 3, 1)), b"POINT (0.3333333333333333 1)"
147 )
148
149 wkt_w.trim = False
150 self.assertFalse(wkt_w.trim)
151 self.assertEqual(
152 wkt_w.write(Point(1, 1)), b"POINT (1.0000000000000000 1.0000000000000000)"
153 )
154
155 def test_wkt_writer_precision(self):
156 wkt_w = WKTWriter()
157 self.assertIsNone(wkt_w.precision)
158 self.assertEqual(
159 wkt_w.write(Point(1.0 / 3, 2.0 / 3)),
160 b"POINT (0.3333333333333333 0.6666666666666666)",
161 )
162
163 wkt_w.precision = 1
164 self.assertEqual(wkt_w.precision, 1)
165 self.assertEqual(wkt_w.write(Point(1.0 / 3, 2.0 / 3)), b"POINT (0.3 0.7)")
166
167 wkt_w.precision = 0
168 self.assertEqual(wkt_w.precision, 0)
169 self.assertEqual(wkt_w.write(Point(1.0 / 3, 2.0 / 3)), b"POINT (0 1)")
170
171 wkt_w.precision = None
172 self.assertIsNone(wkt_w.precision)
173 self.assertEqual(
174 wkt_w.write(Point(1.0 / 3, 2.0 / 3)),
175 b"POINT (0.3333333333333333 0.6666666666666666)",
176 )
177
178 with self.assertRaisesMessage(
179 AttributeError, "WKT output rounding precision must be "
180 ):
181 wkt_w.precision = "potato"
182
183 def test_empty_point_wkb(self):
184 p = Point(srid=4326)
185 wkb_w = WKBWriter()
186
187 wkb_w.srid = False
188 with self.assertRaisesMessage(
189 ValueError, "Empty point is not representable in WKB."
190 ):
191 wkb_w.write(p)
192 with self.assertRaisesMessage(
193 ValueError, "Empty point is not representable in WKB."
194 ):
195 wkb_w.write_hex(p)
196
197 wkb_w.srid = True
198 for byteorder, hex in enumerate(
199 [
200 b"0020000001000010E67FF80000000000007FF8000000000000",
201 b"0101000020E6100000000000000000F87F000000000000F87F",
202 ]
203 ):
204 wkb_w.byteorder = byteorder
205 self.assertEqual(wkb_w.write_hex(p), hex)
206 self.assertEqual(GEOSGeometry(wkb_w.write_hex(p)), p)
207 self.assertEqual(wkb_w.write(p), memoryview(binascii.a2b_hex(hex)))
208 self.assertEqual(GEOSGeometry(wkb_w.write(p)), p)
209
210 def test_empty_polygon_wkb(self):
211 p = Polygon(srid=4326)
212 p_no_srid = Polygon()
213 wkb_w = WKBWriter()
214 wkb_w.srid = True
215 for byteorder, hexes in enumerate(
216 [
217 (b"000000000300000000", b"0020000003000010E600000000"),
218 (b"010300000000000000", b"0103000020E610000000000000"),
219 ]
220 ):
221 wkb_w.byteorder = byteorder
222 for srid, hex in enumerate(hexes):
223 wkb_w.srid = srid
224 self.assertEqual(wkb_w.write_hex(p), hex)
225 self.assertEqual(
226 GEOSGeometry(wkb_w.write_hex(p)), p if srid else p_no_srid
227 )
228 self.assertEqual(wkb_w.write(p), memoryview(binascii.a2b_hex(hex)))
229 self.assertEqual(GEOSGeometry(wkb_w.write(p)), p if srid else p_no_srid)