Lib.test.test_list_jy.py Maven / Gradle / Ivy
import unittest
import random
import threading
import time
from test import test_support
import test_list
if test_support.is_jython:
from java.util import ArrayList, LinkedList, Vector
from java.lang import Integer, String
class ListTestCase(unittest.TestCase):
def test_recursive_list_slices(self):
x = [1,2,3,4,5]
x[1:] = x
self.assertEquals(x, [1, 1, 2, 3, 4, 5],
"Recursive assignment to list slices failed")
def test_subclass_richcmp(self):
# http://bugs.jython.org/issue1115
class Foo(list):
def __init__(self, dotstring):
list.__init__(self, map(int, dotstring.split(".")))
bar1 = Foo('1.2.3')
bar2 = Foo('1.2.4')
self.assert_(bar1 < bar2)
self.assert_(bar1 <= bar2)
self.assert_(bar2 > bar1)
self.assert_(bar2 >= bar1)
def test_setget_override(self):
if not test_support.is_jython:
return
# http://bugs.jython.org/issue600790
class GoofyListMapThing(ArrayList):
def __init__(self):
self.silly = "Nothing"
def __setitem__(self, key, element):
self.silly = "spam"
def __getitem__(self, key):
self.silly = "eggs"
glmt = GoofyListMapThing()
glmt['my-key'] = String('el1')
self.assertEquals(glmt.silly, "spam")
glmt['my-key']
self.assertEquals(glmt.silly, "eggs")
def test_tuple_equality(self):
self.assertEqual([(1,), [1]].count([1]), 1) # http://bugs.jython.org/issue1317
def test_big_list(self):
"""Verify that fairly large collection literals of primitives can be constructed."""
# use \n to separate to avoid parser problems
lst = eval("[" + ",\n".join((str(x) for x in xrange(64000))) +"]")
self.assertEqual(len(lst), 64000)
self.assertEqual(sum(lst), 2047968000)
class ThreadSafetyTestCase(unittest.TestCase):
def run_threads(self, f, num=10):
threads = []
for i in xrange(num):
t = threading.Thread(target=f)
t.start()
threads.append(t)
timeout = 10. # be especially generous
for t in threads:
t.join(timeout)
timeout = 0.
for t in threads:
self.assertFalse(t.isAlive())
def test_append_remove(self):
# derived from Itamar Shtull-Trauring's test for issue 521701
lst = []
def tester():
ct = threading.currentThread()
for i in range(1000):
lst.append(ct)
time.sleep(0.0001)
lst.remove(ct)
self.run_threads(tester)
self.assertEqual(lst, [])
def test_sort(self):
lst = []
def tester():
ct = threading.currentThread()
for i in range(1000):
lst.append(ct)
lst.sort()
lst.remove(ct)
time.sleep(0.0001)
self.run_threads(tester)
self.assertEqual(lst, [])
def test_count_reverse(self):
lst = [0,1,2,3,4,5,6,7,8,9,10,0]
def tester():
ct = threading.currentThread()
for i in range(1000):
self.assertEqual(lst[0], 0)
if random.random() > 0.5:
time.sleep(0.0001)
lst.reverse()
self.assertEqual(lst.count(0), 2)
self.assert_(lst[1] in (1,10))
self.run_threads(tester)
class ExtendedSliceTestCase(unittest.TestCase):
'''Really thrash extended slice operations on list.'''
type2test = list
def test_extended_slice_delete(self):
# Based on list_tests.CommonTest.test_extendedslicing .
# In the cited test case, the stop value is nearly always the default
# (None), meaning the end of the list, and often the start value is too.
# This contributed to the release of http://bugs.jython.org/issue1873 .
# This is a supplementary test focused on correct stopping.
initial = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13]
expected1 = self.type2test([ 0, 1, 2, 3, 4, 5, 10,11,12,13])
expected2 = self.type2test([ 0, 1, 2, 4, 6, 8, 10, 12,13])
expected4 = self.type2test([ 0, 1, 3, 4, 5, 7, 8, 9, 11,12,13])
# Positive step
a = self.type2test(initial)
del a[6:10:1]
self.assertEqual(a, expected1)
a = self.type2test(initial)
del a[3:13:2]
self.assertEqual(a, expected2)
a = self.type2test(initial)
del a[3:12:2]
self.assertEqual(a, expected2)
a = self.type2test(initial)
del a[2:11:4]
self.assertEqual(a, expected4)
a = self.type2test(initial)
del a[2::4]
self.assertEqual(a, expected4)
# Negative step (same results)
a = self.type2test(initial)
del a[9:5:-1]
self.assertEqual(a, expected1)
a = self.type2test(initial)
del a[11:1:-2]
self.assertEqual(a, expected2)
a = self.type2test(initial)
del a[11:2:-2]
self.assertEqual(a, expected2)
a = self.type2test(initial)
del a[10:1:-4]
self.assertEqual(a, expected4)
a = self.type2test(initial)
del a[10::-4]
self.assertEqual(a, expected4)
def test_extended_slice_assign(self):
# Based on list_tests.CommonTest.test_extendedslicing .
# In the cited test case, the stop value is nearly always the default.
# This is a supplementary test focused on correct stopping.
aa, bb, cc = 91, 92, 93
src = self.type2test([aa,bb,cc])
initial = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13]
expected1 = self.type2test([ 0, 1, 2, 3, 4, 5,aa,bb,cc, 9,10,11,12,13])
expected2 = self.type2test([ 0, 1, 2,aa, 4,bb, 6,cc, 8, 9,10,11,12,13])
expected4 = self.type2test([ 0, 1,aa, 3, 4, 5,bb, 7, 8, 9,cc,11,12,13])
# Positive step
a = self.type2test(initial)
a[6:9:1] = src
self.assertEqual(a, expected1)
a = self.type2test(initial)
a[3:9:2] = src
self.assertEqual(a, expected2)
a = self.type2test(initial)
a[3:8:2] = src
self.assertEqual(a, expected2)
a = self.type2test(initial)
a[2:11:4] = src
self.assertEqual(a, expected4)
a = self.type2test(initial)
a[2::4] = src
self.assertEqual(a, expected4)
# Negative step (same results, as src is reversed)
src.reverse()
a = self.type2test(initial)
a[8:5:-1] = src
self.assertEqual(a, expected1)
a = self.type2test(initial)
a[7:2:-2] = src
self.assertEqual(a, expected2)
a = self.type2test(initial)
a[7:1:-2] = src
self.assertEqual(a, expected2)
a = self.type2test(initial)
a[10:1:-4] = src
self.assertEqual(a, expected4)
a = self.type2test(initial)
a[10::-4] = src
self.assertEqual(a, expected4)
class JavaListTestCase(test_list.ListTest):
type2test = ArrayList
def test_init(self):
# Iterable arg is optional
self.assertEqual(self.type2test([]), self.type2test())
# Unlike with builtin types, we do not guarantee objects can
# be overwritten; see corresponding tests
# Mutables always return a new object
a = self.type2test([1, 2, 3])
b = self.type2test(a)
self.assertNotEqual(id(a), id(b))
self.assertEqual(a, b)
def test_extend_java_ArrayList(self):
jl = self.type2test([])
jl.extend([1,2])
self.assertEqual(jl, self.type2test([1,2]))
jl.extend(self.type2test([3,4]))
self.assertEqual(jl, [1,2,3,4])
def test_remove(self):
# Verifies that overloaded java.util.List#remove(int) method can still be used, but with Python index semantics
# http://bugs.jython.org/issue2456
jl = self.type2test(xrange(10, -1, -1)) # 10 .. 0, inclusive
jl.remove(0) # removes jl[-1] (=0)
self.assertEqual(jl, range(10, 0, -1)) # 10 .. 1
self.assertRaises(ValueError, jl.remove, Integer(0)) # j.l.Integer does not support __index__ - maybe it should!
jl.remove(0) # removes jl[0] (=10)
self.assertEqual(jl, range(9, 0, -1)) # 9 .. 1
jl.remove(-1) # removes jl[-1] (=1) - support same index calculations as Python (= del jl[-1])
self.assertEqual(jl, range(9, 1, -1)) # 9 .. 2
jl.remove(3)
jl.remove(5)
self.assertEqual(jl, [9, 8, 7, 6, 4, 2])
a_to_z = list(chr(i) for i in xrange(ord('a'), ord('z') + 1))
b_to_z_by_2 = list(chr(i) for i in xrange(ord('b'), ord('z') + 1, 2))
jl = self.type2test(a_to_z)
for i in xrange(13):
jl.remove(i)
self.assertEqual(jl, b_to_z_by_2)
def test_concat(self):
# See http://bugs.jython.org/issue2688
lst = ArrayList([1, 2, 3])
lst2 = [4, 5, 6]
self.assertEquals(lst+lst2, [1, 2, 3, 4, 5, 6])
self.assertEquals(lst2+lst, [4, 5, 6, 1, 2, 3])
def test_equality_empty_list(self):
jl = self.type2test()
self.assertTrue(jl == [])
self.assertTrue([] == jl)
def test_equality_simple_list(self):
jl = self.type2test()
self.assertFalse(jl == [1])
self.assertFalse([1] == jl)
def test_equality_mixed_types_list(self):
ref = [False, 1, 3**9, "3"]
alt = [0, True, 3L**9, u"3"]
self.assertEqual(ref, alt) # test assumption
jref = self.type2test(ref)
for v in [ref, alt, jref]:
self.assertTrue(jref == v)
self.assertTrue(v == jref)
self.assertTrue(jref == self.type2test(v))
alt = [False, 1, 2e4, "3"]
for v in [alt, ref[:-1], ref+[{}], []]:
self.assertFalse(jref == v)
self.assertFalse(v == jref)
self.assertFalse(jref == self.type2test(v))
# Test for http://bugs.jython.org/issue2639
# This is to test the != comparisons between Java and Python lists
def test_inequality_empty_list(self):
jl = self.type2test()
self.assertFalse(jl != [])
self.assertFalse([] != jl)
def test_inequality_simple_list(self):
jl = self.type2test()
self.assertTrue(jl != [1])
self.assertTrue([1] != jl)
def test_inequality_mixed_types_list(self):
ref = [False, 1, 3**9, "3"]
alt = [0, True, 3L**9, u"3"]
self.assertEqual(ref, alt) # test assumption
jref = self.type2test(ref)
for v in [ref, alt, jref]:
self.assertFalse(jref != v)
self.assertFalse(v != jref)
self.assertFalse(jref != self.type2test(v))
alt = [False, 1, 2e4, "3"]
for v in [alt, ref[:-1], ref+[{}], []]:
self.assertTrue(jref != v)
self.assertTrue(v != jref)
self.assertTrue(jref != self.type2test(v))
class JavaArrayListTestCase(JavaListTestCase):
type2test = ArrayList
class JavaLinkedListTestCase(JavaListTestCase):
type2test = LinkedList
@unittest.skip("Fails for LinkedList see http://bugs.jython.org/issue2645")
def test_pop(self):
pass
@unittest.skip("Seems to hang for linked list")
def test_bigrepeat(self):
pass
@unittest.skip("Takes a long time and can cause OutOfMemory")
def test_overflow(self):
pass
class JavaVectorTestCase(JavaListTestCase):
type2test = Vector
@unittest.skip("Takes a long time and can cause OutOfMemory")
def test_bigrepeat(self):
pass
class ListSubclassTestCase(unittest.TestCase):
def test_subclass_iter_copy(self):
class MyList(list):
def __iter__(self):
i = 0
results = super(MyList, self).__iter__()
for result in results:
yield result
i += 1
# add extra result for validation
yield i
lst = MyList(['a', 'b', 'c'])
self.assertEqual(list(lst), ['a', 'b', 'c', 3])
def test_subclass_iter_does_not_call_other_special_methods(self):
# Verify fix for http://bugs.jython.org/issue2442
class C(list):
def __init__(self, *args):
self.called = False
return super(C, type(self)).__init__(self, *args)
def __len__(self):
self.called = True
return super(C, type(self)).__len__(self)
def __getitem__(self, index):
self.called = True
return super(C, type(self)).__getitem__(self, index)
c = C(range(10))
self.assertEqual(list(iter(c)), range(10))
self.assertFalse(c.called)
def test_main():
test_support.run_unittest(ListTestCase,
ThreadSafetyTestCase,
ExtendedSliceTestCase,
JavaArrayListTestCase,
JavaLinkedListTestCase,
JavaVectorTestCase,
ListSubclassTestCase)
if __name__ == "__main__":
test_main()
© 2015 - 2025 Weber Informatics LLC | Privacy Policy