python-bert/tests.py at master · samuel/python-bert · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
#!/usr/bin/env python
# -*- coding: utf-8 -*-

importdatetime
importre
importunittest

frombertimportBERTDecoder, BERTEncoder, Atom
frombert.codecimportutc_to_datetime, datetime_to_utc

classTestDateConversion(unittest.TestCase):
test_dates= [
 (datetime.datetime(1970, 1, 1, 0, 0, 0, 0), (0, 0)),
 (datetime.datetime(2009, 1, 8, 4, 27, 47), (1231388867, 0)),
 (datetime.datetime(2009, 10, 8, 4, 27, 47, 123), (1254976067, 123)),
 (datetime.datetime(2009, 1, 8, 4, 27, 47, 456), (1231388867, 456)),
 ]

deftestToDatetime(self):
fordt, tstampinself.test_dates:
self.assertEqual(dt, utc_to_datetime(tstamp[0], tstamp[1]))

deftestFromDatetime(self):
fordt, tstampinself.test_dates:
self.assertEqual(tstamp, datetime_to_utc(dt))

classBERTTestCase(unittest.TestCase):
bert_tests= [
# nil
 (None, ("bert", "nil")),
# nested nil
 ([None, (None,)], [("bert", "nil"), (("bert", "nil"),)]),
# unicode
 (u"Mitä kuuluu", ('bert', 'string', Atom('UTF-8'), u"Mitä kuuluu".encode('utf-8'))),
# dict
 ({'foo': 'bar'}, ('bert', 'dict', [('foo', 'bar')])),
# empty dict
 ({}, ('bert', 'dict', [])),
# nested dict
 ({'foo': {'baz': 'bar'}}, ('bert', 'dict', [('foo', ('bert', 'dict', [('baz', 'bar')]))])),
# empty tuple
 (tuple(), tuple()),
# true
 (True, ('bert', 'true')),
# false
 (False, ('bert', 'false')),
# time
 (datetime.datetime.utcfromtimestamp(123*1000000+456).replace(microsecond=789), ('bert', 'time', 123, 456, 789)),
# regex
 (re.compile('^c(a)t$', re.I|re.X), ('bert', 'regex', '^c(a)t$', (Atom('extended'), Atom('caseless')))),
# other
 ([1, 2.0, ("foo", "bar")], [1, 2.0, ("foo", "bar")]),
 ]

deftestDecode(self):
convert=BERTDecoder().convert
forpython, bertinself.bert_tests:
self.assertEqual(python, convert(bert))

deftestEncode(self):
convert=BERTEncoder().convert
forpython, bertinself.bert_tests:
self.assertEqual(bert, convert(python))

if__name__=='__main__':
unittest.main()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
#!/usr/bin/env python
# -*- coding: utf-8 -*-

importdatetime
importre
importunittest

frombertimportBERTDecoder, BERTEncoder, Atom
frombert.codecimportutc_to_datetime, datetime_to_utc

classTestDateConversion(unittest.TestCase):
test_dates= [
 (datetime.datetime(1970, 1, 1, 0, 0, 0, 0), (0, 0)),
 (datetime.datetime(2009, 1, 8, 4, 27, 47), (1231388867, 0)),
 (datetime.datetime(2009, 10, 8, 4, 27, 47, 123), (1254976067, 123)),
 (datetime.datetime(2009, 1, 8, 4, 27, 47, 456), (1231388867, 456)),
 ]

deftestToDatetime(self):
fordt, tstampinself.test_dates:
self.assertEqual(dt, utc_to_datetime(tstamp[0], tstamp[1]))

deftestFromDatetime(self):
fordt, tstampinself.test_dates:
self.assertEqual(tstamp, datetime_to_utc(dt))

