def test_group_join_infinite(self):
        a = infinite()
        b = [2, 3, 5]
        c = Queryable(a).group_join(b).take(3).to_list()

        self.assertEqual(c[0].key, 0)
        self.assertEqual(len(c[0]), 0)

        self.assertEqual(c[1].key, 1)
        self.assertEqual(len(c[1]), 0)

        self.assertEqual(c[2].key, 2)
        self.assertEqual(len(c[2]), 1)
        self.assertTrue(2 in c[2])

 def test_ne_infinite_finite(self):
     a = (1, 2, 3, 5, 16, 32)
     b = infinite()
     c = Queryable(a) != b
     self.assertTrue(c)

 def test_any_infinite(self):
     b = Queryable(infinite()).any()
     self.assertTrue(b)

 def test_getitem_infinite(self):
     b = Queryable(infinite())[5]
     self.assertEqual(b, 5)

 def test_skip_from_infinite(self):
     b = Queryable(infinite()).skip(5).take(3).to_list()
     c = [5, 6, 7]
     self.assertEqual(b, c)

 def test_select_many_infinite(self):
     a = infinite()
     b = Queryable(a).select_many(lambda x: [x] * x).take(10).to_list()
     c = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]
     self.assertEqual(b, c)

 def test_first_or_default_infinite(self):
     b = Queryable(infinite()).first_or_default(37)
     self.assertEqual(b, 0)

 def test_concat_infinite(self):
     b = Queryable(infinite()).concat(infinite()).take(3).to_list()
     c = [0, 1, 2]
     self.assertEqual(b, c)

 def test_difference_infinite(self):
     b = [3, 7, 2, 9, 10]
     c = Queryable(infinite()).difference(b).take(10).to_list()
     d = [0, 1, 4, 5, 6, 8, 11, 12, 13, 14]
     self.assertEqual(c, d)

 def test_intersect_infinite(self):
     b = [3, 7, 2, 9, 10]
     c = Queryable(infinite()).intersect(b).take(5).to_list()
     d = [2, 3, 7, 9, 10]
     self.assertEqual(c, d)

 def test_zip_infinite(self):
     c = Queryable(infinite()).zip(infinite()).take(4).to_list()
     self.assertEqual(c, [(0, 0), (1, 1), (2, 2), (3, 3)])

 def test_reversed_non_sequence(self):
     a = infinite()
     b = list(reversed(Queryable(a).take(10)))
     c = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
     self.assertEqual(b, c)

 def test_select_infinite(self):
     a = infinite()
     b = Queryable(a).select(lambda x: x*2).take(3).to_list()
     c = [0, 2, 4]
     self.assertEqual(b, c)

 def test_sequence_equal_infinite_finite(self):
     a = (1, 2, 3, 5, 16, 32)
     b = infinite()
     c = Queryable(a).sequence_equal(b)
     self.assertFalse(c)

 def test_eq_infinite_finite(self):
     a = (1, 2, 3, 5, 16, 32)
     b = infinite()
     c = Queryable(a) == b
     self.assertFalse(c)

 def test_element_at_out_of_range_infinite(self):
     self.assertRaises(ValueError, lambda: Queryable(infinite()).element_at(-1))

 def test_element_at_infinite(self):
     b = Queryable(infinite()).element_at(5)
     self.assertEqual(b, 5)

 def test_where_infinite(self):
     a = infinite()
     b = Queryable(a).where(lambda x: x % 5 == 0).take(3).to_list()
     c = [0, 5, 10]
     self.assertEqual(b, c)

 def test_default_if_empty_infinite(self):
     b = Queryable(infinite()).default_if_empty(42).take(5).to_list()
     self.assertEqual(b, [0, 1, 2, 3, 4])

 def test_union_infinite(self):
     b = [3, 7, 2, 9, 10]
     c = Queryable(infinite()).union(b).take(5).to_list()
     d = [0, 1, 2, 3, 4]
     self.assertEqual(c, d)