diogo/yap-6.3
Archived
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

inputhooks

Browse Source
This commit is contained in:
Vitor Santos Costa
2018-01-05 17:13:37 +00:00
parent 1cff18d1c0
commit 791484c132
111 changed files with 20555 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
packages/python/yap_kernel/yap_ipython/testing/tests/__init__.py Normal file
View File

@@ -0,0 +1,10 @@
# encoding: utf-8
__docformat__ = "restructuredtext en"
#-------------------------------------------------------------------------------
# Copyright (C) 2005 Fernando Perez <fperez@colorado.edu>
# Brian E Granger <ellisonbg@gmail.com>
# Benjamin Ragan-Kelley <benjaminrk@gmail.com>
#
# Distributed under the terms of the BSD License. The full license is in
# the file COPYING, distributed as part of this software.
#-------------------------------------------------------------------------------

164
packages/python/yap_kernel/yap_ipython/testing/tests/test_decorators.py Normal file
View File

@@ -0,0 +1,164 @@
"""Tests for the decorators we've created for yap_ipython.
"""
# Module imports
# Std lib
import inspect
import sys
# Third party
import nose.tools as nt
# Our own
from yap_ipython.testing import decorators as dec
#-----------------------------------------------------------------------------
# Utilities
# Note: copied from OInspect, kept here so the testing stuff doesn't create
# circular dependencies and is easier to reuse.
def getargspec(obj):
"""Get the names and default values of a function's arguments.
A tuple of four things is returned: (args, varargs, varkw, defaults).
'args' is a list of the argument names (it may contain nested lists).
'varargs' and 'varkw' are the names of the * and ** arguments or None.
'defaults' is an n-tuple of the default values of the last n arguments.
Modified version of inspect.getargspec from the Python Standard
Library."""
if inspect.isfunction(obj):
func_obj = obj
elif inspect.ismethod(obj):
func_obj = obj.__func__
else:
raise TypeError('arg is not a Python function')
args, varargs, varkw = inspect.getargs(func_obj.__code__)
return args, varargs, varkw, func_obj.__defaults__
#-----------------------------------------------------------------------------
# Testing functions
@dec.as_unittest
def trivial():
"""A trivial test"""
pass
@dec.skip
def test_deliberately_broken():
"""A deliberately broken test - we want to skip this one."""
1/0
@dec.skip('Testing the skip decorator')
def test_deliberately_broken2():
"""Another deliberately broken test - we want to skip this one."""
1/0
# Verify that we can correctly skip the doctest for a function at will, but
# that the docstring itself is NOT destroyed by the decorator.
def doctest_bad(x,y=1,**k):
"""A function whose doctest we need to skip.
>>> 1+1
3
"""
print('x:',x)
print('y:',y)
print('k:',k)
def call_doctest_bad():
"""Check that we can still call the decorated functions.
>>> doctest_bad(3,y=4)
x: 3
y: 4
k: {}
"""
pass
def test_skip_dt_decorator():
"""Doctest-skipping decorator should preserve the docstring.
"""
# Careful: 'check' must be a *verbatim* copy of the doctest_bad docstring!
check = """A function whose doctest we need to skip.
>>> 1+1
3
"""
# Fetch the docstring from doctest_bad after decoration.
val = doctest_bad.__doc__
nt.assert_equal(check,val,"doctest_bad docstrings don't match")
# Doctest skipping should work for class methods too
class FooClass(object):
"""FooClass
Example:
>>> 1+1
2
"""
def __init__(self,x):
"""Make a FooClass.
Example:
>>> f = FooClass(3)
junk
"""
print('Making a FooClass.')
self.x = x
def bar(self,y):
"""Example:
>>> ff = FooClass(3)
>>> ff.bar(0)
boom!
>>> 1/0
bam!
"""
return 1/y
def baz(self,y):
"""Example:
>>> ff2 = FooClass(3)
Making a FooClass.
>>> ff2.baz(3)
True
"""
return self.x==y
def test_skip_dt_decorator2():
"""Doctest-skipping decorator should preserve function signature.
"""
# Hardcoded correct answer
dtargs = (['x', 'y'], None, 'k', (1,))
# Introspect out the value
dtargsr = getargspec(doctest_bad)
assert dtargsr==dtargs, \
"Incorrectly reconstructed args for doctest_bad: %s" % (dtargsr,)
@dec.skip_linux
def test_linux():
nt.assert_false(sys.platform.startswith('linux'),"This test can't run under linux")
@dec.skip_win32
def test_win32():
nt.assert_not_equal(sys.platform,'win32',"This test can't run under windows")
@dec.skip_osx
def test_osx():
nt.assert_not_equal(sys.platform,'darwin',"This test can't run under osx")

