File: run-python37.test

package info (click to toggle)
mypy 1.19.1-2
  • links: PTS, VCS
  • area: main
  • in suites: forky, sid
  • size: 22,412 kB
  • sloc: python: 114,754; ansic: 13,343; cpp: 11,380; makefile: 257; sh: 28
file content (159 lines) | stat: -rw-r--r-- 3,874 bytes parent folder | download | duplicates (3)
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
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
-- Test cases for Python 3.7 features

[case testRunDataclass]
import dataclasses
from dataclasses import dataclass, field
from typing import Set, FrozenSet, List, Callable, Any

@dataclass
class Person1:
    age : int
    name : str

    def __bool__(self) -> bool:
        return self.name == 'robot'

def testBool(p: Person1) -> bool:
    if p:
        return True
    else:
        return False

@dataclass
class Person1b(Person1):
    id: str = '000'

@dataclass
class Person2:
    age : int
    name : str = field(default='robot')

@dataclasses.dataclass
class Person2b:
    age : int
    name : str = dataclasses.field(default='robot')

@dataclass(order = True)
class Person3:
    age : int = field(default = 6)
    friendIDs : List[int] = field(default_factory = list)

    def get_age(self) -> int:
        return (self.age)

    def set_age(self, new_age : int) -> None:
        self.age = new_age

    def add_friendID(self, fid : int) -> None:
        self.friendIDs.append(fid)

    def get_friendIDs(self) -> List[int]:
        return self.friendIDs

def get_next_age(g: Callable[[Any], int]) -> Callable[[Any], int]:
    def f(a: Any) -> int:
        return g(a) + 1
    return f

@dataclass
class Person4:
    age : int
    _name : str = 'Bot'

    @get_next_age
    def get_age(self) -> int:
        return self.age

    @property
    def name(self) -> str:
        return self._name

@dataclass
class Person5:
    weight: float
    friends: Set[str] = field(default_factory=set)
    parents: FrozenSet[str] = frozenset()

[file other.py]
from native import Person1, Person1b, Person2, Person3, Person4, Person5, testBool
i1 = Person1(age = 5, name = 'robot')
assert i1.age == 5
assert i1.name == 'robot'
assert testBool(i1) == True
assert testBool(Person1(age = 5, name = 'robo')) == False
i1b = Person1b(age = 5, name = 'robot')
assert i1b.age == 5
assert i1b.name == 'robot'
assert testBool(i1b) == True
assert testBool(Person1b(age = 5, name = 'robo')) == False
i1c = Person1b(age = 20, name = 'robot', id = 'test')
assert i1c.age == 20
assert i1c.id == 'test'

i2 = Person2(age = 5)
assert i2.age == 5
assert i2.name == 'robot'
i3 = Person2(age = 5, name = 'new_robot')
assert i3.age == 5
assert i3.name == 'new_robot'
i4 = Person3()
assert i4.age == 6
assert i4.friendIDs == []
i5 = Person3(age = 5)
assert i5.age == 5
assert i5.friendIDs == []
i6 = Person3(age = 5, friendIDs = [1,2,3])
assert i6.age == 5
assert i6.friendIDs == [1,2,3]
assert i6.get_age() == 5
i6.set_age(10)
assert i6.get_age() == 10
i6.add_friendID(4)
assert i6.get_friendIDs() == [1,2,3,4]
i7 = Person4(age = 5)
assert i7.get_age() == 6
i7.age += 3
assert i7.age == 8
assert i7.name == 'Bot'
i8 = Person3(age = 1, friendIDs = [1,2])
i9 = Person3(age = 1, friendIDs = [1,2])
assert i8 == i9
i8.age = 2
assert i8 > i9

assert Person1.__annotations__ == {'age': int, 'name': str}
assert Person2.__annotations__ == {'age': int, 'name': str}
assert Person5.__annotations__ == {'weight': float, 'friends': set,
                                       'parents': frozenset}

[file driver.py]
import sys

# Dataclasses introduced in 3.7
version = sys.version_info[:2]
if version[0] < 3 or version[1] < 7:
    exit()

# Run the tests in both interpreted and compiled mode
import other
import other_interpreted

# Test for an exceptional cases
from testutil import assertRaises
from native import Person1, Person1b, Person3
from types import BuiltinMethodType

with assertRaises(TypeError, "missing 1 required positional argument"):
    Person1(0)

with assertRaises(TypeError, "missing 2 required positional arguments"):
    Person1b()

with assertRaises(TypeError, "int object expected; got str"):
    Person1('nope', 'test')

p = Person1(0, 'test')
with assertRaises(TypeError, "int object expected; got str"):
    p.age = 'nope'

assert isinstance(Person3().get_age, BuiltinMethodType)