classBERTTestCase(unittest.TestCase):
bert_tests= [
# nil
 (None, ("bert", "nil")),
# nested nil
 ([None, (None,)], [("bert", "nil"), (("bert", "nil"),)]),
# unicode
 (u"Mitä kuuluu", ('bert', 'string', Atom('UTF-8'), u"Mitä kuuluu".encode('utf-8'))),
# dict
 ({'foo': 'bar'}, ('bert', 'dict', [('foo', 'bar')])),
# empty dict
 ({}, ('bert', 'dict', [])),
# nested dict
 ({'foo': {'baz': 'bar'}}, ('bert', 'dict', [('foo', ('bert', 'dict', [('baz', 'bar')]))])),
# empty tuple
 (tuple(), tuple()),
# true
 (True, ('bert', 'true')),
# false
 (False, ('bert', 'false')),
# time
 (datetime.datetime.utcfromtimestamp(123*1000000+456).replace(microsecond=789), ('bert', 'time', 123, 456, 789)),
# regex
 (re.compile('^c(a)t$', re.I|re.X), ('bert', 'regex', '^c(a)t$', (Atom('extended'), Atom('caseless')))),
# other
 ([1, 2.0, ("foo", "bar")], [1, 2.0, ("foo", "bar")]),
 ]

deftestDecode(self):
convert=BERTDecoder().convert
forpython, bertinself.bert_tests:
self.assertEqual(python, convert(bert))

deftestEncode(self):
convert=BERTEncoder().convert
forpython, bertinself.bert_tests:
self.assertEqual(bert, convert(python))

if__name__=='__main__':
unittest.main()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
#!/usr/bin/env python
# -*- coding: utf-8 -*-

importdatetime
importre
importunittest

frombertimportBERTDecoder, BERTEncoder, Atom
frombert.codecimportutc_to_datetime, datetime_to_utc

classTestDateConversion(unittest.TestCase):
test_dates= [
 (datetime.datetime(1970, 1, 1, 0, 0, 0, 0), (0, 0)),
 (datetime.datetime(2009, 1, 8, 4, 27, 47), (1231388867, 0)),
 (datetime.datetime(2009, 10, 8, 4, 27, 47, 123), (1254976067, 123)),
 (datetime.datetime(2009, 1, 8, 4, 27, 47, 456), (1231388867, 456)),
 ]

deftestToDatetime(self):
fordt, tstampinself.test_dates:
self.assertEqual(dt, utc_to_datetime(tstamp[0], tstamp[1]))

deftestFromDatetime(self):
fordt, tstampinself.test_dates:
self.assertEqual(tstamp, datetime_to_utc(dt))

classBERTTestCase(unittest.TestCase):
bert_tests= [
# nil
 (None, ("bert", "nil")),
# nested nil
 ([None, (None,)], [("bert", "nil"), (("bert", "nil"),)]),
# unicode
 (u"Mitä kuuluu", ('bert', 'string', Atom('UTF-8'), u"Mitä kuuluu".encode('utf-8'))),
# dict
 ({'foo': 'bar'}, ('bert', 'dict', [('foo', 'bar')])),
# empty dict
 ({}, ('bert', 'dict', [])),
# nested dict
 ({'foo': {'baz': 'bar'}}, ('bert', 'dict', [('foo', ('bert', 'dict', [('baz', 'bar')]))])),
# empty tuple
 (tuple(), tuple()),
# true
 (True, ('bert', 'true')),
# false
 (False, ('bert', 'false')),
# time
 (datetime.datetime.utcfromtimestamp(123*1000000+456).replace(microsecond=789), ('bert', 'time', 123, 456, 789)),
# regex
 (re.compile('^c(a)t$', re.I|re.X), ('bert', 'regex', '^c(a)t$', (Atom('extended'), Atom('caseless')))),
# other
 ([1, 2.0, ("foo", "bar")], [1, 2.0, ("foo", "bar")]),
 ]

deftestDecode(self):
convert=BERTDecoder().convert
forpython, bertinself.bert_tests:
self.assertEqual(python, convert(bert))

deftestEncode(self):
convert=BERTEncoder().convert
forpython, bertinself.bert_tests:
self.assertEqual(bert, convert(python))

if__name__=='__main__':
unittest.main()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
#!/usr/bin/env python
# -*- coding: utf-8 -*-

importdatetime
importre
importunittest

frombertimportBERTDecoder, BERTEncoder, Atom
frombert.codecimportutc_to_datetime, datetime_to_utc

classTestDateConversion(unittest.TestCase):
test_dates= [
 (datetime.datetime(1970, 1, 1, 0, 0, 0, 0), (0, 0)),
 (datetime.datetime(2009, 1, 8, 4, 27, 47), (1231388867, 0)),
 (datetime.datetime(2009, 10, 8, 4, 27, 47, 123), (1254976067, 123)),
 (datetime.datetime(2009, 1, 8, 4, 27, 47, 456), (1231388867, 456)),
 ]

