mirrors/django
1
0
Fork 0
mirror of https://github.com/django/django.git synced 2025-06-11 06:29:13 +00:00
Code Issues 32 Releases Wiki Activity

Used subTest in GEOS tests.

Browse Source
This commit is contained in:
David Smith 2024-11-07 21:33:33 +00:00
parent 91d7fd3295
commit a902233d8b
4 changed files with 763 additions and 678 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

929
tests/gis_tests/geos_tests/test_geos.py
View File

File diff suppressed because it is too large Load Diff

165
tests/gis_tests/geos_tests/test_geos_mutation.py
View File

@ -86,7 +86,8 @@ class GEOSMutationTest(SimpleTestCase):
"Testing Geometry IndexError" "Testing Geometry IndexError"
p = Point(1, 2) p = Point(1, 2)
for i in range(-2, 2): for i in range(-2, 2):
p._checkindex(i) with self.subTest(i=i):
p._checkindex(i)
msg = "invalid index: 2" msg = "invalid index: 2"
with self.assertRaisesMessage(IndexError, msg): with self.assertRaisesMessage(IndexError, msg):
p._checkindex(2) p._checkindex(2)
@ -97,17 +98,18 @@ class GEOSMutationTest(SimpleTestCase):
def test01_PointMutations(self): def test01_PointMutations(self):
"Testing Point mutations" "Testing Point mutations"
for p in (Point(1, 2, 3), fromstr("POINT (1 2 3)")): for p in (Point(1, 2, 3), fromstr("POINT (1 2 3)")):
self.assertEqual( with self.subTest(p=p):
p._get_single_external(1), 2.0, "Point _get_single_external" self.assertEqual(
) p._get_single_external(1), 2.0, "Point _get_single_external"
)
# _set_single # _set_single
p._set_single(0, 100) p._set_single(0, 100)
self.assertEqual(p.coords, (100.0, 2.0, 3.0), "Point _set_single") self.assertEqual(p.coords, (100.0, 2.0, 3.0), "Point _set_single")
# _set_list # _set_list
p._set_list(2, (50, 3141)) p._set_list(2, (50, 3141))
self.assertEqual(p.coords, (50.0, 3141.0), "Point _set_list") self.assertEqual(p.coords, (50.0, 3141.0), "Point _set_list")
def test02_PointExceptions(self): def test02_PointExceptions(self):
"Testing Point exceptions" "Testing Point exceptions"
@ -121,9 +123,10 @@ class GEOSMutationTest(SimpleTestCase):
"Testing Point API" "Testing Point API"
q = Point(4, 5, 3) q = Point(4, 5, 3)
for p in (Point(1, 2, 3), fromstr("POINT (1 2 3)")): for p in (Point(1, 2, 3), fromstr("POINT (1 2 3)")):
p[0:2] = [4, 5] with self.subTest(p=p):
for f in geos_function_tests: p[0:2] = [4, 5]
self.assertEqual(f(q), f(p), "Point " + f.__name__) for f in geos_function_tests:
self.assertEqual(f(q), f(p), "Point " + f.__name__)
def test04_LineStringMutations(self): def test04_LineStringMutations(self):
"Testing LineString mutations" "Testing LineString mutations"
@ -131,29 +134,31 @@ class GEOSMutationTest(SimpleTestCase):
LineString((1, 0), (4, 1), (6, -1)), LineString((1, 0), (4, 1), (6, -1)),
fromstr("LINESTRING (1 0,4 1,6 -1)"), fromstr("LINESTRING (1 0,4 1,6 -1)"),
): ):
self.assertEqual( with self.subTest(ls=ls):
ls._get_single_external(1), self.assertEqual(
(4.0, 1.0), ls._get_single_external(1),
"LineString _get_single_external", (4.0, 1.0),
) "LineString _get_single_external",
)
# _set_single # _set_single
ls._set_single(0, (-50, 25)) ls._set_single(0, (-50, 25))
self.assertEqual( self.assertEqual(
ls.coords, ls.coords,
((-50.0, 25.0), (4.0, 1.0), (6.0, -1.0)), ((-50.0, 25.0), (4.0, 1.0), (6.0, -1.0)),
"LineString _set_single", "LineString _set_single",
) )
# _set_list # _set_list
ls._set_list(2, ((-50.0, 25.0), (6.0, -1.0))) ls._set_list(2, ((-50.0, 25.0), (6.0, -1.0)))
self.assertEqual( self.assertEqual(
ls.coords, ((-50.0, 25.0), (6.0, -1.0)), "LineString _set_list" ls.coords, ((-50.0, 25.0), (6.0, -1.0)), "LineString _set_list"
) )
lsa = LineString(ls.coords) lsa = LineString(ls.coords)
for f in geos_function_tests: for f in geos_function_tests:
self.assertEqual(f(lsa), f(ls), "LineString " + f.__name__) with self.subTest(f=f):
self.assertEqual(f(lsa), f(ls), "LineString " + f.__name__)
def test05_Polygon(self): def test05_Polygon(self):
"Testing Polygon mutations" "Testing Polygon mutations"
@ -164,37 +169,45 @@ class GEOSMutationTest(SimpleTestCase):
), ),
fromstr("POLYGON ((1 0,4 1,6 -1,8 10,1 0),(5 4,6 4,6 3,5 4))"), fromstr("POLYGON ((1 0,4 1,6 -1,8 10,1 0),(5 4,6 4,6 3,5 4))"),
): ):
self.assertEqual( with self.subTest(pg=pg):
pg._get_single_external(0), self.assertEqual(
LinearRing((1, 0), (4, 1), (6, -1), (8, 10), (1, 0)), pg._get_single_external(0),
"Polygon _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), self.assertEqual(
LinearRing((5, 4), (6, 4), (6, 3), (5, 4)), pg._get_single_external(1),
"Polygon _get_single_external(1)", LinearRing((5, 4), (6, 4), (6, 3), (5, 4)),
) "Polygon _get_single_external(1)",
)
# _set_list # _set_list
pg._set_list( pg._set_list(
2, 2,
( (
((1, 2), (10, 0), (12, 9), (-1, 15), (1, 2)), ((1, 2), (10, 0), (12, 9), (-1, 15), (1, 2)),
((4, 2), (5, 2), (5, 3), (4, 2)), ((4, 2), (5, 2), (5, 3), (4, 2)),
), ),
) )
self.assertEqual( self.assertEqual(
pg.coords, 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)), (1.0, 2.0),
), (10.0, 0.0),
"Polygon _set_list", (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) lsa = Polygon(*pg.coords)
for f in geos_function_tests: for f in geos_function_tests:
self.assertEqual(f(lsa), f(pg), "Polygon " + f.__name__) with self.subTest(f=f):
self.assertEqual(f(lsa), f(pg), "Polygon " + f.__name__)
def test06_Collection(self): def test06_Collection(self):
"Testing Collection mutations" "Testing Collection mutations"
@ -203,17 +216,21 @@ class GEOSMutationTest(SimpleTestCase):
fromstr("MULTIPOINT (3 4,-1 2,5 -4,2 8)"), fromstr("MULTIPOINT (3 4,-1 2,5 -4,2 8)"),
) )
for mp in points: for mp in points:
self.assertEqual( with self.subTest(mp=mp):
mp._get_single_external(2), self.assertEqual(
Point(5, -4), mp._get_single_external(2),
"Collection _get_single_external", Point(5, -4),
) "Collection _get_single_external",
)
mp._set_list(3, map(Point, ((5, 5), (3, -2), (8, 1)))) mp._set_list(3, map(Point, ((5, 5), (3, -2), (8, 1))))
self.assertEqual( self.assertEqual(
mp.coords, ((5.0, 5.0), (3.0, -2.0), (8.0, 1.0)), "Collection _set_list" 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)))) lsa = MultiPoint(*map(Point, ((5, 5), (3, -2), (8, 1))))
for f in geos_function_tests: for f in geos_function_tests:
self.assertEqual(f(lsa), f(mp), "MultiPoint " + f.__name__) with self.subTest(f=f):
self.assertEqual(f(lsa), f(mp), "MultiPoint " + f.__name__)

