def testMap(self):
maps = [
{ 1: 0 },
{ 2: 'asdf' },
{ 'asdf':2 },
{
1: 2,
2: 3,
4: 4,
'asdf': 123,
(1,2): [4,5,'hello world']
}
]
maps[3][(1,2)].append(maps)
fname = 'test_map.map'
for test_i, m in enumerate(maps):
pointless.serialize(m, fname)
root_a = pointless.Pointless(fname).GetRoot()
for k in m.iterkeys():
self.assert_(k in root_a)
v_m = m[k]
v_a = root_a[k]
self.assert_(pointless.pointless_cmp(v_m, v_a) == 0)
del root_a
def test_vector_slice(self):
random.seed(0)
vector = list(range(1000))
for v_py, v_po in VectorSlices('deleteme.map', vector):
c = pointless.pointless_cmp(v_py, v_po)
self.assertEquals(c, 0)
def test_vector_slice(self):
random.seed(0)
vector = range(1000)
for v_py, v_po in VectorSlices('deleteme.map', vector):
c = pointless.pointless_cmp(v_py, v_po)
self.assertEquals(c, 0)
def testMap(self):
maps = [{
1: 0
}, {
2: 'asdf'
}, {
'asdf': 2
}, {
1: 2,
2: 3,
4: 4,
'asdf': 123,
(1, 2): [4, 5, 'hello world']
}]
maps[-1][(1, 2)].append(maps)
fname = 'test_map.map'
for test_i, m in enumerate(maps):
pointless.serialize(m, fname)
root_a = pointless.Pointless(fname).GetRoot()
for k in six.iterkeys(m):
self.assert_(k in root_a)
v_m = m[k]
v_a = root_a[k]
if not self._contains_dict_or_set(v_m):
self.assert_(pointless.pointless_cmp(v_m, v_a) == 0)
del root_a
def _testTotalOrder(self, values): # we're testing, for each 3-combination of values for i, (v_a, v_b, v_c) in enumerate(itertools.product(values, values, values)): # print 'total order', i, len(values) ** 3 # write the values out p_a = serialize_and_get(v_a) p_b = serialize_and_get(v_b) p_c = serialize_and_get(v_c) # test (a > b) <=> (a < b) cmp_ab = sign(pointless.pointless_cmp(p_a, p_b)) cmp_ba = sign(pointless.pointless_cmp(p_b, p_a)) self.assert_(cmp_ab == -cmp_ba) cmp_ac = sign(pointless.pointless_cmp(p_a, p_c)) cmp_ca = sign(pointless.pointless_cmp(p_c, p_a)) self.assert_(cmp_ac == -cmp_ca) cmp_bc = sign(pointless.pointless_cmp(p_b, p_c)) cmp_cb = sign(pointless.pointless_cmp(p_c, p_b)) self.assert_(cmp_bc == -cmp_cb) # a <= b and b <= a -> a == b self.assert_(not (cmp_ab in (-1, 0) and cmp_ba in (-1, 0) and cmp_ab != 0)) # a <= b and b <= c -> a <= c self.assert_(not (cmp_ab in (-1, 0) and cmp_bc in (-1, 0) and cmp_ac not in (-1, 0))) # a <= b or b <= a self.assert_(cmp_ab in (-1, 0) or cmp_ba in (-1, 0)) del p_a del p_b del p_c
def _testPythonCmp(self, values):
for i, (v_a, v_b) in enumerate(itertools.product(values, values)):
# test against python
cmp_failure = False
try:
py_cmp = sign(cmp(v_a, v_b))
except TypeError as e:
if six.PY3 and 'not supported between instances of ' in str(e):
cmp_failure = True
elif six.PY3 and 'unorderable types' in str(e):
cmp_failure = True
else:
raise
p_a = serialize_and_get(v_a)
p_b = serialize_and_get(v_b)
if cmp_failure:
self.assertRaises(TypeError, pointless.pointless_cmp, p_a, p_b)
self.assertRaises(TypeError, pointless.pointless_cmp, p_a, v_b)
self.assertRaises(TypeError, pointless.pointless_cmp, v_a, p_b)
self.assertRaises(TypeError, pointless.pointless_cmp, v_a, v_b)
else:
p_cmp_a = sign(pointless.pointless_cmp(p_a, p_b))
p_cmp_b = sign(pointless.pointless_cmp(p_a, v_b))
p_cmp_c = sign(pointless.pointless_cmp(v_a, p_b))
p_cmp_d = sign(pointless.pointless_cmp(v_a, v_b))
self.assertEqual(p_cmp_a, p_cmp_b)
self.assertEqual(p_cmp_a, p_cmp_c)
self.assertEqual(p_cmp_a, p_cmp_d)
# we're only interested in pointless/python compatibility for equality matcing
self.assert_(not (
(py_cmp == 0 or p_cmp_a == 0) and p_cmp_a != py_cmp))
del p_a
del p_b
def _testPythonCmp(self, values): for i, (v_a, v_b) in enumerate(itertools.product(values, values)): # print 'cmp', i, len(values) ** 2 p_a = serialize_and_get(v_a) p_b = serialize_and_get(v_b) p_cmp_a = sign(pointless.pointless_cmp(p_a, p_b)) p_cmp_b = sign(pointless.pointless_cmp(p_a, v_b)) p_cmp_c = sign(pointless.pointless_cmp(v_a, p_b)) p_cmp_d = sign(pointless.pointless_cmp(v_a, v_b)) self.assertEqual(p_cmp_a, p_cmp_b) self.assertEqual(p_cmp_a, p_cmp_c) self.assertEqual(p_cmp_a, p_cmp_d) # test against python py_cmp = sign(cmp(v_a, v_b)) # we're only interested in pointless/python compatibility for equality matcing self.assert_(not ((py_cmp == 0 or p_cmp_a == 0) and p_cmp_a != py_cmp)) del p_a del p_b
def testEvilCases(self):
for value, comparable in self.bad_case_iter():
pointless.serialize(value, 'file.map')
svalue = pointless.Pointless('file.map').GetRoot()
if comparable:
self.assertEquals(pointless.pointless_cmp(value, svalue), 0)
s_a = str(value)
s_b = str(svalue)
# stringifaction of dicts/set does not have a consistent ordering
if comparable:
if not self._contains_dict_or_set(value):
self.assertEquals(s_a, s_b)
def _testTotalOrder(self, values):
# we're testing, for each 3-combination of values
for i, (v_a, v_b,
v_c) in enumerate(itertools.product(values, values, values)):
# print 'total order', i, len(values) ** 3
# write the values out
p_a = serialize_and_get(v_a)
p_b = serialize_and_get(v_b)
p_c = serialize_and_get(v_c)
is_type_error_ab = False
is_type_error_ac = False
is_type_error_bc = False
try:
cmp(p_a, p_b)
except TypeError:
is_type_error_ab = True
try:
cmp(p_a, p_c)
except TypeError:
is_type_error_ac = True
try:
cmp(p_b, p_c)
except TypeError:
is_type_error_bc = True
if not (is_type_error_ab or is_type_error_ac or is_type_error_bc):
# test (a > b) <=> (a < b)
cmp_ab = sign(pointless.pointless_cmp(p_a, p_b))
cmp_ba = sign(pointless.pointless_cmp(p_b, p_a))
self.assert_(cmp_ab == -cmp_ba)
cmp_ac = sign(pointless.pointless_cmp(p_a, p_c))
cmp_ca = sign(pointless.pointless_cmp(p_c, p_a))
self.assert_(cmp_ac == -cmp_ca)
cmp_bc = sign(pointless.pointless_cmp(p_b, p_c))
cmp_cb = sign(pointless.pointless_cmp(p_c, p_b))
self.assert_(cmp_bc == -cmp_cb)
# a <= b and b <= a -> a == b
self.assert_(not (
cmp_ab in (-1, 0) and cmp_ba in (-1, 0) and cmp_ab != 0))
# a <= b and b <= c -> a <= c
self.assert_(not (cmp_ab in (-1, 0) and cmp_bc in
(-1, 0) and cmp_ac not in (-1, 0)))
# a <= b or b <= a
self.assert_(cmp_ab in (-1, 0) or cmp_ba in (-1, 0))
else:
try:
pointless.pointless_cmp(p_a, p_b)
pointless.pointless_cmp(p_b, p_a)
pointless.pointless_cmp(p_a, p_c)
pointless.pointless_cmp(p_c, p_a)
pointless.pointless_cmp(p_b, p_c)
pointless.pointless_cmp(p_c, p_b)
self.fail('some of these should have raised TypeError')
except TypeError:
pass
del p_a
del p_b
del p_c