137
packages/python/yap_kernel/yap_ipython/testing/tests/test_ipunittest.py Normal file
View File

@@ -0,0 +1,137 @@
"""Tests for yap_ipython's test support utilities.
These are decorators that allow standalone functions and docstrings to be seen
as tests by unittest, replicating some of nose's functionality. Additionally,
yap_ipython-syntax docstrings can be auto-converted to '>>>' so that ipython
sessions can be copy-pasted as tests.
This file can be run as a script, and it will call unittest.main(). We must
check that it works with unittest as well as with nose...
Notes:
- Using nosetests --with-doctest --doctest-tests testfile.py
will find docstrings as tests wherever they are, even in methods. But
if we use ipython syntax in the docstrings, they must be decorated with
@ipdocstring. This is OK for test-only code, but not for user-facing
docstrings where we want to keep the ipython syntax.
- Using nosetests --with-doctest file.py
also finds doctests if the file name doesn't have 'test' in it, because it is
treated like a normal module. But if nose treats the file like a test file,
then for normal classes to be doctested the extra --doctest-tests is
necessary.
- running this script with python (it has a __main__ section at the end) misses
one docstring test, the one embedded in the Foo object method. Since our
approach relies on using decorators that create standalone TestCase
instances, it can only be used for functions, not for methods of objects.
Authors
-------
- Fernando Perez <Fernando.Perez@berkeley.edu>
"""
#-----------------------------------------------------------------------------
# Copyright (C) 2009-2011 The yap_ipython Development Team
#
# Distributed under the terms of the BSD License. The full license is in
# the file COPYING, distributed as part of this software.
#-----------------------------------------------------------------------------
#-----------------------------------------------------------------------------
# Imports
#-----------------------------------------------------------------------------
from yap_ipython.testing.ipunittest import ipdoctest, ipdocstring
from yap_ipython.utils.py3compat import doctest_refactor_print
#-----------------------------------------------------------------------------
# Test classes and functions
#-----------------------------------------------------------------------------
@ipdoctest
@doctest_refactor_print
def simple_dt():
"""
>>> print 1+1
2
"""
@ipdoctest
@doctest_refactor_print
def ipdt_flush():
"""
In [20]: print 1
1
In [26]: for i in range(4):
....: print i
....:
....:
0
1
2
3
In [27]: 3+4
Out[27]: 7
"""
@ipdoctest
@doctest_refactor_print
def ipdt_indented_test():
"""
In [20]: print 1
1
In [26]: for i in range(4):
....: print i
....:
....:
0
1
2
3
In [27]: 3+4
Out[27]: 7
"""
class Foo(object):
"""For methods, the normal decorator doesn't work.
But rewriting the docstring with ip2py does, *but only if using nose
--with-doctest*. Do we want to have that as a dependency?
"""
@ipdocstring
@doctest_refactor_print
def ipdt_method(self):
"""
In [20]: print 1
1
In [26]: for i in range(4):
....: print i
....:
....:
0
1
2
3
In [27]: 3+4
Out[27]: 7
"""
@doctest_refactor_print
def normaldt_method(self):
"""
>>> print 1+1
2
"""

136
packages/python/yap_kernel/yap_ipython/testing/tests/test_tools.py Normal file
View File

