| 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) |