deftestToDatetime(self):
fordt, tstampinself.test_dates:
self.assertEqual(dt, utc_to_datetime(tstamp[0], tstamp[1]))

deftestFromDatetime(self):
fordt, tstampinself.test_dates:
self.assertEqual(tstamp, datetime_to_utc(dt))

classBERTTestCase(unittest.TestCase):
bert_tests= [
# nil
 (None, ("bert", "nil")),
# nested nil
 ([None, (None,)], [("bert", "nil"), (("bert", "nil"),)]),
# unicode
 (u"Mitä kuuluu", ('bert', 'string', Atom('UTF-8'), u"Mitä kuuluu".encode('utf-8'))),
# dict
 ({'foo': 'bar'}, ('bert', 'dict', [('foo', 'bar')])),
# empty dict
 ({}, ('bert', 'dict', [])),
# nested dict
 ({'foo': {'baz': 'bar'}}, ('bert', 'dict', [('foo', ('bert', 'dict', [('baz', 'bar')]))])),
# empty tuple
 (tuple(), tuple()),
# true
 (True, ('bert', 'true')),
# false
 (False, ('bert', 'false')),
# time
 (datetime.datetime.utcfromtimestamp(123*1000000+456).replace(microsecond=789), ('bert', 'time', 123, 456, 789)),
# regex
 (re.compile('^c(a)t$', re.I|re.X), ('bert', 'regex', '^c(a)t$', (Atom('extended'), Atom('caseless')))),
# other
 ([1, 2.0, ("foo", "bar")], [1, 2.0, ("foo", "bar")]),
 ]

deftestDecode(self):
convert=BERTDecoder().convert
forpython, bertinself.bert_tests:
self.assertEqual(python, convert(bert))

deftestEncode(self):
convert=BERTEncoder().convert
forpython, bertinself.bert_tests:
self.assertEqual(bert, convert(python))

if__name__=='__main__':
unittest.main()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
#!/usr/bin/env python
# -*- coding: utf-8 -*-

importdatetime
importre
importunittest

frombertimportBERTDecoder, BERTEncoder, Atom
frombert.codecimportutc_to_datetime, datetime_to_utc

classTestDateConversion(unittest.TestCase):
test_dates= [
 (datetime.datetime(1970, 1, 1, 0, 0, 0, 0), (0, 0)),
 (datetime.datetime(2009, 1, 8, 4, 27, 47), (1231388867, 0)),
 (datetime.datetime(2009, 10, 8, 4, 27, 47, 123), (1254976067, 123)),
 (datetime.datetime(2009, 1, 8, 4, 27, 47, 456), (1231388867, 456)),
 ]

deftestToDatetime(self):
fordt, tstampinself.test_dates:
self.assertEqual(dt, utc_to_datetime(tstamp[0], tstamp[1]))

deftestFromDatetime(self):
fordt, tstampinself.test_dates:
self.assertEqual(tstamp, datetime_to_utc(dt))

classBERTTestCase(unittest.TestCase):
bert_tests= [
# nil
 (None, ("bert", "nil")),
# nested nil
 ([None, (None,)], [("bert", "nil"), (("bert", "nil"),)]),
# unicode
 (u"Mitä kuuluu", ('bert', 'string', Atom('UTF-8'), u"Mitä kuuluu".encode('utf-8'))),
# dict
 ({'foo': 'bar'}, ('bert', 'dict', [('foo', 'bar')])),
# empty dict
 ({}, ('bert', 'dict', [])),
# nested dict
 ({'foo': {'baz': 'bar'}}, ('bert', 'dict', [('foo', ('bert', 'dict', [('baz', 'bar')]))])),
# empty tuple
 (tuple(), tuple()),
# true
 (True, ('bert', 'true')),
# false
 (False, ('bert', 'false')),
# time
 (datetime.datetime.utcfromtimestamp(123*1000000+456).replace(microsecond=789), ('bert', 'time', 123, 456, 789)),
# regex
 (re.compile('^c(a)t$', re.I|re.X), ('bert', 'regex', '^c(a)t$', (Atom('extended'), Atom('caseless')))),
# other
 ([1, 2.0, ("foo", "bar")], [1, 2.0, ("foo", "bar")]),
 ]

