summaryrefslogtreecommitdiffstats
path: root/Lib/test
diff options
context:
space:
mode:
Diffstat (limited to 'Lib/test')
-rw-r--r--Lib/test/test_compile.py2
-rw-r--r--Lib/test/test_format.py249
-rw-r--r--Lib/test/test_str.py42
-rw-r--r--Lib/test/test_struct.py38
-rw-r--r--Lib/test/test_subprocess.py2
-rw-r--r--Lib/test/test_unicode.py4
6 files changed, 150 insertions, 187 deletions
diff --git a/Lib/test/test_compile.py b/Lib/test/test_compile.py
index 0bdd036..d6a51dd 100644
--- a/Lib/test/test_compile.py
+++ b/Lib/test/test_compile.py
@@ -157,7 +157,7 @@ if 1:
s256 = "".join(["\n"] * 256 + ["spam"])
co = compile(s256, 'fn', 'exec')
self.assertEqual(co.co_firstlineno, 257)
- self.assertEqual(co.co_lnotab, '')
+ self.assertEqual(co.co_lnotab, str8(''))
def test_literals_with_leading_zeroes(self):
for arg in ["077787", "0xj", "0x.", "0e", "090000000000000",
diff --git a/Lib/test/test_format.py b/Lib/test/test_format.py
index 4c3d36e..0b02adf 100644
--- a/Lib/test/test_format.py
+++ b/Lib/test/test_format.py
@@ -39,163 +39,158 @@ def testformat(formatstr, args, output=None):
if verbose:
print('yes')
-def testboth(formatstr, *args):
- testformat(str8(formatstr), *args)
- testformat(formatstr, *args)
+testformat("%.1d", (1,), "1")
+testformat("%.*d", (sys.maxint,1)) # expect overflow
+testformat("%.100d", (1,), '0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001')
+testformat("%#.117x", (1,), '0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001')
+testformat("%#.118x", (1,), '0x0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001')
-
-testboth("%.1d", (1,), "1")
-testboth("%.*d", (sys.maxint,1)) # expect overflow
-testboth("%.100d", (1,), '0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001')
-testboth("%#.117x", (1,), '0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001')
-testboth("%#.118x", (1,), '0x0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001')
-
-testboth("%f", (1.0,), "1.000000")
+testformat("%f", (1.0,), "1.000000")
# these are trying to test the limits of the internal magic-number-length
# formatting buffer, if that number changes then these tests are less
# effective
-testboth("%#.*g", (109, -1.e+49/3.))
-testboth("%#.*g", (110, -1.e+49/3.))
-testboth("%#.*g", (110, -1.e+100/3.))
+testformat("%#.*g", (109, -1.e+49/3.))
+testformat("%#.*g", (110, -1.e+49/3.))
+testformat("%#.*g", (110, -1.e+100/3.))
# test some ridiculously large precision, expect overflow
-testboth('%12.*f', (123456, 1.0))
+testformat('%12.*f', (123456, 1.0))
# check for internal overflow validation on length of precision
overflowrequired = 1
-testboth("%#.*g", (110, -1.e+100/3.))
-testboth("%#.*G", (110, -1.e+100/3.))
-testboth("%#.*f", (110, -1.e+100/3.))
-testboth("%#.*F", (110, -1.e+100/3.))
+testformat("%#.*g", (110, -1.e+100/3.))
+testformat("%#.*G", (110, -1.e+100/3.))
+testformat("%#.*f", (110, -1.e+100/3.))
+testformat("%#.*F", (110, -1.e+100/3.))
overflowrequired = 0
# Formatting of long integers. Overflow is not ok
overflowok = 0
-testboth("%x", 10, "a")
-testboth("%x", 100000000000, "174876e800")
-testboth("%o", 10, "12")
-testboth("%o", 100000000000, "1351035564000")
-testboth("%d", 10, "10")
-testboth("%d", 100000000000, "100000000000")
+testformat("%x", 10, "a")
+testformat("%x", 100000000000, "174876e800")
+testformat("%o", 10, "12")
+testformat("%o", 100000000000, "1351035564000")
+testformat("%d", 10, "10")
+testformat("%d", 100000000000, "100000000000")
big = 123456789012345678901234567890
-testboth("%d", big, "123456789012345678901234567890")
-testboth("%d", -big, "-123456789012345678901234567890")
-testboth("%5d", -big, "-123456789012345678901234567890")
-testboth("%31d", -big, "-123456789012345678901234567890")
-testboth("%32d", -big, " -123456789012345678901234567890")
-testboth("%-32d", -big, "-123456789012345678901234567890 ")
-testboth("%032d", -big, "-0123456789012345678901234567890")
-testboth("%-032d", -big, "-123456789012345678901234567890 ")
-testboth("%034d", -big, "-000123456789012345678901234567890")
-testboth("%034d", big, "0000123456789012345678901234567890")
-testboth("%0+34d", big, "+000123456789012345678901234567890")
-testboth("%+34d", big, " +123456789012345678901234567890")
-testboth("%34d", big, " 123456789012345678901234567890")
-testboth("%.2d", big, "123456789012345678901234567890")
-testboth("%.30d", big, "123456789012345678901234567890")
-testboth("%.31d", big, "0123456789012345678901234567890")
-testboth("%32.31d", big, " 0123456789012345678901234567890")
+testformat("%d", big, "123456789012345678901234567890")
+testformat("%d", -big, "-123456789012345678901234567890")
+testformat("%5d", -big, "-123456789012345678901234567890")
+testformat("%31d", -big, "-123456789012345678901234567890")
+testformat("%32d", -big, " -123456789012345678901234567890")
+testformat("%-32d", -big, "-123456789012345678901234567890 ")
+testformat("%032d", -big, "-0123456789012345678901234567890")
+testformat("%-032d", -big, "-123456789012345678901234567890 ")
+testformat("%034d", -big, "-000123456789012345678901234567890")
+testformat("%034d", big, "0000123456789012345678901234567890")
+testformat("%0+34d", big, "+000123456789012345678901234567890")
+testformat("%+34d", big, " +123456789012345678901234567890")
+testformat("%34d", big, " 123456789012345678901234567890")
+testformat("%.2d", big, "123456789012345678901234567890")
+testformat("%.30d", big, "123456789012345678901234567890")
+testformat("%.31d", big, "0123456789012345678901234567890")
+testformat("%32.31d", big, " 0123456789012345678901234567890")
big = 0x1234567890abcdef12345 # 21 hex digits
-testboth("%x", big, "1234567890abcdef12345")
-testboth("%x", -big, "-1234567890abcdef12345")
-testboth("%5x", -big, "-1234567890abcdef12345")
-testboth("%22x", -big, "-1234567890abcdef12345")
-testboth("%23x", -big, " -1234567890abcdef12345")
-testboth("%-23x", -big, "-1234567890abcdef12345 ")
-testboth("%023x", -big, "-01234567890abcdef12345")
-testboth("%-023x", -big, "-1234567890abcdef12345 ")
-testboth("%025x", -big, "-0001234567890abcdef12345")
-testboth("%025x", big, "00001234567890abcdef12345")
-testboth("%0+25x", big, "+0001234567890abcdef12345")
-testboth("%+25x", big, " +1234567890abcdef12345")
-testboth("%25x", big, " 1234567890abcdef12345")
-testboth("%.2x", big, "1234567890abcdef12345")
-testboth("%.21x", big, "1234567890abcdef12345")
-testboth("%.22x", big, "01234567890abcdef12345")
-testboth("%23.22x", big, " 01234567890abcdef12345")
-testboth("%-23.22x", big, "01234567890abcdef12345 ")
-testboth("%X", big, "1234567890ABCDEF12345")
-testboth("%#X", big, "0X1234567890ABCDEF12345")
-testboth("%#x", big, "0x1234567890abcdef12345")
-testboth("%#x", -big, "-0x1234567890abcdef12345")
-testboth("%#.23x", -big, "-0x001234567890abcdef12345")
-testboth("%#+.23x", big, "+0x001234567890abcdef12345")
-testboth("%# .23x", big, " 0x001234567890abcdef12345")
-testboth("%#+.23X", big, "+0X001234567890ABCDEF12345")
-testboth("%#-+.23X", big, "+0X001234567890ABCDEF12345")
-testboth("%#-+26.23X", big, "+0X001234567890ABCDEF12345")
-testboth("%#-+27.23X", big, "+0X001234567890ABCDEF12345 ")
-testboth("%#+27.23X", big, " +0X001234567890ABCDEF12345")
+testformat("%x", big, "1234567890abcdef12345")
+testformat("%x", -big, "-1234567890abcdef12345")
+testformat("%5x", -big, "-1234567890abcdef12345")
+testformat("%22x", -big, "-1234567890abcdef12345")
+testformat("%23x", -big, " -1234567890abcdef12345")
+testformat("%-23x", -big, "-1234567890abcdef12345 ")
+testformat("%023x", -big, "-01234567890abcdef12345")
+testformat("%-023x", -big, "-1234567890abcdef12345 ")
+testformat("%025x", -big, "-0001234567890abcdef12345")
+testformat("%025x", big, "00001234567890abcdef12345")
+testformat("%0+25x", big, "+0001234567890abcdef12345")
+testformat("%+25x", big, " +1234567890abcdef12345")
+testformat("%25x", big, " 1234567890abcdef12345")
+testformat("%.2x", big, "1234567890abcdef12345")
+testformat("%.21x", big, "1234567890abcdef12345")
+testformat("%.22x", big, "01234567890abcdef12345")
+testformat("%23.22x", big, " 01234567890abcdef12345")
+testformat("%-23.22x", big, "01234567890abcdef12345 ")
+testformat("%X", big, "1234567890ABCDEF12345")
+testformat("%#X", big, "0X1234567890ABCDEF12345")
+testformat("%#x", big, "0x1234567890abcdef12345")
+testformat("%#x", -big, "-0x1234567890abcdef12345")
+testformat("%#.23x", -big, "-0x001234567890abcdef12345")
+testformat("%#+.23x", big, "+0x001234567890abcdef12345")
+testformat("%# .23x", big, " 0x001234567890abcdef12345")
+testformat("%#+.23X", big, "+0X001234567890ABCDEF12345")
+testformat("%#-+.23X", big, "+0X001234567890ABCDEF12345")
+testformat("%#-+26.23X", big, "+0X001234567890ABCDEF12345")
+testformat("%#-+27.23X", big, "+0X001234567890ABCDEF12345 ")
+testformat("%#+27.23X", big, " +0X001234567890ABCDEF12345")
# next one gets two leading zeroes from precision, and another from the
# 0 flag and the width
-testboth("%#+027.23X", big, "+0X0001234567890ABCDEF12345")
+testformat("%#+027.23X", big, "+0X0001234567890ABCDEF12345")
# same, except no 0 flag
-testboth("%#+27.23X", big, " +0X001234567890ABCDEF12345")
+testformat("%#+27.23X", big, " +0X001234567890ABCDEF12345")
big = 0o12345670123456701234567012345670 # 32 octal digits
-testboth("%o", big, "12345670123456701234567012345670")
-testboth("%o", -big, "-12345670123456701234567012345670")
-testboth("%5o", -big, "-12345670123456701234567012345670")
-testboth("%33o", -big, "-12345670123456701234567012345670")
-testboth("%34o", -big, " -12345670123456701234567012345670")
-testboth("%-34o", -big, "-12345670123456701234567012345670 ")
-testboth("%034o", -big, "-012345670123456701234567012345670")
-testboth("%-034o", -big, "-12345670123456701234567012345670 ")
-testboth("%036o", -big, "-00012345670123456701234567012345670")
-testboth("%036o", big, "000012345670123456701234567012345670")
-testboth("%0+36o", big, "+00012345670123456701234567012345670")
-testboth("%+36o", big, " +12345670123456701234567012345670")
-testboth("%36o", big, " 12345670123456701234567012345670")
-testboth("%.2o", big, "12345670123456701234567012345670")
-testboth("%.32o", big, "12345670123456701234567012345670")
-testboth("%.33o", big, "012345670123456701234567012345670")
-testboth("%34.33o", big, " 012345670123456701234567012345670")
-testboth("%-34.33o", big, "012345670123456701234567012345670 ")
-testboth("%o", big, "12345670123456701234567012345670")
-testboth("%#o", big, "0o12345670123456701234567012345670")
-testboth("%#o", -big, "-0o12345670123456701234567012345670")
-testboth("%#.34o", -big, "-0o0012345670123456701234567012345670")
-testboth("%#+.34o", big, "+0o0012345670123456701234567012345670")
-testboth("%# .34o", big, " 0o0012345670123456701234567012345670")
-testboth("%#-+.34o", big, "+0o0012345670123456701234567012345670")
-testboth("%#-+39.34o", big, "+0o0012345670123456701234567012345670 ")
-testboth("%#+39.34o", big, " +0o0012345670123456701234567012345670")
+testformat("%o", big, "12345670123456701234567012345670")
+testformat("%o", -big, "-12345670123456701234567012345670")
+testformat("%5o", -big, "-12345670123456701234567012345670")
+testformat("%33o", -big, "-12345670123456701234567012345670")
+testformat("%34o", -big, " -12345670123456701234567012345670")
+testformat("%-34o", -big, "-12345670123456701234567012345670 ")
+testformat("%034o", -big, "-012345670123456701234567012345670")
+testformat("%-034o", -big, "-12345670123456701234567012345670 ")
+testformat("%036o", -big, "-00012345670123456701234567012345670")
+testformat("%036o", big, "000012345670123456701234567012345670")
+testformat("%0+36o", big, "+00012345670123456701234567012345670")
+testformat("%+36o", big, " +12345670123456701234567012345670")
+testformat("%36o", big, " 12345670123456701234567012345670")
+testformat("%.2o", big, "12345670123456701234567012345670")
+testformat("%.32o", big, "12345670123456701234567012345670")
+testformat("%.33o", big, "012345670123456701234567012345670")
+testformat("%34.33o", big, " 012345670123456701234567012345670")
+testformat("%-34.33o", big, "012345670123456701234567012345670 ")
+testformat("%o", big, "12345670123456701234567012345670")
+testformat("%#o", big, "0o12345670123456701234567012345670")
+testformat("%#o", -big, "-0o12345670123456701234567012345670")
+testformat("%#.34o", -big, "-0o0012345670123456701234567012345670")
+testformat("%#+.34o", big, "+0o0012345670123456701234567012345670")
+testformat("%# .34o", big, " 0o0012345670123456701234567012345670")
+testformat("%#-+.34o", big, "+0o0012345670123456701234567012345670")
+testformat("%#-+39.34o", big, "+0o0012345670123456701234567012345670 ")
+testformat("%#+39.34o", big, " +0o0012345670123456701234567012345670")
# next one gets one leading zero from precision
-testboth("%.33o", big, "012345670123456701234567012345670")
+testformat("%.33o", big, "012345670123456701234567012345670")
# one leading zero from precision
-testboth("%#.33o", big, "0o012345670123456701234567012345670")
+testformat("%#.33o", big, "0o012345670123456701234567012345670")
# leading zero vanishes
-testboth("%#.32o", big, "0o12345670123456701234567012345670")
+testformat("%#.32o", big, "0o12345670123456701234567012345670")
# one leading zero from precision, and another from '0' flag & width
-testboth("%034.33o", big, "0012345670123456701234567012345670")
+testformat("%034.33o", big, "0012345670123456701234567012345670")
# max width includes base marker; padding zeroes come after marker
-testboth("%0#38.33o", big, "0o000012345670123456701234567012345670")
+testformat("%0#38.33o", big, "0o000012345670123456701234567012345670")
# padding spaces come before marker
-testboth("%#36.33o", big, " 0o012345670123456701234567012345670")
+testformat("%#36.33o", big, " 0o012345670123456701234567012345670")
# Some small ints, in both Python int and long flavors).
-testboth("%d", 42, "42")
-testboth("%d", -42, "-42")
-testboth("%#x", 1, "0x1")
-testboth("%#X", 1, "0X1")
-testboth("%#o", 1, "0o1")
-testboth("%#o", 1, "0o1")
-testboth("%#o", 0, "0o0")
-testboth("%#o", 0, "0o0")
-testboth("%o", 0, "0")
-testboth("%d", 0, "0")
-testboth("%#x", 0, "0x0")
-testboth("%#X", 0, "0X0")
-
-testboth("%x", 0x42, "42")
-testboth("%x", -0x42, "-42")
-
-testboth("%o", 0o42, "42")
-testboth("%o", -0o42, "-42")
-testboth("%o", 0o42, "42")
-testboth("%o", -0o42, "-42")
+testformat("%d", 42, "42")
+testformat("%d", -42, "-42")
+testformat("%#x", 1, "0x1")
+testformat("%#X", 1, "0X1")
+testformat("%#o", 1, "0o1")
+testformat("%#o", 1, "0o1")
+testformat("%#o", 0, "0o0")
+testformat("%#o", 0, "0o0")
+testformat("%o", 0, "0")
+testformat("%d", 0, "0")
+testformat("%#x", 0, "0x0")
+testformat("%#X", 0, "0X0")
+
+testformat("%x", 0x42, "42")
+testformat("%x", -0x42, "-42")
+
+testformat("%o", 0o42, "42")
+testformat("%o", -0o42, "-42")
+testformat("%o", 0o42, "42")
+testformat("%o", -0o42, "-42")
# Test exception for unknown format characters
if verbose:
diff --git a/Lib/test/test_str.py b/Lib/test/test_str.py
index ad118d6..1d02467 100644
--- a/Lib/test/test_str.py
+++ b/Lib/test/test_str.py
@@ -36,34 +36,9 @@ class StrTest(
def __str__(self):
return "foo"
- class Foo2(object):
- def __str__(self):
- return "foo"
-
- class Foo3(object):
- def __str__(self):
- return "foo"
-
- class Foo4(str8):
- def __str__(self):
- return "foo"
-
- class Foo5(str):
- def __unicode__(self):
- return "foo"
-
- class Foo6(str8):
- def __str__(self):
- return "foos"
-
- def __unicode__(self):
- return "foou"
-
class Foo7(str):
def __str__(self):
return "foos"
- def __unicode__(self):
- return "foou"
class Foo8(str):
def __new__(cls, content=""):
@@ -71,24 +46,9 @@ class StrTest(
def __str__(self):
return self
- class Foo9(str8):
- def __str__(self):
- return "string"
- def __unicode__(self):
- return "not unicode"
-
self.assertEqual(str(Foo1()), "foo")
- self.assertEqual(str(Foo2()), "foo")
- self.assertEqual(str(Foo3()), "foo")
- self.assertEqual(str(Foo4("bar")), "foo")
- self.assertEqual(str(Foo5("bar")), "foo")
- self.assertEqual(str8(Foo6("bar")), "foos")
- self.assertEqual(str(Foo6("bar")), "foou")
- self.assertEqual(str8(Foo7("bar")), "foos")
- self.assertEqual(str(Foo7("bar")), "foou")
+ self.assertEqual(str(Foo7("bar")), "foos")
self.assertEqual(str(Foo8("foo")), "foofoo")
- self.assertEqual(str8(Foo9("foo")), "string")
- self.assertEqual(str(Foo9("foo")), "not unicode")
def test_expandtabs_overflows_gracefully(self):
# This test only affects 32-bit platforms because expandtabs can only take
diff --git a/Lib/test/test_struct.py b/Lib/test/test_struct.py
index cc6db32..7942045 100644
--- a/Lib/test/test_struct.py
+++ b/Lib/test/test_struct.py
@@ -101,7 +101,7 @@ s = struct.pack('ii', 1, 2)
simple_err(struct.unpack, 'iii', s)
simple_err(struct.unpack, 'i', s)
-c = 'a'
+c = str8('a')
b = 1
h = 255
i = 65535
@@ -183,6 +183,10 @@ for fmt, arg, big, lil, asy in tests:
raise TestFailed("calcsize(%r) -> %d # expected %d" % (
xfmt, n, len(res)))
rev = struct.unpack(xfmt, res)[0]
+ if isinstance(arg, str):
+ # Strings are returned as str8 since you can't know the encoding of
+ # the string when packed.
+ arg = str8(arg)
if rev != arg and not asy:
raise TestFailed("unpack(%r, %r) -> (%r,) # expected (%r,)" % (
fmt, res, rev, arg))
@@ -424,14 +428,14 @@ for args in [("bB", 1),
def test_p_code():
for code, input, expected, expectedback in [
- ('p','abc', '\x00', ''),
- ('1p', 'abc', '\x00', ''),
- ('2p', 'abc', '\x01a', 'a'),
- ('3p', 'abc', '\x02ab', 'ab'),
- ('4p', 'abc', '\x03abc', 'abc'),
- ('5p', 'abc', '\x03abc\x00', 'abc'),
- ('6p', 'abc', '\x03abc\x00\x00', 'abc'),
- ('1000p', 'x'*1000, '\xff' + 'x'*999, 'x'*255)]:
+ ('p','abc', '\x00', str8('')),
+ ('1p', 'abc', '\x00', str8('')),
+ ('2p', 'abc', '\x01a', str8('a')),
+ ('3p', 'abc', '\x02ab', str8('ab')),
+ ('4p', 'abc', '\x03abc', str8('abc')),
+ ('5p', 'abc', '\x03abc\x00', str8('abc')),
+ ('6p', 'abc', '\x03abc\x00\x00', str8('abc')),
+ ('1000p', 'x'*1000, '\xff' + 'x'*999, str8('x'*255))]:
expected = bytes(expected, "latin-1")
got = struct.pack(code, input)
if got != expected:
@@ -560,20 +564,20 @@ def test_unpack_from():
if verbose:
print("test_unpack_from using", cls.__name__)
data = cls(test_string)
- vereq(s.unpack_from(data), ('abcd',))
- vereq(s.unpack_from(data, 2), ('cd01',))
- vereq(s.unpack_from(data, 4), ('0123',))
+ vereq(s.unpack_from(data), (str8('abcd'),))
+ vereq(s.unpack_from(data, 2), (str8('cd01'),))
+ vereq(s.unpack_from(data, 4), (str8('0123'),))
for i in range(6):
- vereq(s.unpack_from(data, i), (data[i:i+4],))
+ vereq(s.unpack_from(data, i), (str8(data[i:i+4]),))
for i in range(6, len(test_string) + 1):
simple_err(s.unpack_from, data, i)
for cls in (str, str8, bytes): # XXX + memoryview
data = cls(test_string)
- vereq(struct.unpack_from(fmt, data), ('abcd',))
- vereq(struct.unpack_from(fmt, data, 2), ('cd01',))
- vereq(struct.unpack_from(fmt, data, 4), ('0123',))
+ vereq(struct.unpack_from(fmt, data), (str8('abcd'),))
+ vereq(struct.unpack_from(fmt, data, 2), (str8('cd01'),))
+ vereq(struct.unpack_from(fmt, data, 4), (str8('0123'),))
for i in range(6):
- vereq(struct.unpack_from(fmt, data, i), (data[i:i+4],))
+ vereq(struct.unpack_from(fmt, data, i), (str8(data[i:i+4]),))
for i in range(6, len(test_string) + 1):
simple_err(struct.unpack_from, fmt, data, i)
diff --git a/Lib/test/test_subprocess.py b/Lib/test/test_subprocess.py
index 3c92675..fea98dc 100644
--- a/Lib/test/test_subprocess.py
+++ b/Lib/test/test_subprocess.py
@@ -24,7 +24,7 @@ else:
# shutdown time. That frustrates tests trying to check stderr produced
# from a spawned Python process.
def remove_stderr_debug_decorations(stderr):
- return re.sub(r"\[\d+ refs\]\r?\n?$", "", str8(stderr))
+ return re.sub(r"\[\d+ refs\]\r?\n?$", "", str(stderr))
class ProcessTestCase(unittest.TestCase):
def setUp(self):
diff --git a/Lib/test/test_unicode.py b/Lib/test/test_unicode.py
index d33643a..04dddaa 100644
--- a/Lib/test/test_unicode.py
+++ b/Lib/test/test_unicode.py
@@ -200,6 +200,10 @@ class UnicodeTest(
self.checkequalnofix('one@two!three!', 'one!two!three!', 'replace', '!', '@', 1)
self.assertRaises(TypeError, 'replace'.replace, "r", 42)
+ def test_str8_comparison(self):
+ self.assertEqual('abc' == str8('abc'), False)
+ self.assertEqual('abc' != str8('abc'), True)
+
def test_comparison(self):
# Comparisons:
self.assertEqual('abc', 'abc')
generated by cgit v0.12 at 2024-11-28 07:59:03 (GMT)