@@ -0,0 +1,136 @@
# encoding: utf-8
"""
Tests for testing.tools
"""
#-----------------------------------------------------------------------------
# Copyright (C) 2008-2011 The yap_ipython Development Team
#
# Distributed under the terms of the BSD License. The full license is in
# the file COPYING, distributed as part of this software.
#-----------------------------------------------------------------------------
#-----------------------------------------------------------------------------
# Imports
#-----------------------------------------------------------------------------
import os
import unittest
import nose.tools as nt
from yap_ipython.testing import decorators as dec
from yap_ipython.testing import tools as tt
#-----------------------------------------------------------------------------
# Tests
#-----------------------------------------------------------------------------
@dec.skip_win32
def test_full_path_posix():
spath = '/foo/bar.py'
result = tt.full_path(spath,['a.txt','b.txt'])
nt.assert_equal(result, ['/foo/a.txt', '/foo/b.txt'])
spath = '/foo'
result = tt.full_path(spath,['a.txt','b.txt'])
nt.assert_equal(result, ['/a.txt', '/b.txt'])
result = tt.full_path(spath,'a.txt')
nt.assert_equal(result, ['/a.txt'])
@dec.skip_if_not_win32
def test_full_path_win32():
spath = 'c:\\foo\\bar.py'
result = tt.full_path(spath,['a.txt','b.txt'])
nt.assert_equal(result, ['c:\\foo\\a.txt', 'c:\\foo\\b.txt'])
spath = 'c:\\foo'
result = tt.full_path(spath,['a.txt','b.txt'])
nt.assert_equal(result, ['c:\\a.txt', 'c:\\b.txt'])
result = tt.full_path(spath,'a.txt')
nt.assert_equal(result, ['c:\\a.txt'])
def test_parser():
err = ("FAILED (errors=1)", 1, 0)
fail = ("FAILED (failures=1)", 0, 1)
both = ("FAILED (errors=1, failures=1)", 1, 1)
for txt, nerr, nfail in [err, fail, both]:
nerr1, nfail1 = tt.parse_test_output(txt)
nt.assert_equal(nerr, nerr1)
nt.assert_equal(nfail, nfail1)
def test_temp_pyfile():
src = 'pass\n'
fname, fh = tt.temp_pyfile(src)
assert os.path.isfile(fname)
fh.close()
with open(fname) as fh2:
src2 = fh2.read()
nt.assert_equal(src2, src)
class TestAssertPrints(unittest.TestCase):
def test_passing(self):
with tt.AssertPrints("abc"):
print("abcd")
print("def")
print(b"ghi")
def test_failing(self):
def func():
with tt.AssertPrints("abc"):
print("acd")
print("def")
print(b"ghi")
self.assertRaises(AssertionError, func)
class Test_ipexec_validate(unittest.TestCase, tt.TempFileMixin):
def test_main_path(self):
"""Test with only stdout results.
"""
self.mktmp("print('A')\n"
"print('B')\n"
)
out = "A\nB"
tt.ipexec_validate(self.fname, out)
def test_main_path2(self):
"""Test with only stdout results, expecting windows line endings.
"""
self.mktmp("print('A')\n"
"print('B')\n"
)
out = "A\r\nB"
tt.ipexec_validate(self.fname, out)
def test_exception_path(self):
"""Test exception path in exception_validate.
"""
self.mktmp("import sys\n"
"print('A')\n"
"print('B')\n"
"print('C', file=sys.stderr)\n"
"print('D', file=sys.stderr)\n"
)
out = "A\nB"
tt.ipexec_validate(self.fname, expected_out=out, expected_err="C\nD")
def test_exception_path2(self):
"""Test exception path in exception_validate, expecting windows line endings.
"""
self.mktmp("import sys\n"
"print('A')\n"
"print('B')\n"
"print('C', file=sys.stderr)\n"
"print('D', file=sys.stderr)\n"
)
out = "A\r\nB"
tt.ipexec_validate(self.fname, expected_out=out, expected_err="C\r\nD")
def tearDown(self):
# tear down correctly the mixin,
# unittest.TestCase.tearDown does nothing
tt.TempFileMixin.tearDown(self)