def test_distinct(self):
e = linqy.make([1,2,3,2,1]).distinct()
self.assertEqual(list(e), [1,2,3])
e = linqy.make([(1,2),(2,3),(2,2),(1,4)]).distinct(lambda x: x[0])
self.assertEqual(list(e), [(1,2),(2,3)])
e = linqy.make([(1,2),(2,3),(2,2),(1,4)]).distinct(lambda x: x[1])
self.assertEqual(list(e), [(1,2),(2,3),(1,4)])
def test_selectmany(self):
e = linqy.make([1,2,3]).selectmany(lambda x: [x, x * 2])
self.assertEqual(list(e), [1,2,2,4,3,6])
e = linqy.make([1,2,3]).selectmany(lambda x, i: [(i, x), i * x])
self.assertEqual(list(e), [(0,1),0,(1,2),2,(2,3),6])
e = linqy.make([1,2,3]).selectmany(lambda x: range(x), result=lambda x, y: y)
self.assertEqual(list(e), [0,0,1,0,1,2])
def test_do(self):
e = linqy.make([1,2,3]).do(self.add)
self.assertEqual(self.num, 0)
list(e)
self.assertEqual(self.num, 6)
e = linqy.make([1,2,3]).do(self.addi)
self.assertEqual(self.num, 6)
list(e)
self.assertEqual(self.num, 12)
def test_contains(self):
self.assertTrue(linqy.make([(1,2),(2,3),(3,4)]).contains((2,3)))
self.assertTrue(linqy.make([1,2,3,4,5]).contains(2))
self.assertFalse(linqy.make([1,2,3,4,5]).contains(8))
self.assertTrue(linqy.make([(1,2),(2,3),(3,4)]).contains((2,3)))
self.assertFalse(linqy.make([(1,2),(2,3),(3,4)]).contains(6))
self.assertFalse(linqy.make([(1,2),(2,3),(3,4)]).contains((5,6)))
self.assertTrue(linqy.make([(1,2),(2,3),(3,4)]).contains(1, lambda x: x[0]))
self.assertFalse(linqy.make([(1,2),(2,3),(3,4)]).contains(8, lambda x: x[0]))
self.assertFalse(linqy.make([(1,2),(2,3),(3,4)]).contains(1, lambda x: x[1]))
self.assertTrue(linqy.make([(1,2),(2,3),(3,4)]).contains(2, lambda x: x[1]))
def test_orderby_random1(self):
for i in range(10):
r = self.make_random_range()
r1 = sorted(r, key=lambda x: x[0])
r2 = (linqy.make(r)
.orderby(lambda x: x[0])
.tolist())
self.assertEqual(r1, r2)
def test_reverse(self):
seq = linqy.make([1,2,3,4,5])
e1 = seq.reverse()
e2 = e1.reverse()
e3 = e2.reverse()
self.assertEqual(list(e1), [5,4,3,2,1])
self.assertEqual(list(e2), [1,2,3,4,5])
self.assertEqual(list(e1), list(e3))
def fibonacci():
yield 0
yield 1
fibs = linqy.make(fibonacci)
query = (fibs.zip(fibs.skip(1))
.select(lambda item: item[0] + item[1]))
for item in query:
yield item
def test_orderby_thenby(self):
seq = self.make_data()
a,b,c,d,e = seq
enum = (linqy.make(seq)
.orderby(lambda x: x['num'])
.thenby(lambda x: x['price'])
.thenbydesc(lambda x: x['name']))
self.assertEqual(list(enum), [a,d,c,e,b])
def test_orderby_random2(self):
for i in range(10):
r = self.make_random_range()
r1 = sorted(r, key=lambda x: (x[0], -x[2], x[1]))
r2 = (linqy.make(r)
.orderby(lambda x: x[0])
.thenbydesc(lambda x: x[2])
.thenby(lambda x: x[1])
.tolist())
self.assertEqual(r1, r2)
def test_any(self):
self.assertTrue(linqy.make([1,2,3,4,5]).any())
self.assertTrue(linqy.make([0,1,2,3,4,5]).any())
self.assertFalse(linqy.make([0,0,0,0]).any())
self.assertTrue(linqy.make([1,2,3,4,5]).any(lambda x: x < 10))
self.assertTrue(linqy.make([0,1,2,3,4,5]).any(lambda x: x < 10))
self.assertFalse(linqy.make([0,1,2,3,4,5]).any(lambda x: x > 10))
def test_all(self):
self.assertTrue(linqy.make([1,2,3,4,5]).all())
self.assertFalse(linqy.make([0,1,2,3,4,5]).all())
self.assertTrue(linqy.make([1,2,3,4,5]).all(lambda x: x > 0))
self.assertFalse(linqy.make([1,2,3,4,5]).all(lambda x: x > 3))
self.assertTrue(linqy.make([0,1,2,3,4,5]).all(lambda x: x < 8))
self.assertFalse(linqy.make([0,1,2,3,4,5]).all(lambda x: x < 3))
def test_count(self):
self.assertEqual(linqy.make([4,3,5,1,2]).count(), 5)
self.assertEqual(linqy.make(range(1,101)).count(), 100)
self.assertEqual(linqy.make(range(1,101)).count(lambda x: x % 2), 50)
def test_average(self):
self.assertEqual(linqy.make([1,1,1,1,1]).average(), 1)
self.assertEqual(linqy.make([1,2,3,4,5]).average(), 3)
def test_aggregate(self):
self.assertEqual(linqy.make(range(1,11)).aggregate(lambda a, b: a + b), 55)
self.assertEqual(linqy.make(range(1,11)).aggregate(lambda a, b: a + b, seed=100), 155)
def test_concat(self):
cats = [{'name': 'Barley', 'age': 8}, {'name': 'Boots', 'age': 4}, {'name': 'Whiskers', 'age': 1}]
dogs = [{'name': 'Bounder', 'age': 3}, {'name': 'Snoopy', 'age': 14}, {'name': 'Fido', 'age': 9}]
query = linqy.make(cats).select(lambda cat: cat['name']).concat(linqy.make(dogs).select(lambda dog: dog['name']))
self.assertEqual(query.tolist(), ['Barley', 'Boots', 'Whiskers', 'Bounder', 'Snoopy', 'Fido'])
def test_tolookup(self):
e = linqy.make(range(0, 10))
lookup = e.tolookup(lambda x: x % 2)
self.assertEqual(lookup[0], [0, 2, 4, 6, 8])
self.assertEqual(lookup[1], [1, 3, 5, 7, 9])
def test_todict(self):
d = (linqy.make([1,2,3])
.select(lambda x, i: {'key': str(i), 'value': x})
.todict(lambda x: x['key'], lambda x: x['value']))
self.assertEqual(d, {'0': 1, '1': 2, '2': 3})
def test_max(self):
self.assertEqual(linqy.make([4,3,5,1,2]).max(), 5)
def test_sum(self):
self.assertEqual(linqy.make([1,2,3,4,5,6,7,8,9,10]).sum(), 55)
def test_foreach(self):
linqy.make([1,2,3]).foreach(self.add)
self.assertEqual(self.num, 6)
linqy.make([1,2,3]).foreach(self.addi)
self.assertEqual(self.num, 12)
def test_last_pred(self):
e = linqy.make([1,2,3,4,5])
self.assertEqual(e.last(pred=lambda x: x < 3), 2)
def test_last(self):
e = linqy.make([1,2,3,4,5])
self.assertEqual(e.last(), 5)
def test_first_pred(self):
e = linqy.make([1,2,3,4,5])
self.assertEqual(e.first(pred=lambda x: x > 3), 4)
def test_first(self):
e = linqy.make([1,2,3,4,5])
self.assertEqual(e.first(), 1)
def test_min(self):
self.assertEqual(linqy.make([4,3,5,1,2]).min(), 1)
def test_toarray(self):
e = linqy.make([1,2,3,4,5])
self.assertEqual(e.toarray('i'), array('i', [1,2,3,4,5]))
def test_last_pred_default(self):
e = linqy.make([1,2,3,4,5])
self.assertRaises(IndexError, lambda: e.last(pred=lambda x: x < 0))
self.assertEqual(e.last(lambda x: x < 0, 100), 100)
def test_tolist(self):
e = linqy.make([1,2,3,4,5])
self.assertEqual(e.tolist(), [1,2,3,4,5])
def sample_stream():
response = urllib.urlopen('http://stream.twitter.com/1/statuses/sample.json')
return (linqy.make(enumerate_line(response))
.where(lambda s: s)
.select(lambda s: s.decode('utf-8'))
.select(lambda s: json.loads(s)))
def test_single_default(self):
self.assertEqual(linqy.make([1]).single(), 1)
self.assertEqual(linqy.empty().single(default=100), 100)
self.assertRaises(LookupError, lambda: linqy.make([1,2]).single(default=100))