56
tests/gis_tests/geos_tests/test_io.py
View File

@ -23,9 +23,8 @@ class GEOSIOTest(SimpleTestCase):
ref = GEOSGeometry(wkt) ref = GEOSGeometry(wkt)
g1 = wkt_r.read(wkt.encode()) g1 = wkt_r.read(wkt.encode())
g2 = wkt_r.read(wkt) g2 = wkt_r.read(wkt)
self.assertEqual(g1, ref)
for geom in (g1, g2): self.assertEqual(g2, ref)
self.assertEqual(ref, geom)
# Should only accept string objects. # Should only accept string objects.
msg = "'wkt' must be bytes or str." msg = "'wkt' must be bytes or str."
@ -71,14 +70,16 @@ class GEOSIOTest(SimpleTestCase):
g1 = wkb_r.read(wkb) g1 = wkb_r.read(wkb)
g2 = wkb_r.read(hex_bin) g2 = wkb_r.read(hex_bin)
g3 = wkb_r.read(hex_str) g3 = wkb_r.read(hex_str)
for geom in (g1, g2, g3): self.assertEqual(ref, g1)
self.assertEqual(ref, geom) self.assertEqual(ref, g2)
self.assertEqual(ref, g3)
bad_input = (1, 5.23, None, False) bad_input = (1, 5.23, None, False)
msg = "'wkb' must be bytes, str or memoryview." msg = "'wkb' must be bytes, str or memoryview."
for bad_wkb in bad_input: for bad_wkb in bad_input:
with self.assertRaisesMessage(TypeError, msg): with self.subTest(bad_wkb=bad_wkb):
wkb_r.read(bad_wkb) with self.assertRaisesMessage(TypeError, msg):
wkb_r.read(bad_wkb)
def test04_wkbwriter(self): def test04_wkbwriter(self):
wkb_w = WKBWriter() wkb_w = WKBWriter()
@ -96,10 +97,13 @@ class GEOSIOTest(SimpleTestCase):
# Ensuring bad byteorders are not accepted. # Ensuring bad byteorders are not accepted.
for bad_byteorder in (-1, 2, 523, "foo", None): for bad_byteorder in (-1, 2, 523, "foo", None):
# Equivalent of `wkb_w.byteorder = bad_byteorder` with self.subTest(bad_byteorder=bad_byteorder):
msg = "Byte order parameter must be 0 (Big Endian) or 1 (Little Endian)." # Equivalent of `wkb_w.byteorder = bad_byteorder`
with self.assertRaisesMessage(ValueError, msg): msg = (
wkb_w._set_byteorder(bad_byteorder) "Byte order parameter must be 0 (Big Endian) or 1 (Little Endian)."
)
with self.assertRaisesMessage(ValueError, msg):
wkb_w._set_byteorder(bad_byteorder)
# Setting the byteorder to 0 (for Big Endian) # Setting the byteorder to 0 (for Big Endian)
wkb_w.byteorder = 0 wkb_w.byteorder = 0
@ -122,10 +126,11 @@ class GEOSIOTest(SimpleTestCase):
# Ensuring bad output dimensions are not accepted # Ensuring bad output dimensions are not accepted
for bad_outdim in (-1, 0, 1, 4, 423, "foo", None): for bad_outdim in (-1, 0, 1, 4, 423, "foo", None):
with self.assertRaisesMessage( with self.subTest(bad_outdim=bad_outdim):
ValueError, "WKB output dimension must be 2 or 3" with self.assertRaisesMessage(
): ValueError, "WKB output dimension must be 2 or 3"
wkb_w.outdim = bad_outdim ):
wkb_w.outdim = bad_outdim
# Now setting the output dimensions to be 3 # Now setting the output dimensions to be 3
wkb_w.outdim = 3 wkb_w.outdim = 3
@ -225,12 +230,15 @@ class GEOSIOTest(SimpleTestCase):
(b"010300000000000000", b"0103000020E610000000000000"), (b"010300000000000000", b"0103000020E610000000000000"),
] ]
): ):
wkb_w.byteorder = byteorder with self.subTest(byteorder=byteorder, hexes=hexes):
for srid, hex in enumerate(hexes): wkb_w.byteorder = byteorder
wkb_w.srid = srid for srid, hex in enumerate(hexes):
self.assertEqual(wkb_w.write_hex(p), hex) wkb_w.srid = srid
self.assertEqual( self.assertEqual(wkb_w.write_hex(p), hex)
GEOSGeometry(wkb_w.write_hex(p)), p if srid else p_no_srid 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) 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
)

