Esempio n. 1
0
    def test_tuple_3(self):
        t = edgedb.Tuple((1, []))
        t[1].append(t)
        self.assertEqual(t[1], [t])

        self.assertEqual(repr(t), '(1, [(...)])')
        self.assertEqual(str(t), '(1, [(...)])')
Esempio n. 2
0
    def test_namedtuple_4(self):
        t1 = edgedb.NamedTuple(a=1, b='aaaa')
        t2 = edgedb.Tuple((1, 'aaaa'))
        t3 = (1, 'aaaa')

        self.assertEqual(hash(t1), hash(t2))
        self.assertEqual(hash(t1), hash(t3))
Esempio n. 3
0
 def test_tuple_empty_1(self):
     t = edgedb.Tuple()
     self.assertEqual(len(t), 0)
     self.assertEqual(hash(t), hash(()))
     self.assertEqual(repr(t), '()')
     with self.assertRaisesRegex(IndexError, 'out of range'):
         t[0]
Esempio n. 4
0
    def test_tuple_2(self):
        t = edgedb.Tuple((1, 'a'))
        self.assertEqual(len(t), 2)
        self.assertEqual(hash(t), hash((1, 'a')))

        self.assertEqual(repr(t), "(1, 'a')")

        self.assertEqual(t[0], 1)
        self.assertEqual(t[1], 'a')
        with self.assertRaisesRegex(IndexError, 'out of range'):
            t[2]
Esempio n. 5
0
 def test_tuple_7(self):
     self.assertNotEqual(edgedb.Tuple([1, 2, 3]), 123)
Esempio n. 6
0
    def test_tuple_6(self):
        self.assertEqual(edgedb.Tuple([1, 2, 3]), (1, 2, 3))

        self.assertEqual((1, 2, 3), edgedb.Tuple([1, 2, 3]))

        self.assertNotEqual(edgedb.Tuple([1, 2, 3]), (1, 3, 2))

        self.assertLess(edgedb.Tuple([1, 2, 3]), (1, 3, 2))

        self.assertEqual(edgedb.Tuple([]), ())

        self.assertEqual(edgedb.Tuple([1]), (1, ))

        self.assertGreaterEqual(edgedb.Tuple([1]), (1, ))

        self.assertNotEqual(edgedb.Tuple([1]), ())

        self.assertGreater(edgedb.Tuple([1]), ())

        self.assertNotEqual(edgedb.Tuple([1]), (2, ))

        self.assertLess(edgedb.Tuple([1]), (2, ))

        self.assertNotEqual(edgedb.Tuple([1, 2]), (2, 2))

        self.assertNotEqual(edgedb.Tuple([1, 1]), (2, 2, 1))
Esempio n. 7
0
    def test_tuple_5(self):
        self.assertEqual(edgedb.Tuple([1, 2, 3]), edgedb.Tuple([1, 2, 3]))

        self.assertNotEqual(edgedb.Tuple([1, 2, 3]), edgedb.Tuple([1, 3, 2]))

        self.assertLess(edgedb.Tuple([1, 2, 3]), edgedb.Tuple([1, 3, 2]))

        self.assertEqual(edgedb.Tuple([]), edgedb.Tuple([]))

        self.assertEqual(edgedb.Tuple([1]), edgedb.Tuple([1]))

        self.assertGreaterEqual(edgedb.Tuple([1]), edgedb.Tuple([1]))

        self.assertNotEqual(edgedb.Tuple([1]), edgedb.Tuple([]))

        self.assertGreater(edgedb.Tuple([1]), edgedb.Tuple([]))

        self.assertNotEqual(edgedb.Tuple([1]), edgedb.Tuple([2]))

        self.assertLess(edgedb.Tuple([1]), edgedb.Tuple([2]))

        self.assertNotEqual(edgedb.Tuple([1, 2]), edgedb.Tuple([2, 2]))

        self.assertNotEqual(edgedb.Tuple([1, 1]), edgedb.Tuple([2, 2, 1]))
Esempio n. 8
0
 def test_tuple_freelist_1(self):
     lst = []
     for _ in range(5000):
         lst.append(edgedb.Tuple((1, )))
     for t in lst:
         self.assertEqual(t[0], 1)
Esempio n. 9
0
 def test_tuple_4(self):
     with self.assertRaisesRegex(ValueError, f'more than {0x4000 - 1}'):
         edgedb.Tuple([1] * 20000)