1 ### -*- mode: python, coding: utf-8 -*-
5 ### (c) 2019 Straylight/Edgeware
8 ###----- Licensing notice ---------------------------------------------------
10 ### This file is part of the Python interface to Catacomb.
12 ### Catacomb/Python is free software: you can redistribute it and/or
13 ### modify it under the terms of the GNU General Public License as
14 ### published by the Free Software Foundation; either version 2 of the
15 ### License, or (at your option) any later version.
17 ### Catacomb/Python is distributed in the hope that it will be useful, but
18 ### WITHOUT ANY WARRANTY; without even the implied warranty of
19 ### MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 ### General Public License for more details.
22 ### You should have received a copy of the GNU General Public License
23 ### along with Catacomb/Python. If not, write to the Free Software
24 ### Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
27 ###--------------------------------------------------------------------------
35 ###--------------------------------------------------------------------------
36 class TestByteString (U
.TestCase
):
40 ## Create a string and make sure it looks right.
41 x
= C
.ByteString(T
.bin("abcde"))
42 me
.assertEqual(x
, T
.bin("abcde"))
43 me
.assertEqual(x
, C
.bytes("6162636465"))
44 me
.assertEqual(len(x
), 5)
48 x
= C
.ByteString(T
.bin("once upon a time there was a string"))
50 ## Check that simple indexing works. Alas the behaviour differs between
51 ## Python major versions.
53 me
.assertEqual(type(x
[3]), int)
54 me
.assertEqual(x
[3], 101)
55 me
.assertEqual(x
[-5], 116)
57 me
.assertEqual(type(x
[3]), C
.ByteString
)
58 me
.assertEqual(x
[3], 'e')
59 me
.assertEqual(x
[-5], 't')
61 ## Check out-of-range detection.
62 x
[34]; me
.assertRaises(IndexError, lambda: x
[35])
63 x
[-35]; me
.assertRaises(IndexError, lambda: x
[-36])
65 ## Check slicing. This should always give us bytes.
66 me
.assertEqual(type(x
[7:17]), C
.ByteString
)
67 me
.assertEqual(x
[7:17], T
.bin("on a time "))
69 ## Complex slicing is also supported.
70 me
.assertEqual(x
[5:23:3], C
.bytes("756e206d7472"))
74 Test byte string comparison.
76 This is rather important, since we override it and many of the other
77 tests assume that comparison works.
80 def check(big
, small
):
81 """Check comparisons between BIG and SMALL strings."""
84 me
.assertTrue(big
== big
)
85 me
.assertFalse(big
== small
)
88 me
.assertFalse(big
!= big
)
89 me
.assertTrue(big
!= small
)
92 me
.assertFalse(big
< big
)
93 me
.assertFalse(big
< small
)
94 me
.assertTrue(small
< big
)
96 ## Non-strict less-than.
97 me
.assertTrue(big
<= big
)
98 me
.assertFalse(big
<= small
)
99 me
.assertTrue(small
<= big
)
101 ## Non-strict greater-than.
102 me
.assertTrue(big
>= big
)
103 me
.assertTrue(big
>= small
)
104 me
.assertFalse(small
>= big
)
106 ## Strict greater-than.
107 me
.assertFalse(big
> big
)
108 me
.assertTrue(big
> small
)
109 me
.assertFalse(small
> big
)
111 ## Strings with equal length.
112 check(C
.ByteString(T
.bin("a string which is unlike the second")),
113 C
.ByteString(T
.bin("a string that is not like the first")))
115 ## A string and a prefix of it.
116 check(C
.ByteString(T
.bin("short strings order before longer ones")),
117 C
.ByteString(T
.bin("short string")))
119 ## The `ctstreq' function.
120 x
= T
.bin("special test string")
121 y
= T
.bin("my different string")
122 me
.assertTrue(C
.ctstreq(x
, x
))
123 me
.assertFalse(C
.ctstreq(x
, y
))
125 def test_operators(me
):
127 ## Some example strings.
128 x
= C
.bytes("03a5fc")
129 y
= C
.bytes("5fac30")
130 z
= C
.bytes("00000000")
132 ## Operands of a binary operator must have equal lengths.
133 me
.assertRaises(ValueError, lambda: x
&z
)
134 me
.assertRaises(ValueError, lambda: x|z
)
135 me
.assertRaises(ValueError, lambda: x^z
)
138 me
.assertEqual(type(x
&y
), C
.ByteString
)
139 me
.assertEqual(x
&y
, C
.bytes("03a430"))
142 me
.assertEqual(type(x | y
), C
.ByteString
)
143 me
.assertEqual(x | y
, C
.bytes("5fadfc"))
146 me
.assertEqual(type(x ^ y
), C
.ByteString
)
147 me
.assertEqual(x ^ y
, C
.bytes("5c09cc"))
150 me
.assertEqual(type(~x
), C
.ByteString
)
151 me
.assertEqual(~x
, C
.bytes("fc5a03"))
154 me
.assertEqual(type(x
+ y
), C
.ByteString
)
155 me
.assertEqual(x
+ y
, C
.bytes("03a5fc5fac30"))
157 ## Replication (asymmetric but commutative).
158 me
.assertEqual(type(3*x
), C
.ByteString
)
159 me
.assertEqual(type(x
*3), C
.ByteString
)
160 me
.assertEqual(3*x
, C
.bytes("03a5fc03a5fc03a5fc"))
161 me
.assertEqual(x
*3, C
.bytes("03a5fc03a5fc03a5fc"))
163 ## Replication by zero (regression test).
164 me
.assertEqual(type(0*x
), C
.ByteString
)
165 me
.assertEqual(type(x
*0), C
.ByteString
)
166 me
.assertEqual(0*x
, C
.ByteString(T
.bin("")))
167 me
.assertEqual(x
*0, C
.ByteString(T
.bin("")))
170 me
.assertEqual(C
.ByteString
.zero(7), T
.bin(7*"\0"))
171 me
.assertEqual(C
.ByteString
.zero(0), T
.bin(""))
173 ###----- That's all, folks --------------------------------------------------
175 if __name__
== "__main__": U
.main()