Hide keyboard shortcuts

Hot-keys on this page

r m x p   toggle line displays

j k   next/prev highlighted chunk

0   (zero) top of page

1   (one) first highlighted chunk

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

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

""" 

Pytest test running. 

 

This module implements the ``test()`` function for NumPy modules. The usual 

boiler plate for doing that is to put the following in the module 

``__init__.py`` file:: 

 

from numpy._pytesttester import PytestTester 

test = PytestTester(__name__).test 

del PytestTester 

 

 

Warnings filtering and other runtime settings should be dealt with in the 

``pytest.ini`` file in the numpy repo root. The behavior of the test depends on 

whether or not that file is found as follows: 

 

* ``pytest.ini`` is present (develop mode) 

All warnings except those explicitly filtered out are raised as error. 

* ``pytest.ini`` is absent (release mode) 

DeprecationWarnings and PendingDeprecationWarnings are ignored, other 

warnings are passed through. 

 

In practice, tests run from the numpy repo are run in develop mode. That 

includes the standard ``python runtests.py`` invocation. 

 

This module is imported by every numpy subpackage, so lies at the top level to 

simplify circular import issues. For the same reason, it contains no numpy 

imports at module scope, instead importing numpy within function calls. 

""" 

import sys 

import os 

 

__all__ = ['PytestTester'] 

 

 

 

def _show_numpy_info(): 

import numpy as np 

 

print("NumPy version %s" % np.__version__) 

relaxed_strides = np.ones((10, 1), order="C").flags.f_contiguous 

print("NumPy relaxed strides checking option:", relaxed_strides) 

 

 

class PytestTester: 

""" 

Pytest test runner. 

 

A test function is typically added to a package's __init__.py like so:: 

 

from numpy._pytesttester import PytestTester 

test = PytestTester(__name__).test 

del PytestTester 

 

Calling this test function finds and runs all tests associated with the 

module and all its sub-modules. 

 

Attributes 

---------- 

module_name : str 

Full path to the package to test. 

 

Parameters 

---------- 

module_name : module name 

The name of the module to test. 

 

Notes 

----- 

Unlike the previous ``nose``-based implementation, this class is not 

publicly exposed as it performs some ``numpy``-specific warning 

suppression. 

 

""" 

def __init__(self, module_name): 

self.module_name = module_name 

 

def __call__(self, label='fast', verbose=1, extra_argv=None, 

doctests=False, coverage=False, durations=-1, tests=None): 

""" 

Run tests for module using pytest. 

 

Parameters 

---------- 

label : {'fast', 'full'}, optional 

Identifies the tests to run. When set to 'fast', tests decorated 

with `pytest.mark.slow` are skipped, when 'full', the slow marker 

is ignored. 

verbose : int, optional 

Verbosity value for test outputs, in the range 1-3. Default is 1. 

extra_argv : list, optional 

List with any extra arguments to pass to pytests. 

doctests : bool, optional 

.. note:: Not supported 

coverage : bool, optional 

If True, report coverage of NumPy code. Default is False. 

Requires installation of (pip) pytest-cov. 

durations : int, optional 

If < 0, do nothing, If 0, report time of all tests, if > 0, 

report the time of the slowest `timer` tests. Default is -1. 

tests : test or list of tests 

Tests to be executed with pytest '--pyargs' 

 

Returns 

------- 

result : bool 

Return True on success, false otherwise. 

 

Notes 

----- 

Each NumPy module exposes `test` in its namespace to run all tests for 

it. For example, to run all tests for numpy.lib: 

 

>>> np.lib.test() #doctest: +SKIP 

 

Examples 

-------- 

>>> result = np.lib.test() #doctest: +SKIP 

... 

1023 passed, 2 skipped, 6 deselected, 1 xfailed in 10.39 seconds 

>>> result 

True 

 

""" 

import pytest 

import warnings 

 

module = sys.modules[self.module_name] 

module_path = os.path.abspath(module.__path__[0]) 

 

# setup the pytest arguments 

pytest_args = ["-l"] 

 

# offset verbosity. The "-q" cancels a "-v". 

pytest_args += ["-q"] 

 

# Filter out distutils cpu warnings (could be localized to 

# distutils tests). ASV has problems with top level import, 

# so fetch module for suppression here. 

with warnings.catch_warnings(): 

warnings.simplefilter("always") 

from numpy.distutils import cpuinfo 

 

# Filter out annoying import messages. Want these in both develop and 

# release mode. 

pytest_args += [ 

"-W ignore:Not importing directory", 

"-W ignore:numpy.dtype size changed", 

"-W ignore:numpy.ufunc size changed", 

"-W ignore::UserWarning:cpuinfo", 

] 

 

# When testing matrices, ignore their PendingDeprecationWarnings 

pytest_args += [ 

"-W ignore:the matrix subclass is not", 

"-W ignore:Importing from numpy.matlib is", 

] 

 

if doctests: 

raise ValueError("Doctests not supported") 

 

if extra_argv: 

pytest_args += list(extra_argv) 

 

if verbose > 1: 

pytest_args += ["-" + "v"*(verbose - 1)] 

 

if coverage: 

pytest_args += ["--cov=" + module_path] 

 

if label == "fast": 

# not importing at the top level to avoid circular import of module 

from numpy.testing import IS_PYPY 

if IS_PYPY: 

pytest_args += ["-m", "not slow and not slow_pypy"] 

else: 

pytest_args += ["-m", "not slow"] 

 

elif label != "full": 

pytest_args += ["-m", label] 

 

if durations >= 0: 

pytest_args += ["--durations=%s" % durations] 

 

if tests is None: 

tests = [self.module_name] 

 

pytest_args += ["--pyargs"] + list(tests) 

 

 

# run tests. 

_show_numpy_info() 

 

try: 

code = pytest.main(pytest_args) 

except SystemExit as exc: 

code = exc.code 

 

return code == 0