Skip to content

Commit 8302e5c

Browse files
author
James William Pye
committed
Use assert*.
1 parent 4ddc8ce commit 8302e5c

1 file changed

Lines changed: 113 additions & 113 deletions

File tree

‎postgresql/test/test_optimized.py‎

Lines changed: 113 additions & 113 deletions
Original file line numberDiff line numberDiff line change
@@ -28,36 +28,36 @@ class test_optimized(unittest.TestCase):
2828
def test_consume_tuple_messages(self):
2929
ctm = optimized.consume_tuple_messages
3030
# expecting a tuple of pairs.
31-
self.failUnlessRaises(TypeError, ctm, [])
32-
self.failUnlessEqual(ctm(()), [])
31+
self.assertRaises(TypeError, ctm, [])
32+
self.assertEqual(ctm(()), [])
3333
# Make sure that the slicing is working.
34-
self.failUnlessEqual(ctm(tuplemessages), [
34+
self.assertEqual(ctm(tuplemessages), [
3535
(b'foo', b'bar'),
3636
(b'foo', None, b'bar'),
3737
])
3838
# Not really checking consume here, but we are validating that
3939
# it's properly propagating exceptions.
40-
self.failUnlessRaises(ValueError, ctm, ((b'D', b'\xff\xff\xff\xfefoo'),))
41-
self.failUnlessRaises(ValueError, ctm, ((b'D', b'\x00\x00\x00\x04foo'),))
40+
self.assertRaises(ValueError, ctm, ((b'D', b'\xff\xff\xff\xfefoo'),))
41+
self.assertRaises(ValueError, ctm, ((b'D', b'\x00\x00\x00\x04foo'),))
4242

4343
def test_parse_tuple_message(self):
4444
ptm = optimized.parse_tuple_message
45-
self.failUnlessRaises(TypeError, ptm, "stringzor")
46-
self.failUnlessRaises(TypeError, ptm, 123)
47-
self.failUnlessRaises(ValueError, ptm, b'')
48-
self.failUnlessRaises(ValueError, ptm, b'0')
45+
self.assertRaises(TypeError, ptm, "stringzor")
46+
self.assertRaises(TypeError, ptm, 123)
47+
self.assertRaises(ValueError, ptm, b'')
48+
self.assertRaises(ValueError, ptm, b'0')
4949

5050
notenoughdata = struct.pack('!H', 2)
51-
self.failUnlessRaises(ValueError, ptm, notenoughdata)
51+
self.assertRaises(ValueError, ptm, notenoughdata)
5252

5353
wraparound = struct.pack('!HL', 2, 10) + (b'0' * 10) + struct.pack('!L', 0xFFFFFFFE)
54-
self.failUnlessRaises(ValueError, ptm, wraparound)
54+
self.assertRaises(ValueError, ptm, wraparound)
5555

5656
oneatt_notenough = struct.pack('!HL', 2, 10) + (b'0' * 10) + struct.pack('!L', 15)
57-
self.failUnlessRaises(ValueError, ptm, oneatt_notenough)
57+
self.assertRaises(ValueError, ptm, oneatt_notenough)
5858

5959
toomuchdata = struct.pack('!HL', 1, 3) + (b'0' * 10)
60-
self.failUnlessRaises(ValueError, ptm, toomuchdata)
60+
self.assertRaises(ValueError, ptm, toomuchdata)
6161

6262
class faketup(tuple):
6363
def __new__(subtype, geeze):
@@ -66,31 +66,31 @@ def __new__(subtype, geeze):
6666
return r
6767
zerodata = struct.pack('!H', 0)
6868
r = ptm(zerodata)
69-
self.failUnlessRaises(AttributeError, getattr, r, 'foo')
70-
self.failUnlessRaises(AttributeError, setattr, r, 'foo', 'bar')
71-
self.failUnlessEqual(len(r), 0)
69+
self.assertRaises(AttributeError, getattr, r, 'foo')
70+
self.assertRaises(AttributeError, setattr, r, 'foo', 'bar')
71+
self.assertEqual(len(r), 0)
7272

7373
def test_process_tuple(self):
7474
def funpass(procs, tup, col):
7575
pass
7676
pt = optimized.process_tuple
7777
# tuple() requirements
78-
self.failUnlessRaises(TypeError, pt, "foo", "bar", funpass)
79-
self.failUnlessRaises(TypeError, pt, (), "bar", funpass)
80-
self.failUnlessRaises(TypeError, pt, "foo", (), funpass)
81-
self.failUnlessRaises(TypeError, pt, (), ("foo",), funpass)
78+
self.assertRaises(TypeError, pt, "foo", "bar", funpass)
79+
self.assertRaises(TypeError, pt, (), "bar", funpass)
80+
self.assertRaises(TypeError, pt, "foo", (), funpass)
81+
self.assertRaises(TypeError, pt, (), ("foo",), funpass)
8282

8383
def test_pack_tuple_data(self):
8484
pit = optimized.pack_tuple_data
85-
self.failUnlessEqual(pit((None,)), b'\xff\xff\xff\xff')
86-
self.failUnlessEqual(pit((None,)*2), b'\xff\xff\xff\xff'*2)
87-
self.failUnlessEqual(pit((None,)*3), b'\xff\xff\xff\xff'*3)
88-
self.failUnlessEqual(pit((None,b'foo')), b'\xff\xff\xff\xff\x00\x00\x00\x03foo')
89-
self.failUnlessEqual(pit((None,b'')), b'\xff\xff\xff\xff\x00\x00\x00\x00')
90-
self.failUnlessEqual(pit((None,b'',b'bar')), b'\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x03bar')
91-
self.failUnlessRaises(TypeError, pit, 1)
92-
self.failUnlessRaises(TypeError, pit, (1,))
93-
self.failUnlessRaises(TypeError, pit, ("",))
85+
self.assertEqual(pit((None,)), b'\xff\xff\xff\xff')
86+
self.assertEqual(pit((None,)*2), b'\xff\xff\xff\xff'*2)
87+
self.assertEqual(pit((None,)*3), b'\xff\xff\xff\xff'*3)
88+
self.assertEqual(pit((None,b'foo')), b'\xff\xff\xff\xff\x00\x00\x00\x03foo')
89+
self.assertEqual(pit((None,b'')), b'\xff\xff\xff\xff\x00\x00\x00\x00')
90+
self.assertEqual(pit((None,b'',b'bar')), b'\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x03bar')
91+
self.assertRaises(TypeError, pit, 1)
92+
self.assertRaises(TypeError, pit, (1,))
93+
self.assertRaises(TypeError, pit, ("",))
9494

9595
def test_int2(self):
9696
d = b'\x00\x01'
@@ -100,19 +100,19 @@ def test_int2(self):
100100
sd = optimized.swap_int2_pack(1)
101101
nd = optimized.int2_pack(1)
102102
if sys.byteorder == 'little':
103-
self.failUnlessEqual(1, s)
104-
self.failUnlessEqual(256, n)
105-
self.failUnlessEqual(d, sd)
106-
self.failUnlessEqual(rd, nd)
103+
self.assertEqual(1, s)
104+
self.assertEqual(256, n)
105+
self.assertEqual(d, sd)
106+
self.assertEqual(rd, nd)
107107
else:
108-
self.failUnlessEqual(1, n)
109-
self.failUnlessEqual(256, s)
110-
self.failUnlessEqual(d, nd)
111-
self.failUnlessEqual(rd, sd)
112-
self.failUnlessRaises(OverflowError, optimized.swap_int2_pack, 2**15)
113-
self.failUnlessRaises(OverflowError, optimized.int2_pack, 2**15)
114-
self.failUnlessRaises(OverflowError, optimized.swap_int2_pack, (-2**15)-1)
115-
self.failUnlessRaises(OverflowError, optimized.int2_pack, (-2**15)-1)
108+
self.assertEqual(1, n)
109+
self.assertEqual(256, s)
110+
self.assertEqual(d, nd)
111+
self.assertEqual(rd, sd)
112+
self.assertRaises(OverflowError, optimized.swap_int2_pack, 2**15)
113+
self.assertRaises(OverflowError, optimized.int2_pack, 2**15)
114+
self.assertRaises(OverflowError, optimized.swap_int2_pack, (-2**15)-1)
115+
self.assertRaises(OverflowError, optimized.int2_pack, (-2**15)-1)
116116

117117
def test_int4(self):
118118
d = b'\x00\x00\x00\x01'
@@ -122,19 +122,19 @@ def test_int4(self):
122122
sd = optimized.swap_int4_pack(1)
123123
nd = optimized.int4_pack(1)
124124
if sys.byteorder == 'little':
125-
self.failUnlessEqual(1, s)
126-
self.failUnlessEqual(16777216, n)
127-
self.failUnlessEqual(d, sd)
128-
self.failUnlessEqual(rd, nd)
125+
self.assertEqual(1, s)
126+
self.assertEqual(16777216, n)
127+
self.assertEqual(d, sd)
128+
self.assertEqual(rd, nd)
129129
else:
130-
self.failUnlessEqual(1, n)
131-
self.failUnlessEqual(16777216, s)
132-
self.failUnlessEqual(d, nd)
133-
self.failUnlessEqual(rd, sd)
134-
self.failUnlessRaises(OverflowError, optimized.swap_int4_pack, 2**31)
135-
self.failUnlessRaises(OverflowError, optimized.int4_pack, 2**31)
136-
self.failUnlessRaises(OverflowError, optimized.swap_int4_pack, (-2**31)-1)
137-
self.failUnlessRaises(OverflowError, optimized.int4_pack, (-2**31)-1)
130+
self.assertEqual(1, n)
131+
self.assertEqual(16777216, s)
132+
self.assertEqual(d, nd)
133+
self.assertEqual(rd, sd)
134+
self.assertRaises(OverflowError, optimized.swap_int4_pack, 2**31)
135+
self.assertRaises(OverflowError, optimized.int4_pack, 2**31)
136+
self.assertRaises(OverflowError, optimized.swap_int4_pack, (-2**31)-1)
137+
self.assertRaises(OverflowError, optimized.int4_pack, (-2**31)-1)
138138

139139
def test_int8(self):
140140
d = b'\x00\x00\x00\x00\x00\x00\x00\x01'
@@ -144,32 +144,32 @@ def test_int8(self):
144144
sd = optimized.swap_int8_pack(1)
145145
nd = optimized.int8_pack(1)
146146
if sys.byteorder == 'little':
147-
self.failUnlessEqual(0x1, s)
148-
self.failUnlessEqual(0x100000000000000, n)
149-
self.failUnlessEqual(d, sd)
150-
self.failUnlessEqual(rd, nd)
147+
self.assertEqual(0x1, s)
148+
self.assertEqual(0x100000000000000, n)
149+
self.assertEqual(d, sd)
150+
self.assertEqual(rd, nd)
151151
else:
152-
self.failUnlessEqual(0x1, n)
153-
self.failUnlessEqual(0x100000000000000, s)
154-
self.failUnlessEqual(d, nd)
155-
self.failUnlessEqual(rd, sd)
156-
self.failUnlessEqual(optimized.swap_int8_pack(-1), b'\xFF\xFF\xFF\xFF'*2)
157-
self.failUnlessEqual(optimized.int8_pack(-1), b'\xFF\xFF\xFF\xFF'*2)
158-
self.failUnlessRaises(OverflowError, optimized.swap_int8_pack, 2**63)
159-
self.failUnlessRaises(OverflowError, optimized.int8_pack, 2**63)
160-
self.failUnlessRaises(OverflowError, optimized.swap_int8_pack, (-2**63)-1)
161-
self.failUnlessRaises(OverflowError, optimized.int8_pack, (-2**63)-1)
152+
self.assertEqual(0x1, n)
153+
self.assertEqual(0x100000000000000, s)
154+
self.assertEqual(d, nd)
155+
self.assertEqual(rd, sd)
156+
self.assertEqual(optimized.swap_int8_pack(-1), b'\xFF\xFF\xFF\xFF'*2)
157+
self.assertEqual(optimized.int8_pack(-1), b'\xFF\xFF\xFF\xFF'*2)
158+
self.assertRaises(OverflowError, optimized.swap_int8_pack, 2**63)
159+
self.assertRaises(OverflowError, optimized.int8_pack, 2**63)
160+
self.assertRaises(OverflowError, optimized.swap_int8_pack, (-2**63)-1)
161+
self.assertRaises(OverflowError, optimized.int8_pack, (-2**63)-1)
162162
# edge I/O
163163
int8_max = ((2**63) - 1)
164164
int8_min = (-(2**63))
165165
swap_max = optimized.swap_int8_pack(int8_max)
166166
max = optimized.int8_pack(int8_max)
167167
swap_min = optimized.swap_int8_pack(int8_min)
168168
min = optimized.int8_pack(int8_min)
169-
self.failUnlessEqual(optimized.swap_int8_unpack(swap_max), int8_max)
170-
self.failUnlessEqual(optimized.int8_unpack(max), int8_max)
171-
self.failUnlessEqual(optimized.swap_int8_unpack(swap_min), int8_min)
172-
self.failUnlessEqual(optimized.int8_unpack(min), int8_min)
169+
self.assertEqual(optimized.swap_int8_unpack(swap_max), int8_max)
170+
self.assertEqual(optimized.int8_unpack(max), int8_max)
171+
self.assertEqual(optimized.swap_int8_unpack(swap_min), int8_min)
172+
self.assertEqual(optimized.int8_unpack(min), int8_min)
173173

174174
def test_uint2(self):
175175
d = b'\x00\x01'
@@ -179,21 +179,21 @@ def test_uint2(self):
179179
sd = optimized.swap_uint2_pack(1)
180180
nd = optimized.uint2_pack(1)
181181
if sys.byteorder == 'little':
182-
self.failUnlessEqual(1, s)
183-
self.failUnlessEqual(256, n)
184-
self.failUnlessEqual(d, sd)
185-
self.failUnlessEqual(rd, nd)
182+
self.assertEqual(1, s)
183+
self.assertEqual(256, n)
184+
self.assertEqual(d, sd)
185+
self.assertEqual(rd, nd)
186186
else:
187-
self.failUnlessEqual(1, n)
188-
self.failUnlessEqual(256, s)
189-
self.failUnlessEqual(d, nd)
190-
self.failUnlessEqual(rd, sd)
191-
self.failUnlessRaises(OverflowError, optimized.swap_uint2_pack, -1)
192-
self.failUnlessRaises(OverflowError, optimized.uint2_pack, -1)
193-
self.failUnlessRaises(OverflowError, optimized.swap_uint2_pack, 2**16)
194-
self.failUnlessRaises(OverflowError, optimized.uint2_pack, 2**16)
195-
self.failUnlessEqual(optimized.uint2_pack(2**16-1), b'\xFF\xFF')
196-
self.failUnlessEqual(optimized.swap_uint2_pack(2**16-1), b'\xFF\xFF')
187+
self.assertEqual(1, n)
188+
self.assertEqual(256, s)
189+
self.assertEqual(d, nd)
190+
self.assertEqual(rd, sd)
191+
self.assertRaises(OverflowError, optimized.swap_uint2_pack, -1)
192+
self.assertRaises(OverflowError, optimized.uint2_pack, -1)
193+
self.assertRaises(OverflowError, optimized.swap_uint2_pack, 2**16)
194+
self.assertRaises(OverflowError, optimized.uint2_pack, 2**16)
195+
self.assertEqual(optimized.uint2_pack(2**16-1), b'\xFF\xFF')
196+
self.assertEqual(optimized.swap_uint2_pack(2**16-1), b'\xFF\xFF')
197197

198198
def test_uint4(self):
199199
d = b'\x00\x00\x00\x01'
@@ -203,21 +203,21 @@ def test_uint4(self):
203203
sd = optimized.swap_uint4_pack(1)
204204
nd = optimized.uint4_pack(1)
205205
if sys.byteorder == 'little':
206-
self.failUnlessEqual(1, s)
207-
self.failUnlessEqual(16777216, n)
208-
self.failUnlessEqual(d, sd)
209-
self.failUnlessEqual(rd, nd)
206+
self.assertEqual(1, s)
207+
self.assertEqual(16777216, n)
208+
self.assertEqual(d, sd)
209+
self.assertEqual(rd, nd)
210210
else:
211-
self.failUnlessEqual(1, n)
212-
self.failUnlessEqual(16777216, s)
213-
self.failUnlessEqual(d, nd)
214-
self.failUnlessEqual(rd, sd)
215-
self.failUnlessRaises(OverflowError, optimized.swap_uint4_pack, -1)
216-
self.failUnlessRaises(OverflowError, optimized.uint4_pack, -1)
217-
self.failUnlessRaises(OverflowError, optimized.swap_uint4_pack, 2**32)
218-
self.failUnlessRaises(OverflowError, optimized.uint4_pack, 2**32)
219-
self.failUnlessEqual(optimized.uint4_pack(2**32-1), b'\xFF\xFF\xFF\xFF')
220-
self.failUnlessEqual(optimized.swap_uint4_pack(2**32-1), b'\xFF\xFF\xFF\xFF')
211+
self.assertEqual(1, n)
212+
self.assertEqual(16777216, s)
213+
self.assertEqual(d, nd)
214+
self.assertEqual(rd, sd)
215+
self.assertRaises(OverflowError, optimized.swap_uint4_pack, -1)
216+
self.assertRaises(OverflowError, optimized.uint4_pack, -1)
217+
self.assertRaises(OverflowError, optimized.swap_uint4_pack, 2**32)
218+
self.assertRaises(OverflowError, optimized.uint4_pack, 2**32)
219+
self.assertEqual(optimized.uint4_pack(2**32-1), b'\xFF\xFF\xFF\xFF')
220+
self.assertEqual(optimized.swap_uint4_pack(2**32-1), b'\xFF\xFF\xFF\xFF')
221221

222222
def test_uint8(self):
223223
d = b'\x00\x00\x00\x00\x00\x00\x00\x01'
@@ -227,21 +227,21 @@ def test_uint8(self):
227227
sd = optimized.swap_uint8_pack(1)
228228
nd = optimized.uint8_pack(1)
229229
if sys.byteorder == 'little':
230-
self.failUnlessEqual(0x1, s)
231-
self.failUnlessEqual(0x100000000000000, n)
232-
self.failUnlessEqual(d, sd)
233-
self.failUnlessEqual(rd, nd)
230+
self.assertEqual(0x1, s)
231+
self.assertEqual(0x100000000000000, n)
232+
self.assertEqual(d, sd)
233+
self.assertEqual(rd, nd)
234234
else:
235-
self.failUnlessEqual(0x1, n)
236-
self.failUnlessEqual(0x100000000000000, s)
237-
self.failUnlessEqual(d, nd)
238-
self.failUnlessEqual(rd, sd)
239-
self.failUnlessRaises(OverflowError, optimized.swap_uint8_pack, -1)
240-
self.failUnlessRaises(OverflowError, optimized.uint8_pack, -1)
241-
self.failUnlessRaises(OverflowError, optimized.swap_uint8_pack, 2**64)
242-
self.failUnlessRaises(OverflowError, optimized.uint8_pack, 2**64)
243-
self.failUnlessEqual(optimized.uint8_pack((2**64)-1), b'\xFF\xFF\xFF\xFF'*2)
244-
self.failUnlessEqual(optimized.swap_uint8_pack((2**64)-1), b'\xFF\xFF\xFF\xFF'*2)
235+
self.assertEqual(0x1, n)
236+
self.assertEqual(0x100000000000000, s)
237+
self.assertEqual(d, nd)
238+
self.assertEqual(rd, sd)
239+
self.assertRaises(OverflowError, optimized.swap_uint8_pack, -1)
240+
self.assertRaises(OverflowError, optimized.uint8_pack, -1)
241+
self.assertRaises(OverflowError, optimized.swap_uint8_pack, 2**64)
242+
self.assertRaises(OverflowError, optimized.uint8_pack, 2**64)
243+
self.assertEqual(optimized.uint8_pack((2**64)-1), b'\xFF\xFF\xFF\xFF'*2)
244+
self.assertEqual(optimized.swap_uint8_pack((2**64)-1), b'\xFF\xFF\xFF\xFF'*2)
245245

246246
if __name__ == '__main__':
247247
from types import ModuleType

0 commit comments

Comments
 (0)