deftestDecode(self):
convert=BERTDecoder().convert
forpython, bertinself.bert_tests:
self.assertEqual(python, convert(bert))

deftestEncode(self):
convert=BERTEncoder().convert
forpython, bertinself.bert_tests:
self.assertEqual(bert, convert(python))

if__name__=='__main__':
unittest.main()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
#!/usr/bin/env python
# -*- coding: utf-8 -*-

importdatetime
importre
importunittest

frombertimportBERTDecoder, BERTEncoder, Atom
frombert.codecimportutc_to_datetime, datetime_to_utc

classTestDateConversion(unittest.TestCase):
test_dates= [
 (datetime.datetime(1970, 1, 1, 0, 0, 0, 0), (0, 0)),
 (datetime.datetime(2009, 1, 8, 4, 27, 47), (1231388867, 0)),
 (datetime.datetime(2009, 10, 8, 4, 27, 47, 123), (1254976067, 123)),
 (datetime.datetime(2009, 1, 8, 4, 27, 47, 456), (1231388867, 456)),
 ]

deftestToDatetime(self):
fordt, tstampinself.test_dates:
self.assertEqual(dt, utc_to_datetime(tstamp[0], tstamp[1]))

deftestFromDatetime(self):
fordt, tstampinself.test_dates:
self.assertEqual(tstamp, datetime_to_utc(dt))

classBERTTestCase(unittest.TestCase):
bert_tests= [
# nil
 (None, ("bert", "nil")),
# nested nil
 ([None, (None,)], [("bert", "nil"), (("bert", "nil"),)]),
# unicode
 (u"Mitä kuuluu", ('bert', 'string', Atom('UTF-8'), u"Mitä kuuluu".encode('utf-8'))),
# dict
 ({'foo': 'bar'}, ('bert', 'dict', [('foo', 'bar')])),
# empty dict
 ({}, ('bert', 'dict', [])),
# nested dict
 ({'foo': {'baz': 'bar'}}, ('bert', 'dict', [('foo', ('bert', 'dict', [('baz', 'bar')]))])),
# empty tuple
 (tuple(), tuple()),
# true
 (True, ('bert', 'true')),
# false
 (False, ('bert', 'false')),
# time
 (datetime.datetime.utcfromtimestamp(123*1000000+456).replace(microsecond=789), ('bert', 'time', 123, 456, 789)),
# regex
 (re.compile('^c(a)t$', re.I|re.X), ('bert', 'regex', '^c(a)t$', (Atom('extended'), Atom('caseless')))),
# other
 ([1, 2.0, ("foo", "bar")], [1, 2.0, ("foo", "bar")]),
 ]

deftestDecode(self):
convert=BERTDecoder().convert
forpython, bertinself.bert_tests:
self.assertEqual(python, convert(bert))

deftestEncode(self):
convert=BERTEncoder().convert
forpython, bertinself.bert_tests:
self.assertEqual(bert, convert(python))

if__name__=='__main__':
unittest.main()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
#!/usr/bin/env python
# -*- coding: utf-8 -*-

importdatetime
importre
importunittest

frombertimportBERTDecoder, BERTEncoder, Atom
frombert.codecimportutc_to_datetime, datetime_to_utc

classTestDateConversion(unittest.TestCase):
test_dates= [
 (datetime.datetime(1970, 1, 1, 0, 0, 0, 0), (0, 0)),
 (datetime.datetime(2009, 1, 8, 4, 27, 47), (1231388867, 0)),
 (datetime.datetime(2009, 10, 8, 4, 27, 47, 123), (1254976067, 123)),
 (datetime.datetime(2009, 1, 8, 4, 27, 47, 456), (1231388867, 456)),
 ]

deftestToDatetime(self):
fordt, tstampinself.test_dates:
self.assertEqual(dt, utc_to_datetime(tstamp[0], tstamp[1]))

deftestFromDatetime(self):
fordt, tstampinself.test_dates:
self.assertEqual(tstamp, datetime_to_utc(dt))