291
tests/gis_tests/geos_tests/test_mutable_list.py
View File

@ -78,22 +78,24 @@ class ListMixinTest(SimpleTestCase):
"Slice retrieval" "Slice retrieval"
pl, ul = self.lists_of_len() pl, ul = self.lists_of_len()
for i in self.limits_plus(1): for i in self.limits_plus(1):
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))
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(): for k in self.step_range():
self.assertEqual( self.assertEqual(pl[i::k], ul[i::k], "slice [%d::%d]" % (i, k))
pl[i:j:k], ul[i:j:k], "slice [%d:%d:%d]" % (i, j, k) self.assertEqual(pl[:i:k], ul[:i:k], "slice [:%d:%d]" % (i, 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))
for k in self.step_range(): 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): def test02_setslice(self):
"Slice assignment" "Slice assignment"
@ -103,129 +105,136 @@ class ListMixinTest(SimpleTestCase):
pl, ul = self.lists_of_len() pl, ul = self.lists_of_len()
for slen in range(self.limit + 1): for slen in range(self.limit + 1):
ssl = nextRange(slen) 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) ssl = nextRange(slen)
ul[i:] = ssl ul[:] = ssl
pl[i:] = ssl pl[:] = ssl
self.assertEqual(pl, ul[:], "set slice [%d:]" % (i)) self.assertEqual(pl, ul[:], "set slice [:]")
ssl = nextRange(slen) for i in self.limits_plus(1):
ul[:i] = ssl
pl[:i] = ssl
self.assertEqual(pl, ul[:], "set slice [:%d]" % (i))
for j in self.limits_plus(1):
ssl = nextRange(slen) ssl = nextRange(slen)
ul[i:j] = ssl ul[i:] = ssl
pl[i:j] = ssl pl[i:] = ssl
self.assertEqual(pl, ul[:], "set slice [%d:%d]" % (i, j)) self.assertEqual(pl, ul[:], "set slice [%d:]" % (i))
for k in self.step_range(): ssl = nextRange(slen)
ssl = nextRange(len(ul[i:j:k])) ul[:i] = ssl
ul[i:j:k] = ssl pl[:i] = ssl
pl[i:j:k] = ssl self.assertEqual(pl, ul[:], "set slice [:%d]" % (i))
self.assertEqual(pl, ul[:], "set slice [%d:%d:%d]" % (i, j, k))
sliceLen = len(ul[i:j:k]) for j in self.limits_plus(1):
msg = ( ssl = nextRange(slen)
f"attempt to assign sequence of size {sliceLen + 1} " ul[i:j] = ssl
f"to extended slice of size {sliceLen}" pl[i:j] = ssl
) self.assertEqual(pl, ul[:], "set slice [%d:%d]" % (i, j))
with self.assertRaisesMessage(ValueError, msg):
setfcn(ul, i, j, k, sliceLen + 1) for k in self.step_range():
if sliceLen > 2: 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 = ( msg = (
f"attempt to assign sequence of size {sliceLen - 1} " f"attempt to assign sequence of size {sliceLen + 1} "
f"to extended slice of size {sliceLen}" f"to extended slice of size {sliceLen}"
) )
with self.assertRaisesMessage(ValueError, msg): with self.assertRaisesMessage(ValueError, msg):
setfcn(ul, i, j, k, sliceLen - 1) 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::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(): for k in self.step_range():
ssl = nextRange(len(ul[i::k])) ssl = nextRange(len(ul[::k]))
ul[i::k] = ssl ul[::k] = ssl
pl[i::k] = ssl pl[::k] = ssl
self.assertEqual(pl, ul[:], "set slice [%d::%d]" % (i, k)) self.assertEqual(pl, ul[:], "set slice [::%d]" % (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))
def test03_delslice(self): def test03_delslice(self):
"Delete slice" "Delete slice"
for Len in range(self.limit): for Len in range(self.limit):
pl, ul = self.lists_of_len(Len) 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) pl, ul = self.lists_of_len(Len)
del pl[i:] del pl[:]
del ul[i:] del ul[:]
self.assertEqual(pl[:], ul[:], "del slice [%d:]" % (i)) self.assertEqual(pl[:], ul[:], "del slice [:]")
pl, ul = self.lists_of_len(Len) for i in range(-Len - 1, Len + 1):
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) pl, ul = self.lists_of_len(Len)
del pl[i:j] del pl[i:]
del ul[i:j] del ul[i:]
self.assertEqual(pl[:], ul[:], "del slice [%d:%d]" % (i, j)) 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)]: for k in [*range(-Len - 1, 0), *range(1, Len)]:
pl, ul = self.lists_of_len(Len) pl, ul = self.lists_of_len(Len)
del pl[i:j:k] del pl[:i:k]
del ul[i:j:k] del ul[:i:k]
self.assertEqual( self.assertEqual(pl[:], ul[:], "del slice [:%d:%d]" % (i, k))
pl[:], ul[:], "del slice [%d:%d:%d]" % (i, j, 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)]: for k in [*range(-Len - 1, 0), *range(1, Len)]:
pl, ul = self.lists_of_len(Len) pl, ul = self.lists_of_len(Len)
del pl[:i:k] del pl[::k]
del ul[:i:k] del ul[::k]
self.assertEqual(pl[:], ul[:], "del slice [:%d:%d]" % (i, k)) self.assertEqual(pl[:], ul[:], "del slice [::%d]" % (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))
def test04_get_set_del_single(self): def test04_get_set_del_single(self):
"Get/set/delete single item" "Get/set/delete single item"
pl, ul = self.lists_of_len() pl, ul = self.lists_of_len()
for i in self.limits_plus(0): 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): for i in self.limits_plus(0):
pl, ul = self.lists_of_len() with self.subTest(i=i):
pl[i] = 100 pl, ul = self.lists_of_len()
ul[i] = 100 pl[i] = 100
self.assertEqual(pl[:], ul[:], "set single item [%d]" % i) ul[i] = 100
self.assertEqual(pl[:], ul[:], "set single item [%d]" % i)
for i in self.limits_plus(0): for i in self.limits_plus(0):
pl, ul = self.lists_of_len() with self.subTest(i=i):
del pl[i] pl, ul = self.lists_of_len()
del ul[i] del pl[i]
self.assertEqual(pl[:], ul[:], "del single item [%d]" % i) del ul[i]
self.assertEqual(pl[:], ul[:], "del single item [%d]" % i)
def test05_out_of_range_exceptions(self): def test05_out_of_range_exceptions(self):
"Out of range exceptions" "Out of range exceptions"
@ -242,12 +251,13 @@ class ListMixinTest(SimpleTestCase):
pl, ul = self.lists_of_len() pl, ul = self.lists_of_len()
for i in (-1 - self.limit, self.limit): for i in (-1 - self.limit, self.limit):
msg = f"invalid index: {i}" msg = f"invalid index: {i}"
with self.assertRaisesMessage(IndexError, msg): # 'set index %d' % i) with self.subTest(i=i):
setfcn(ul, i) with self.assertRaisesMessage(IndexError, msg): # 'set index %d' % i)
with self.assertRaisesMessage(IndexError, msg): # 'get index %d' % i) setfcn(ul, i)
getfcn(ul, i) with self.assertRaisesMessage(IndexError, msg): # 'get index %d' % i)
with self.assertRaisesMessage(IndexError, msg): # 'del index %d' % i) getfcn(ul, i)
delfcn(ul, i) with self.assertRaisesMessage(IndexError, msg): # 'del index %d' % i)
delfcn(ul, i)
def test06_list_methods(self): def test06_list_methods(self):
"List methods" "List methods"
@ -265,15 +275,17 @@ class ListMixinTest(SimpleTestCase):
self.assertEqual(pl[:], ul[:], "reverse") self.assertEqual(pl[:], ul[:], "reverse")
for i in self.limits_plus(1): for i in self.limits_plus(1):
pl, ul = self.lists_of_len() with self.subTest(i=i):
pl.insert(i, 50) pl, ul = self.lists_of_len()
ul.insert(i, 50) pl.insert(i, 50)
self.assertEqual(pl[:], ul[:], "insert at %d" % i) ul.insert(i, 50)
self.assertEqual(pl[:], ul[:], "insert at %d" % i)
for i in self.limits_plus(0): for i in self.limits_plus(0):
pl, ul = self.lists_of_len() with self.subTest(i=i):
self.assertEqual(pl.pop(i), ul.pop(i), "popped value at %d" % i) pl, ul = self.lists_of_len()
self.assertEqual(pl[:], ul[:], "after pop at %d" % 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() pl, ul = self.lists_of_len()
self.assertEqual(pl.pop(), ul.pop(i), "popped value") self.assertEqual(pl.pop(), ul.pop(i), "popped value")
@ -293,16 +305,19 @@ class ListMixinTest(SimpleTestCase):
pl, ul = self.lists_of_len() pl, ul = self.lists_of_len()
for val in range(self.limit): 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): 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): for val in range(self.limit):
pl, ul = self.lists_of_len() with self.subTest(val=val):
pl.remove(val) pl, ul = self.lists_of_len()
ul.remove(val) pl.remove(val)
self.assertEqual(pl[:], ul[:], "after remove val %d" % val) ul.remove(val)
self.assertEqual(pl[:], ul[:], "after remove val %d" % val)
def indexfcn(x, v): def indexfcn(x, v):
return x.index(v) return x.index(v)
@ -345,15 +360,17 @@ class ListMixinTest(SimpleTestCase):
msg = "Must have at least 3 items" msg = "Must have at least 3 items"
for i in range(len(ul) - ul._minlength + 1, len(ul)): for i in range(len(ul) - ul._minlength + 1, len(ul)):
with self.assertRaisesMessage(ValueError, msg): with self.subTest(i=i):
delfcn(ul, i) with self.assertRaisesMessage(ValueError, msg):
with self.assertRaisesMessage(ValueError, msg): delfcn(ul, i)
setfcn(ul, i) with self.assertRaisesMessage(ValueError, msg):
setfcn(ul, i)
del ul[: len(ul) - ul._minlength] del ul[: len(ul) - ul._minlength]
ul._maxlength = 4 ul._maxlength = 4
for i in range(0, ul._maxlength - len(ul)): for i in range(0, ul._maxlength - len(ul)):
ul.append(i) with self.subTest(i=i):
ul.append(i)
msg = "Cannot have more than 4 items" msg = "Cannot have more than 4 items"
with self.assertRaisesMessage(ValueError, msg): with self.assertRaisesMessage(ValueError, msg):
ul.append(10) ul.append(10)
@ -373,17 +390,19 @@ class ListMixinTest(SimpleTestCase):
"Index check" "Index check"
pl, ul = self.lists_of_len() pl, ul = self.lists_of_len()
for i in self.limits_plus(0): for i in self.limits_plus(0):
if i < 0: with self.subTest(i=i):
self.assertEqual( if i < 0:
ul._checkindex(i), i + self.limit, "_checkindex(neg index)" self.assertEqual(
) ul._checkindex(i), i + self.limit, "_checkindex(neg index)"
else: )
self.assertEqual(ul._checkindex(i), i, "_checkindex(pos index)") else:
self.assertEqual(ul._checkindex(i), i, "_checkindex(pos index)")
for i in (-self.limit - 1, self.limit): for i in (-self.limit - 1, self.limit):
msg = f"invalid index: {i}" msg = f"invalid index: {i}"
with self.assertRaisesMessage(IndexError, msg): with self.subTest(i=i):
ul._checkindex(i) with self.assertRaisesMessage(IndexError, msg):
ul._checkindex(i)
def test_11_sorting(self): def test_11_sorting(self):
"Sorting" "Sorting"