mirror of
https://github.com/django/django.git
synced 2025-08-21 01:09:13 +00:00
Used assertRaisesMessage and subTest where appropriate in GEOS tests.
This commit is contained in:
David Smith
nessita
parent
896fa85b02
commit
ef42718a2b
@ -11,12 +11,12 @@
|
||||
{"wkt": "MULTIPOLYGON (((180 60, 240 160, 300 60, 180 60)), ((80 80, 180 60, 160 140, 240 160, 360 140, 300 60, 420 100, 320 280, 120 260, 80 80)))", "valid": true, "num_geom": 2, "n_p": 14}
|
||||
],
|
||||
"errors": [
|
||||
{"wkt": "GEOMETR##!@#%#............a32515", "bad": true, "hex": false},
|
||||
{"wkt": "Foo.Bar", "bad": true, "hex": false},
|
||||
{"wkt": "POINT (5, 23)", "bad": true, "hex": false},
|
||||
{"wkt": "AAABBBDDDAAD##@#1113511111-098111111111111111533333333333333", "bad": true, "hex": true},
|
||||
{"wkt": "FFFFFFFFFFFFFFFFF1355555555555555555565111", "bad": true, "hex": true},
|
||||
{"wkt": "", "bad": true, "hex": false}
|
||||
{"wkt": "GEOMETR##!@#%#............a32515", "bad": true, "hex": false, "msg": "String input unrecognized as WKT EWKT, and HEXEWKB."},
|
||||
{"wkt": "Foo.Bar", "bad": true, "hex": false, "msg": "String input unrecognized as WKT EWKT, and HEXEWKB."},
|
||||
{"wkt": "POINT (5, 23)", "bad": true, "hex": false, "msg": "Error encountered checking Geometry returned from GEOS C function \"GEOSWKTReader_read_r\"."},
|
||||
{"wkt": "AAABBBDDDAAD##@#1113511111-098111111111111111533333333333333", "bad": true, "hex": true, "msg": "String input unrecognized as WKT EWKT, and HEXEWKB."},
|
||||
{"wkt": "FFFFFFFFFFFFFFFFF1355555555555555555565111", "bad": true, "hex": true, "msg": "Error encountered checking Geometry returned from GEOS C function \"GEOSWKBReader_readHEX_r\"."},
|
||||
{"wkt": "", "bad": true, "hex": false, "msg": "String input unrecognized as WKT EWKT, and HEXEWKB."}
|
||||
],
|
||||
"wkt_out": [
|
||||
{"wkt": "POINT (110 130)", "ewkt": "POINT (110 130)", "kml": "<Point><coordinates>110.0,130.0,0</coordinates></Point>", "gml": "<gml:Point><gml:coordinates>110,130</gml:coordinates></gml:Point>"},
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -2,8 +2,6 @@
|
||||
# Modified from original contribution by Aryeh Leib Taurog, which was
|
||||
# released under the New BSD license.
|
||||
|
||||
import unittest
|
||||
|
||||
from django.contrib.gis.geos import (
|
||||
LinearRing,
|
||||
LineString,
|
||||
@ -12,6 +10,7 @@ from django.contrib.gis.geos import (
|
||||
Polygon,
|
||||
fromstr,
|
||||
)
|
||||
from django.test import SimpleTestCase
|
||||
|
||||
|
||||
def api_get_distance(x):
|
||||
@ -77,7 +76,7 @@ geos_function_tests = [
|
||||
]
|
||||
|
||||
|
||||
class GEOSMutationTest(unittest.TestCase):
|
||||
class GEOSMutationTest(SimpleTestCase):
|
||||
"""
|
||||
Tests Pythonic Mutability of Python GEOS geometry wrappers
|
||||
get/set/delitem on a slice, normal list methods
|
||||
@ -87,33 +86,41 @@ class GEOSMutationTest(unittest.TestCase):
|
||||
"Testing Geometry IndexError"
|
||||
p = Point(1, 2)
|
||||
for i in range(-2, 2):
|
||||
p._checkindex(i)
|
||||
with self.assertRaises(IndexError):
|
||||
p._checkindex(2)
|
||||
with self.assertRaises(IndexError):
|
||||
p._checkindex(-3)
|
||||
with self.subTest(i=i):
|
||||
p._checkindex(i)
|
||||
|
||||
for i in (2, -3):
|
||||
with (
|
||||
self.subTest(i=i),
|
||||
self.assertRaisesMessage(IndexError, f"invalid index: {i}"),
|
||||
):
|
||||
p._checkindex(i)
|
||||
|
||||
def test01_PointMutations(self):
|
||||
"Testing Point mutations"
|
||||
for p in (Point(1, 2, 3), fromstr("POINT (1 2 3)")):
|
||||
self.assertEqual(
|
||||
p._get_single_external(1), 2.0, "Point _get_single_external"
|
||||
)
|
||||
with self.subTest(p=p):
|
||||
self.assertEqual(
|
||||
p._get_single_external(1), 2.0, "Point _get_single_external"
|
||||
)
|
||||
|
||||
# _set_single
|
||||
p._set_single(0, 100)
|
||||
self.assertEqual(p.coords, (100.0, 2.0, 3.0), "Point _set_single")
|
||||
# _set_single
|
||||
p._set_single(0, 100)
|
||||
self.assertEqual(p.coords, (100.0, 2.0, 3.0), "Point _set_single")
|
||||
|
||||
# _set_list
|
||||
p._set_list(2, (50, 3141))
|
||||
self.assertEqual(p.coords, (50.0, 3141.0), "Point _set_list")
|
||||
# _set_list
|
||||
p._set_list(2, (50, 3141))
|
||||
self.assertEqual(p.coords, (50.0, 3141.0), "Point _set_list")
|
||||
|
||||
def test02_PointExceptions(self):
|
||||
"Testing Point exceptions"
|
||||
with self.assertRaises(TypeError):
|
||||
Point(range(1))
|
||||
with self.assertRaises(TypeError):
|
||||
Point(range(4))
|
||||
msg = "Invalid parameters given for Point initialization."
|
||||
for i in (range(1), range(4)):
|
||||
with (
|
||||
self.subTest(i=i),
|
||||
self.assertRaisesMessage(TypeError, msg),
|
||||
):
|
||||
Point(i)
|
||||
|
||||
def test03_PointApi(self):
|
||||
"Testing Point API"
|
||||
@ -121,7 +128,8 @@ class GEOSMutationTest(unittest.TestCase):
|
||||
for p in (Point(1, 2, 3), fromstr("POINT (1 2 3)")):
|
||||
p[0:2] = [4, 5]
|
||||
for f in geos_function_tests:
|
||||
self.assertEqual(f(q), f(p), "Point " + f.__name__)
|
||||
with self.subTest(p=p, f=f):
|
||||
self.assertEqual(f(q), f(p), "Point " + f.__name__)
|
||||
|
||||
def test04_LineStringMutations(self):
|
||||
"Testing LineString mutations"
|
||||
@ -129,29 +137,31 @@ class GEOSMutationTest(unittest.TestCase):
|
||||
LineString((1, 0), (4, 1), (6, -1)),
|
||||
fromstr("LINESTRING (1 0,4 1,6 -1)"),
|
||||
):
|
||||
self.assertEqual(
|
||||
ls._get_single_external(1),
|
||||
(4.0, 1.0),
|
||||
"LineString _get_single_external",
|
||||
)
|
||||
with self.subTest(ls=ls):
|
||||
self.assertEqual(
|
||||
ls._get_single_external(1),
|
||||
(4.0, 1.0),
|
||||
"LineString _get_single_external",
|
||||
)
|
||||
|
||||
# _set_single
|
||||
ls._set_single(0, (-50, 25))
|
||||
self.assertEqual(
|
||||
ls.coords,
|
||||
((-50.0, 25.0), (4.0, 1.0), (6.0, -1.0)),
|
||||
"LineString _set_single",
|
||||
)
|
||||
# _set_single
|
||||
ls._set_single(0, (-50, 25))
|
||||
self.assertEqual(
|
||||
ls.coords,
|
||||
((-50.0, 25.0), (4.0, 1.0), (6.0, -1.0)),
|
||||
"LineString _set_single",
|
||||
)
|
||||
|
||||
# _set_list
|
||||
ls._set_list(2, ((-50.0, 25.0), (6.0, -1.0)))
|
||||
self.assertEqual(
|
||||
ls.coords, ((-50.0, 25.0), (6.0, -1.0)), "LineString _set_list"
|
||||
)
|
||||
# _set_list
|
||||
ls._set_list(2, ((-50.0, 25.0), (6.0, -1.0)))
|
||||
self.assertEqual(
|
||||
ls.coords, ((-50.0, 25.0), (6.0, -1.0)), "LineString _set_list"
|
||||
)
|
||||
|
||||
lsa = LineString(ls.coords)
|
||||
for f in geos_function_tests:
|
||||
self.assertEqual(f(lsa), f(ls), "LineString " + f.__name__)
|
||||
lsa = LineString(ls.coords)
|
||||
for f in geos_function_tests:
|
||||
with self.subTest(f=f):
|
||||
self.assertEqual(f(lsa), f(ls), "LineString " + f.__name__)
|
||||
|
||||
def test05_Polygon(self):
|
||||
"Testing Polygon mutations"
|
||||
@ -162,37 +172,45 @@ class GEOSMutationTest(unittest.TestCase):
|
||||
),
|
||||
fromstr("POLYGON ((1 0,4 1,6 -1,8 10,1 0),(5 4,6 4,6 3,5 4))"),
|
||||
):
|
||||
self.assertEqual(
|
||||
pg._get_single_external(0),
|
||||
LinearRing((1, 0), (4, 1), (6, -1), (8, 10), (1, 0)),
|
||||
"Polygon _get_single_external(0)",
|
||||
)
|
||||
self.assertEqual(
|
||||
pg._get_single_external(1),
|
||||
LinearRing((5, 4), (6, 4), (6, 3), (5, 4)),
|
||||
"Polygon _get_single_external(1)",
|
||||
)
|
||||
with self.subTest(pg=pg):
|
||||
self.assertEqual(
|
||||
pg._get_single_external(0),
|
||||
LinearRing((1, 0), (4, 1), (6, -1), (8, 10), (1, 0)),
|
||||
"Polygon _get_single_external(0)",
|
||||
)
|
||||
self.assertEqual(
|
||||
pg._get_single_external(1),
|
||||
LinearRing((5, 4), (6, 4), (6, 3), (5, 4)),
|
||||
"Polygon _get_single_external(1)",
|
||||
)
|
||||
|
||||
# _set_list
|
||||
pg._set_list(
|
||||
2,
|
||||
(
|
||||
((1, 2), (10, 0), (12, 9), (-1, 15), (1, 2)),
|
||||
((4, 2), (5, 2), (5, 3), (4, 2)),
|
||||
),
|
||||
)
|
||||
self.assertEqual(
|
||||
pg.coords,
|
||||
(
|
||||
((1.0, 2.0), (10.0, 0.0), (12.0, 9.0), (-1.0, 15.0), (1.0, 2.0)),
|
||||
((4.0, 2.0), (5.0, 2.0), (5.0, 3.0), (4.0, 2.0)),
|
||||
),
|
||||
"Polygon _set_list",
|
||||
)
|
||||
# _set_list
|
||||
pg._set_list(
|
||||
2,
|
||||
(
|
||||
((1, 2), (10, 0), (12, 9), (-1, 15), (1, 2)),
|
||||
((4, 2), (5, 2), (5, 3), (4, 2)),
|
||||
),
|
||||
)
|
||||
self.assertEqual(
|
||||
pg.coords,
|
||||
(
|
||||
(
|
||||
(1.0, 2.0),
|
||||
(10.0, 0.0),
|
||||
(12.0, 9.0),
|
||||
(-1.0, 15.0),
|
||||
(1.0, 2.0),
|
||||
),
|
||||
((4.0, 2.0), (5.0, 2.0), (5.0, 3.0), (4.0, 2.0)),
|
||||
),
|
||||
"Polygon _set_list",
|
||||
)
|
||||
|
||||
lsa = Polygon(*pg.coords)
|
||||
for f in geos_function_tests:
|
||||
self.assertEqual(f(lsa), f(pg), "Polygon " + f.__name__)
|
||||
lsa = Polygon(*pg.coords)
|
||||
for f in geos_function_tests:
|
||||
with self.subTest(f=f):
|
||||
self.assertEqual(f(lsa), f(pg), "Polygon " + f.__name__)
|
||||
|
||||
def test06_Collection(self):
|
||||
"Testing Collection mutations"
|
||||
@ -201,17 +219,21 @@ class GEOSMutationTest(unittest.TestCase):
|
||||
fromstr("MULTIPOINT (3 4,-1 2,5 -4,2 8)"),
|
||||
)
|
||||
for mp in points:
|
||||
self.assertEqual(
|
||||
mp._get_single_external(2),
|
||||
Point(5, -4),
|
||||
"Collection _get_single_external",
|
||||
)
|
||||
with self.subTest(mp=mp):
|
||||
self.assertEqual(
|
||||
mp._get_single_external(2),
|
||||
Point(5, -4),
|
||||
"Collection _get_single_external",
|
||||
)
|
||||
|
||||
mp._set_list(3, map(Point, ((5, 5), (3, -2), (8, 1))))
|
||||
self.assertEqual(
|
||||
mp.coords, ((5.0, 5.0), (3.0, -2.0), (8.0, 1.0)), "Collection _set_list"
|
||||
)
|
||||
mp._set_list(3, map(Point, ((5, 5), (3, -2), (8, 1))))
|
||||
self.assertEqual(
|
||||
mp.coords,
|
||||
((5.0, 5.0), (3.0, -2.0), (8.0, 1.0)),
|
||||
"Collection _set_list",
|
||||
)
|
||||
|
||||
lsa = MultiPoint(*map(Point, ((5, 5), (3, -2), (8, 1))))
|
||||
for f in geos_function_tests:
|
||||
self.assertEqual(f(lsa), f(mp), "MultiPoint " + f.__name__)
|
||||
lsa = MultiPoint(*map(Point, ((5, 5), (3, -2), (8, 1))))
|
||||
for f in geos_function_tests:
|
||||
with self.subTest(f=f):
|
||||
self.assertEqual(f(lsa), f(mp), "MultiPoint " + f.__name__)
|
||||
|
||||
@ -25,7 +25,8 @@ class GEOSIOTest(SimpleTestCase):
|
||||
g2 = wkt_r.read(wkt)
|
||||
|
||||
for geom in (g1, g2):
|
||||
self.assertEqual(ref, geom)
|
||||
with self.subTest(geom=geom):
|
||||
self.assertEqual(ref, geom)
|
||||
|
||||
# Should only accept string objects.
|
||||
with self.assertRaises(TypeError):
|
||||
@ -67,7 +68,8 @@ class GEOSIOTest(SimpleTestCase):
|
||||
g2 = wkb_r.read(hex_bin)
|
||||
g3 = wkb_r.read(hex_str)
|
||||
for geom in (g1, g2, g3):
|
||||
self.assertEqual(ref, geom)
|
||||
with self.subTest(geom=geom):
|
||||
self.assertEqual(ref, geom)
|
||||
|
||||
bad_input = (1, 5.23, None, False)
|
||||
for bad_wkb in bad_input:
|
||||
@ -89,9 +91,13 @@ class GEOSIOTest(SimpleTestCase):
|
||||
self.assertEqual(wkb1, wkb_w.write(g))
|
||||
|
||||
# Ensuring bad byteorders are not accepted.
|
||||
msg = "Byte order parameter must be 0 (Big Endian) or 1 (Little Endian)."
|
||||
for bad_byteorder in (-1, 2, 523, "foo", None):
|
||||
# Equivalent of `wkb_w.byteorder = bad_byteorder`
|
||||
with self.assertRaises(ValueError):
|
||||
with (
|
||||
self.subTest(bad_byteorder=bad_byteorder),
|
||||
self.assertRaisesMessage(ValueError, msg),
|
||||
):
|
||||
wkb_w._set_byteorder(bad_byteorder)
|
||||
|
||||
# Setting the byteorder to 0 (for Big Endian)
|
||||
@ -114,9 +120,11 @@ class GEOSIOTest(SimpleTestCase):
|
||||
wkb3d_srid = memoryview(binascii.a2b_hex(hex3d_srid))
|
||||
|
||||
# Ensuring bad output dimensions are not accepted
|
||||
msg = "WKB output dimension must be 2 or 3"
|
||||
for bad_outdim in (-1, 0, 1, 4, 423, "foo", None):
|
||||
with self.assertRaisesMessage(
|
||||
ValueError, "WKB output dimension must be 2 or 3"
|
||||
with (
|
||||
self.subTest(bad_outdim=bad_outdim),
|
||||
self.assertRaisesMessage(ValueError, msg),
|
||||
):
|
||||
wkb_w.outdim = bad_outdim
|
||||
|
||||
@ -221,9 +229,12 @@ class GEOSIOTest(SimpleTestCase):
|
||||
wkb_w.byteorder = byteorder
|
||||
for srid, hex in enumerate(hexes):
|
||||
wkb_w.srid = srid
|
||||
self.assertEqual(wkb_w.write_hex(p), hex)
|
||||
self.assertEqual(
|
||||
GEOSGeometry(wkb_w.write_hex(p)), p if srid else p_no_srid
|
||||
)
|
||||
self.assertEqual(wkb_w.write(p), memoryview(binascii.a2b_hex(hex)))
|
||||
self.assertEqual(GEOSGeometry(wkb_w.write(p)), p if srid else p_no_srid)
|
||||
with self.subTest(byteorder=byteorder, hexes=hexes):
|
||||
self.assertEqual(wkb_w.write_hex(p), hex)
|
||||
self.assertEqual(
|
||||
GEOSGeometry(wkb_w.write_hex(p)), p if srid else p_no_srid
|
||||
)
|
||||
self.assertEqual(wkb_w.write(p), memoryview(binascii.a2b_hex(hex)))
|
||||
self.assertEqual(
|
||||
GEOSGeometry(wkb_w.write(p)), p if srid else p_no_srid
|
||||
)
|
||||
|
||||
@ -4,9 +4,8 @@
|
||||
# Modified from original contribution by Aryeh Leib Taurog, which was
|
||||
# released under the New BSD license.
|
||||
|
||||
import unittest
|
||||
|
||||
from django.contrib.gis.geos.mutable_list import ListMixin
|
||||
from django.test import SimpleTestCase
|
||||
|
||||
|
||||
class UserListA(ListMixin):
|
||||
@ -54,7 +53,7 @@ def nextRange(length):
|
||||
nextRange.start = 0
|
||||
|
||||
|
||||
class ListMixinTest(unittest.TestCase):
|
||||
class ListMixinTest(SimpleTestCase):
|
||||
"""
|
||||
Tests base class ListMixin by comparing a list clone which is
|
||||
a ListMixin subclass with a real Python list.
|
||||
@ -79,22 +78,24 @@ class ListMixinTest(unittest.TestCase):
|
||||
"Slice retrieval"
|
||||
pl, ul = self.lists_of_len()
|
||||
for i in self.limits_plus(1):
|
||||
self.assertEqual(pl[i:], ul[i:], "slice [%d:]" % (i))
|
||||
self.assertEqual(pl[:i], ul[:i], "slice [:%d]" % (i))
|
||||
with self.subTest(i=i):
|
||||
self.assertEqual(pl[i:], ul[i:], "slice [%d:]" % (i))
|
||||
self.assertEqual(pl[:i], ul[:i], "slice [:%d]" % (i))
|
||||
|
||||
for j in self.limits_plus(1):
|
||||
self.assertEqual(pl[i:j], ul[i:j], "slice [%d:%d]" % (i, j))
|
||||
for k in self.step_range():
|
||||
self.assertEqual(
|
||||
pl[i:j:k], ul[i:j:k], "slice [%d:%d:%d]" % (i, j, k)
|
||||
)
|
||||
|
||||
for j in self.limits_plus(1):
|
||||
self.assertEqual(pl[i:j], ul[i:j], "slice [%d:%d]" % (i, j))
|
||||
for k in self.step_range():
|
||||
self.assertEqual(
|
||||
pl[i:j:k], ul[i:j:k], "slice [%d:%d:%d]" % (i, j, k)
|
||||
)
|
||||
|
||||
for k in self.step_range():
|
||||
self.assertEqual(pl[i::k], ul[i::k], "slice [%d::%d]" % (i, k))
|
||||
self.assertEqual(pl[:i:k], ul[:i:k], "slice [:%d:%d]" % (i, k))
|
||||
self.assertEqual(pl[i::k], ul[i::k], "slice [%d::%d]" % (i, k))
|
||||
self.assertEqual(pl[:i:k], ul[:i:k], "slice [:%d:%d]" % (i, k))
|
||||
|
||||
for k in self.step_range():
|
||||
self.assertEqual(pl[::k], ul[::k], "slice [::%d]" % (k))
|
||||
with self.subTest(k=k):
|
||||
self.assertEqual(pl[::k], ul[::k], "slice [::%d]" % (k))
|
||||
|
||||
def test02_setslice(self):
|
||||
"Slice assignment"
|
||||
@ -105,120 +106,135 @@ class ListMixinTest(unittest.TestCase):
|
||||
pl, ul = self.lists_of_len()
|
||||
for slen in range(self.limit + 1):
|
||||
ssl = nextRange(slen)
|
||||
ul[:] = ssl
|
||||
pl[:] = ssl
|
||||
self.assertEqual(pl, ul[:], "set slice [:]")
|
||||
with self.subTest(slen=slen):
|
||||
ul[:] = ssl
|
||||
pl[:] = ssl
|
||||
self.assertEqual(pl, ul[:], "set slice [:]")
|
||||
|
||||
for i in self.limits_plus(1):
|
||||
ssl = nextRange(slen)
|
||||
ul[i:] = ssl
|
||||
pl[i:] = ssl
|
||||
self.assertEqual(pl, ul[:], "set slice [%d:]" % (i))
|
||||
|
||||
ssl = nextRange(slen)
|
||||
ul[:i] = ssl
|
||||
pl[:i] = ssl
|
||||
self.assertEqual(pl, ul[:], "set slice [:%d]" % (i))
|
||||
|
||||
for j in self.limits_plus(1):
|
||||
for i in self.limits_plus(1):
|
||||
ssl = nextRange(slen)
|
||||
ul[i:j] = ssl
|
||||
pl[i:j] = ssl
|
||||
self.assertEqual(pl, ul[:], "set slice [%d:%d]" % (i, j))
|
||||
ul[i:] = ssl
|
||||
pl[i:] = ssl
|
||||
self.assertEqual(pl, ul[:], "set slice [%d:]" % (i))
|
||||
|
||||
ssl = nextRange(slen)
|
||||
ul[:i] = ssl
|
||||
pl[:i] = ssl
|
||||
self.assertEqual(pl, ul[:], "set slice [:%d]" % (i))
|
||||
|
||||
for j in self.limits_plus(1):
|
||||
ssl = nextRange(slen)
|
||||
ul[i:j] = ssl
|
||||
pl[i:j] = ssl
|
||||
self.assertEqual(pl, ul[:], "set slice [%d:%d]" % (i, j))
|
||||
|
||||
for k in self.step_range():
|
||||
ssl = nextRange(len(ul[i:j:k]))
|
||||
ul[i:j:k] = ssl
|
||||
pl[i:j:k] = ssl
|
||||
self.assertEqual(
|
||||
pl, ul[:], "set slice [%d:%d:%d]" % (i, j, k)
|
||||
)
|
||||
|
||||
sliceLen = len(ul[i:j:k])
|
||||
msg = (
|
||||
f"attempt to assign sequence of size {sliceLen + 1} "
|
||||
f"to extended slice of size {sliceLen}"
|
||||
)
|
||||
with self.assertRaisesMessage(ValueError, msg):
|
||||
setfcn(ul, i, j, k, sliceLen + 1)
|
||||
if sliceLen > 2:
|
||||
msg = (
|
||||
f"attempt to assign sequence of size {sliceLen - 1}"
|
||||
f" to extended slice of size {sliceLen}"
|
||||
)
|
||||
with self.assertRaisesMessage(ValueError, msg):
|
||||
setfcn(ul, i, j, k, sliceLen - 1)
|
||||
|
||||
for k in self.step_range():
|
||||
ssl = nextRange(len(ul[i:j:k]))
|
||||
ul[i:j:k] = ssl
|
||||
pl[i:j:k] = ssl
|
||||
self.assertEqual(pl, ul[:], "set slice [%d:%d:%d]" % (i, j, k))
|
||||
ssl = nextRange(len(ul[i::k]))
|
||||
ul[i::k] = ssl
|
||||
pl[i::k] = ssl
|
||||
self.assertEqual(pl, ul[:], "set slice [%d::%d]" % (i, k))
|
||||
|
||||
sliceLen = len(ul[i:j:k])
|
||||
with self.assertRaises(ValueError):
|
||||
setfcn(ul, i, j, k, sliceLen + 1)
|
||||
if sliceLen > 2:
|
||||
with self.assertRaises(ValueError):
|
||||
setfcn(ul, i, j, k, sliceLen - 1)
|
||||
ssl = nextRange(len(ul[:i:k]))
|
||||
ul[:i:k] = ssl
|
||||
pl[:i:k] = ssl
|
||||
self.assertEqual(pl, ul[:], "set slice [:%d:%d]" % (i, k))
|
||||
|
||||
for k in self.step_range():
|
||||
ssl = nextRange(len(ul[i::k]))
|
||||
ul[i::k] = ssl
|
||||
pl[i::k] = ssl
|
||||
self.assertEqual(pl, ul[:], "set slice [%d::%d]" % (i, k))
|
||||
|
||||
ssl = nextRange(len(ul[:i:k]))
|
||||
ul[:i:k] = ssl
|
||||
pl[:i:k] = ssl
|
||||
self.assertEqual(pl, ul[:], "set slice [:%d:%d]" % (i, k))
|
||||
|
||||
for k in self.step_range():
|
||||
ssl = nextRange(len(ul[::k]))
|
||||
ul[::k] = ssl
|
||||
pl[::k] = ssl
|
||||
self.assertEqual(pl, ul[:], "set slice [::%d]" % (k))
|
||||
ssl = nextRange(len(ul[::k]))
|
||||
ul[::k] = ssl
|
||||
pl[::k] = ssl
|
||||
self.assertEqual(pl, ul[:], "set slice [::%d]" % (k))
|
||||
|
||||
def test03_delslice(self):
|
||||
"Delete slice"
|
||||
for Len in range(self.limit):
|
||||
pl, ul = self.lists_of_len(Len)
|
||||
del pl[:]
|
||||
del ul[:]
|
||||
self.assertEqual(pl[:], ul[:], "del slice [:]")
|
||||
for i in range(-Len - 1, Len + 1):
|
||||
pl, ul = self.lists_of_len(Len)
|
||||
del pl[i:]
|
||||
del ul[i:]
|
||||
self.assertEqual(pl[:], ul[:], "del slice [%d:]" % (i))
|
||||
pl, ul = self.lists_of_len(Len)
|
||||
del pl[:i]
|
||||
del ul[:i]
|
||||
self.assertEqual(pl[:], ul[:], "del slice [:%d]" % (i))
|
||||
for j in range(-Len - 1, Len + 1):
|
||||
with self.subTest(Len=Len):
|
||||
del pl[:]
|
||||
del ul[:]
|
||||
self.assertEqual(pl[:], ul[:], "del slice [:]")
|
||||
for i in range(-Len - 1, Len + 1):
|
||||
pl, ul = self.lists_of_len(Len)
|
||||
del pl[i:j]
|
||||
del ul[i:j]
|
||||
self.assertEqual(pl[:], ul[:], "del slice [%d:%d]" % (i, j))
|
||||
del pl[i:]
|
||||
del ul[i:]
|
||||
self.assertEqual(pl[:], ul[:], "del slice [%d:]" % (i))
|
||||
pl, ul = self.lists_of_len(Len)
|
||||
del pl[:i]
|
||||
del ul[:i]
|
||||
self.assertEqual(pl[:], ul[:], "del slice [:%d]" % (i))
|
||||
for j in range(-Len - 1, Len + 1):
|
||||
pl, ul = self.lists_of_len(Len)
|
||||
del pl[i:j]
|
||||
del ul[i:j]
|
||||
self.assertEqual(pl[:], ul[:], "del slice [%d:%d]" % (i, j))
|
||||
for k in [*range(-Len - 1, 0), *range(1, Len)]:
|
||||
pl, ul = self.lists_of_len(Len)
|
||||
del pl[i:j:k]
|
||||
del ul[i:j:k]
|
||||
self.assertEqual(
|
||||
pl[:], ul[:], "del slice [%d:%d:%d]" % (i, j, k)
|
||||
)
|
||||
|
||||
for k in [*range(-Len - 1, 0), *range(1, Len)]:
|
||||
pl, ul = self.lists_of_len(Len)
|
||||
del pl[i:j:k]
|
||||
del ul[i:j:k]
|
||||
self.assertEqual(
|
||||
pl[:], ul[:], "del slice [%d:%d:%d]" % (i, j, k)
|
||||
)
|
||||
del pl[:i:k]
|
||||
del ul[:i:k]
|
||||
self.assertEqual(pl[:], ul[:], "del slice [:%d:%d]" % (i, k))
|
||||
|
||||
pl, ul = self.lists_of_len(Len)
|
||||
del pl[i::k]
|
||||
del ul[i::k]
|
||||
self.assertEqual(pl[:], ul[:], "del slice [%d::%d]" % (i, k))
|
||||
|
||||
for k in [*range(-Len - 1, 0), *range(1, Len)]:
|
||||
pl, ul = self.lists_of_len(Len)
|
||||
del pl[:i:k]
|
||||
del ul[:i:k]
|
||||
self.assertEqual(pl[:], ul[:], "del slice [:%d:%d]" % (i, k))
|
||||
|
||||
pl, ul = self.lists_of_len(Len)
|
||||
del pl[i::k]
|
||||
del ul[i::k]
|
||||
self.assertEqual(pl[:], ul[:], "del slice [%d::%d]" % (i, k))
|
||||
|
||||
for k in [*range(-Len - 1, 0), *range(1, Len)]:
|
||||
pl, ul = self.lists_of_len(Len)
|
||||
del pl[::k]
|
||||
del ul[::k]
|
||||
self.assertEqual(pl[:], ul[:], "del slice [::%d]" % (k))
|
||||
del pl[::k]
|
||||
del ul[::k]
|
||||
self.assertEqual(pl[:], ul[:], "del slice [::%d]" % (k))
|
||||
|
||||
def test04_get_set_del_single(self):
|
||||
"Get/set/delete single item"
|
||||
pl, ul = self.lists_of_len()
|
||||
for i in self.limits_plus(0):
|
||||
self.assertEqual(pl[i], ul[i], "get single item [%d]" % i)
|
||||
with self.subTest(i=i):
|
||||
self.assertEqual(pl[i], ul[i], "get single item [%d]" % i)
|
||||
|
||||
for i in self.limits_plus(0):
|
||||
pl, ul = self.lists_of_len()
|
||||
pl[i] = 100
|
||||
ul[i] = 100
|
||||
self.assertEqual(pl[:], ul[:], "set single item [%d]" % i)
|
||||
with self.subTest(i=i):
|
||||
self.assertEqual(pl[:], ul[:], "set single item [%d]" % i)
|
||||
|
||||
for i in self.limits_plus(0):
|
||||
pl, ul = self.lists_of_len()
|
||||
del pl[i]
|
||||
del ul[i]
|
||||
self.assertEqual(pl[:], ul[:], "del single item [%d]" % i)
|
||||
with self.subTest(i=i):
|
||||
self.assertEqual(pl[:], ul[:], "del single item [%d]" % i)
|
||||
|
||||
def test05_out_of_range_exceptions(self):
|
||||
"Out of range exceptions"
|
||||
@ -234,12 +250,14 @@ class ListMixinTest(unittest.TestCase):
|
||||
|
||||
pl, ul = self.lists_of_len()
|
||||
for i in (-1 - self.limit, self.limit):
|
||||
with self.assertRaises(IndexError): # 'set index %d' % i)
|
||||
setfcn(ul, i)
|
||||
with self.assertRaises(IndexError): # 'get index %d' % i)
|
||||
getfcn(ul, i)
|
||||
with self.assertRaises(IndexError): # 'del index %d' % i)
|
||||
delfcn(ul, i)
|
||||
msg = f"invalid index: {i}"
|
||||
with self.subTest(i=i):
|
||||
with self.assertRaisesMessage(IndexError, msg):
|
||||
setfcn(ul, i)
|
||||
with self.assertRaisesMessage(IndexError, msg):
|
||||
getfcn(ul, i)
|
||||
with self.assertRaisesMessage(IndexError, msg):
|
||||
delfcn(ul, i)
|
||||
|
||||
def test06_list_methods(self):
|
||||
"List methods"
|
||||
@ -260,12 +278,14 @@ class ListMixinTest(unittest.TestCase):
|
||||
pl, ul = self.lists_of_len()
|
||||
pl.insert(i, 50)
|
||||
ul.insert(i, 50)
|
||||
self.assertEqual(pl[:], ul[:], "insert at %d" % i)
|
||||
with self.subTest(i=i):
|
||||
self.assertEqual(pl[:], ul[:], "insert at %d" % i)
|
||||
|
||||
for i in self.limits_plus(0):
|
||||
pl, ul = self.lists_of_len()
|
||||
self.assertEqual(pl.pop(i), ul.pop(i), "popped value at %d" % i)
|
||||
self.assertEqual(pl[:], ul[:], "after pop at %d" % i)
|
||||
with self.subTest(i=i):
|
||||
self.assertEqual(pl.pop(i), ul.pop(i), "popped value at %d" % i)
|
||||
self.assertEqual(pl[:], ul[:], "after pop at %d" % i)
|
||||
|
||||
pl, ul = self.lists_of_len()
|
||||
self.assertEqual(pl.pop(), ul.pop(i), "popped value")
|
||||
@ -276,23 +296,26 @@ class ListMixinTest(unittest.TestCase):
|
||||
def popfcn(x, i):
|
||||
x.pop(i)
|
||||
|
||||
with self.assertRaises(IndexError):
|
||||
with self.assertRaisesMessage(IndexError, "invalid index: 3"):
|
||||
popfcn(ul, self.limit)
|
||||
with self.assertRaises(IndexError):
|
||||
with self.assertRaisesMessage(IndexError, "invalid index: -4"):
|
||||
popfcn(ul, -1 - self.limit)
|
||||
|
||||
pl, ul = self.lists_of_len()
|
||||
for val in range(self.limit):
|
||||
self.assertEqual(pl.index(val), ul.index(val), "index of %d" % val)
|
||||
with self.subTest(val=val):
|
||||
self.assertEqual(pl.index(val), ul.index(val), "index of %d" % val)
|
||||
|
||||
for val in self.limits_plus(2):
|
||||
self.assertEqual(pl.count(val), ul.count(val), "count %d" % val)
|
||||
with self.subTest(val=val):
|
||||
self.assertEqual(pl.count(val), ul.count(val), "count %d" % val)
|
||||
|
||||
for val in range(self.limit):
|
||||
pl, ul = self.lists_of_len()
|
||||
pl.remove(val)
|
||||
ul.remove(val)
|
||||
self.assertEqual(pl[:], ul[:], "after remove val %d" % val)
|
||||
with self.subTest(val=val):
|
||||
self.assertEqual(pl[:], ul[:], "after remove val %d" % val)
|
||||
|
||||
def indexfcn(x, v):
|
||||
return x.index(v)
|
||||
@ -300,9 +323,10 @@ class ListMixinTest(unittest.TestCase):
|
||||
def removefcn(x, v):
|
||||
return x.remove(v)
|
||||
|
||||
with self.assertRaises(ValueError):
|
||||
msg = "40 not found in object"
|
||||
with self.assertRaisesMessage(ValueError, msg):
|
||||
indexfcn(ul, 40)
|
||||
with self.assertRaises(ValueError):
|
||||
with self.assertRaisesMessage(ValueError, msg):
|
||||
removefcn(ul, 40)
|
||||
|
||||
def test07_allowed_types(self):
|
||||
@ -315,9 +339,10 @@ class ListMixinTest(unittest.TestCase):
|
||||
def setfcn(x, i, v):
|
||||
x[i] = v
|
||||
|
||||
with self.assertRaises(TypeError):
|
||||
msg = "Invalid type encountered in the arguments."
|
||||
with self.assertRaisesMessage(TypeError, msg):
|
||||
setfcn(ul, 2, "hello")
|
||||
with self.assertRaises(TypeError):
|
||||
with self.assertRaisesMessage(TypeError, msg):
|
||||
setfcn(ul, slice(0, 3, 2), ("hello", "goodbye"))
|
||||
|
||||
def test08_min_length(self):
|
||||
@ -331,17 +356,20 @@ class ListMixinTest(unittest.TestCase):
|
||||
def setfcn(x, i):
|
||||
x[:i] = []
|
||||
|
||||
msg = "Must have at least 3 items"
|
||||
for i in range(len(ul) - ul._minlength + 1, len(ul)):
|
||||
with self.assertRaises(ValueError):
|
||||
delfcn(ul, i)
|
||||
with self.assertRaises(ValueError):
|
||||
setfcn(ul, i)
|
||||
with self.subTest(i=i):
|
||||
with self.assertRaisesMessage(ValueError, msg):
|
||||
delfcn(ul, i)
|
||||
with self.assertRaisesMessage(ValueError, msg):
|
||||
setfcn(ul, i)
|
||||
del ul[: len(ul) - ul._minlength]
|
||||
|
||||
ul._maxlength = 4
|
||||
for i in range(0, ul._maxlength - len(ul)):
|
||||
ul.append(i)
|
||||
with self.assertRaises(ValueError):
|
||||
with self.subTest(i=i):
|
||||
ul.append(i)
|
||||
with self.assertRaisesMessage(ValueError, "Cannot have more than 4 items"):
|
||||
ul.append(10)
|
||||
|
||||
def test09_iterable_check(self):
|
||||
@ -351,22 +379,28 @@ class ListMixinTest(unittest.TestCase):
|
||||
def setfcn(x, i, v):
|
||||
x[i] = v
|
||||
|
||||
with self.assertRaises(TypeError):
|
||||
with self.assertRaisesMessage(
|
||||
TypeError, "can only assign an iterable to a slice"
|
||||
):
|
||||
setfcn(ul, slice(0, 3, 2), 2)
|
||||
|
||||
def test10_checkindex(self):
|
||||
"Index check"
|
||||
pl, ul = self.lists_of_len()
|
||||
for i in self.limits_plus(0):
|
||||
if i < 0:
|
||||
self.assertEqual(
|
||||
ul._checkindex(i), i + self.limit, "_checkindex(neg index)"
|
||||
)
|
||||
else:
|
||||
self.assertEqual(ul._checkindex(i), i, "_checkindex(pos index)")
|
||||
with self.subTest(i=i):
|
||||
if i < 0:
|
||||
self.assertEqual(
|
||||
ul._checkindex(i), i + self.limit, "_checkindex(neg index)"
|
||||
)
|
||||
else:
|
||||
self.assertEqual(ul._checkindex(i), i, "_checkindex(pos index)")
|
||||
|
||||
for i in (-self.limit - 1, self.limit):
|
||||
with self.assertRaises(IndexError):
|
||||
with (
|
||||
self.subTest(i=i),
|
||||
self.assertRaisesMessage(IndexError, f"invalid index: {i}"),
|
||||
):
|
||||
ul._checkindex(i)
|
||||
|
||||
def test_11_sorting(self):
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user