classBERTTestCase(unittest.TestCase):
bert_tests= [
# nil
 (None, ("bert", "nil")),
# nested nil
 ([None, (None,)], [("bert", "nil"), (("bert", "nil"),)]),
# unicode
 (u"Mitä kuuluu", ('bert', 'string', Atom('UTF-8'), u"Mitä kuuluu".encode('utf-8'))),
# dict
 ({'foo': 'bar'}, ('bert', 'dict', [('foo', 'bar')])),
# empty dict
 ({}, ('bert', 'dict', [])),
# nested dict
 ({'foo': {'baz': 'bar'}}, ('bert', 'dict', [('foo', ('bert', 'dict', [('baz', 'bar')]))])),
# empty tuple
 (tuple(), tuple()),
# true
 (True, ('bert', 'true')),
# false
 (False, ('bert', 'false')),
# time
 (datetime.datetime.utcfromtimestamp(123*1000000+456).replace(microsecond=789), ('bert', 'time', 123, 456, 789)),
# regex
 (re.compile('^c(a)t$', re.I|re.X), ('bert', 'regex', '^c(a)t$', (Atom('extended'), Atom('caseless')))),
# other
 ([1, 2.0, ("foo", "bar")], [1, 2.0, ("foo", "bar")]),
 ]

deftestDecode(self):
convert=BERTDecoder().convert
forpython, bertinself.bert_tests:
self.assertEqual(python, convert(bert))

deftestEncode(self):
convert=BERTEncoder().convert
forpython, bertinself.bert_tests:
self.assertEqual(bert, convert(python))

if__name__=='__main__':
unittest.main()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
#!/usr/bin/env python
# -*- coding: utf-8 -*-

importdatetime
importre
importunittest

frombertimportBERTDecoder, BERTEncoder, Atom
frombert.codecimportutc_to_datetime, datetime_to_utc

classTestDateConversion(unittest.TestCase):
test_dates= [
 (datetime.datetime(1970, 1, 1, 0, 0, 0, 0), (0, 0)),
 (datetime.datetime(2009, 1, 8, 4, 27, 47), (1231388867, 0)),
 (datetime.datetime(2009, 10, 8, 4, 27, 47, 123), (1254976067, 123)),
 (datetime.datetime(2009, 1, 8, 4, 27, 47, 456), (1231388867, 456)),
 ]

deftestToDatetime(self):
fordt, tstampinself.test_dates:
self.assertEqual(dt, utc_to_datetime(tstamp[0], tstamp[1]))

deftestFromDatetime(self):
fordt, tstampinself.test_dates:
self.assertEqual(tstamp, datetime_to_utc(dt))

classBERTTestCase(unittest.TestCase):
bert_tests= [
# nil
 (None, ("bert", "nil")),
# nested nil
 ([None, (None,)], [("bert", "nil"), (("bert", "nil"),)]),
# unicode
 (u"Mitä kuuluu", ('bert', 'string', Atom('UTF-8'), u"Mitä kuuluu".encode('utf-8'))),
# dict
 ({'foo': 'bar'}, ('bert', 'dict', [('foo', 'bar')])),
# empty dict
 ({}, ('bert', 'dict', [])),
# nested dict
 ({'foo': {'baz': 'bar'}}, ('bert', 'dict', [('foo', ('bert', 'dict', [('baz', 'bar')]))])),
# empty tuple
 (tuple(), tuple()),
# true
 (True, ('bert', 'true')),
# false
 (False, ('bert', 'false')),
# time
 (datetime.datetime.utcfromtimestamp(123*1000000+456).replace(microsecond=789), ('bert', 'time', 123, 456, 789)),
# regex
 (re.compile('^c(a)t$', re.I|re.X), ('bert', 'regex', '^c(a)t$', (Atom('extended'), Atom('caseless')))),
# other
 ([1, 2.0, ("foo", "bar")], [1, 2.0, ("foo", "bar")]),
 ]

deftestDecode(self):
convert=BERTDecoder().convert
forpython, bertinself.bert_tests:
self.assertEqual(python, convert(bert))

deftestEncode(self):
convert=BERTEncoder().convert
forpython, bertinself.bert_tests:
self.assertEqual(bert, convert(python))

if__name__=='__main__':
unittest.main()