nltk 3.2__zip → 3.3__zip

{nltk-3.2 → nltk-3.3}/nltk/test/resolution.doctest

@@ -1,221 +1,221 @@
-.. Copyright (C) 2001-2015 NLTK Project
-.. For license information, see LICENSE.TXT
-
-=========================
-Resolution Theorem Prover
-=========================
-
-    >>> from nltk.inference.resolution import *
-    >>> from nltk.sem import logic
-    >>> from nltk.sem.logic import *
-    >>> logic._counter._value = 0
-    >>> read_expr = logic.Expression.fromstring
-
-    >>> P = read_expr('P')
-    >>> Q = read_expr('Q')
-    >>> R = read_expr('R')
-    >>> A = read_expr('A')
-    >>> B = read_expr('B')
-    >>> x = read_expr('x')
-    >>> y = read_expr('y')
-    >>> z = read_expr('z')
-
--------------------------------
-Test most_general_unification()
--------------------------------
-    >>> print(most_general_unification(x, x))
-    {}
-    >>> print(most_general_unification(A, A))
-    {}
-    >>> print(most_general_unification(A, x))
-    {x: A}
-    >>> print(most_general_unification(x, A))
-    {x: A}
-    >>> print(most_general_unification(x, y))
-    {x: y}
-    >>> print(most_general_unification(P(x), P(A)))
-    {x: A}
-    >>> print(most_general_unification(P(x,B), P(A,y)))
-    {x: A, y: B}
-    >>> print(most_general_unification(P(x,B), P(B,x)))
-    {x: B}
-    >>> print(most_general_unification(P(x,y), P(A,x)))
-    {x: A, y: x}
-    >>> print(most_general_unification(P(Q(x)), P(y)))
-    {y: Q(x)}
-
-------------
-Test unify()
-------------
-    >>> print(Clause([]).unify(Clause([])))
-    []
-    >>> print(Clause([P(x)]).unify(Clause([-P(A)])))
-    [{}]
-    >>> print(Clause([P(A), Q(x)]).unify(Clause([-P(x), R(x)])))
-    [{R(A), Q(A)}]
-    >>> print(Clause([P(A), Q(x), R(x,y)]).unify(Clause([-P(x), Q(y)])))
-    [{Q(y), Q(A), R(A,y)}]
-    >>> print(Clause([P(A), -Q(y)]).unify(Clause([-P(x), Q(B)])))
-    [{}]
-    >>> print(Clause([P(x), Q(x)]).unify(Clause([-P(A), -Q(B)])))
-    [{-Q(B), Q(A)}, {-P(A), P(B)}]
-    >>> print(Clause([P(x,x), Q(x), R(x)]).unify(Clause([-P(A,z), -Q(B)])))
-    [{-Q(B), Q(A), R(A)}, {-P(A,z), R(B), P(B,B)}]
-
-    >>> a = clausify(read_expr('P(A)'))
-    >>> b = clausify(read_expr('A=B'))
-    >>> print(a[0].unify(b[0]))
-    [{P(B)}]
-
--------------------------
-Test is_tautology()
--------------------------
-    >>> print(Clause([P(A), -P(A)]).is_tautology())
-    True
-    >>> print(Clause([-P(A), P(A)]).is_tautology())
-    True
-    >>> print(Clause([P(x), -P(A)]).is_tautology())
-    False
-    >>> print(Clause([Q(B), -P(A), P(A)]).is_tautology())
-    True
-    >>> print(Clause([-Q(A), P(R(A)), -P(R(A)), Q(x), -R(y)]).is_tautology())
-    True
-    >>> print(Clause([P(x), -Q(A)]).is_tautology())
-    False
-
--------------------------
-Test subsumes()
--------------------------
-    >>> print(Clause([P(A), Q(B)]).subsumes(Clause([P(A), Q(B)])))
-    True
-    >>> print(Clause([-P(A)]).subsumes(Clause([P(A)])))
-    False
-    >>> print(Clause([P(A), Q(B)]).subsumes(Clause([Q(B), P(A)])))
-    True
-    >>> print(Clause([P(A), Q(B)]).subsumes(Clause([Q(B), R(A), P(A)])))
-    True
-    >>> print(Clause([P(A), R(A), Q(B)]).subsumes(Clause([Q(B), P(A)])))
-    False
-    >>> print(Clause([P(x)]).subsumes(Clause([P(A)])))
-    True
-    >>> print(Clause([P(A)]).subsumes(Clause([P(x)])))
-    True
-
-------------
-Test prove()
-------------
-    >>> print(ResolutionProverCommand(read_expr('man(x)')).prove())
-    False
-    >>> print(ResolutionProverCommand(read_expr('(man(x) -> man(x))')).prove())
-    True
-    >>> print(ResolutionProverCommand(read_expr('(man(x) -> --man(x))')).prove())
-    True
-    >>> print(ResolutionProverCommand(read_expr('-(man(x) & -man(x))')).prove())
-    True
-    >>> print(ResolutionProverCommand(read_expr('(man(x) | -man(x))')).prove())
-    True
-    >>> print(ResolutionProverCommand(read_expr('(man(x) -> man(x))')).prove())
-    True
-    >>> print(ResolutionProverCommand(read_expr('-(man(x) & -man(x))')).prove())
-    True
-    >>> print(ResolutionProverCommand(read_expr('(man(x) | -man(x))')).prove())
-    True
-    >>> print(ResolutionProverCommand(read_expr('(man(x) -> man(x))')).prove())
-    True
-    >>> print(ResolutionProverCommand(read_expr('(man(x) <-> man(x))')).prove())
-    True
-    >>> print(ResolutionProverCommand(read_expr('-(man(x) <-> -man(x))')).prove())
-    True
-    >>> print(ResolutionProverCommand(read_expr('all x.man(x)')).prove())
-    False
-    >>> print(ResolutionProverCommand(read_expr('-all x.some y.F(x,y) & some x.all y.(-F(x,y))')).prove())
-    False
-    >>> print(ResolutionProverCommand(read_expr('some x.all y.sees(x,y)')).prove())
-    False
-
-    >>> p1 = read_expr('all x.(man(x) -> mortal(x))')
-    >>> p2 = read_expr('man(Socrates)')
-    >>> c = read_expr('mortal(Socrates)')
-    >>> ResolutionProverCommand(c, [p1,p2]).prove()
-    True
-
-    >>> p1 = read_expr('all x.(man(x) -> walks(x))')
-    >>> p2 = read_expr('man(John)')
-    >>> c = read_expr('some y.walks(y)')
-    >>> ResolutionProverCommand(c, [p1,p2]).prove()
-    True
-
-    >>> p = read_expr('some e1.some e2.(believe(e1,john,e2) & walk(e2,mary))')
-    >>> c = read_expr('some e0.walk(e0,mary)')
-    >>> ResolutionProverCommand(c, [p]).prove()
-    True
-
-------------
-Test proof()
-------------
-    >>> p1 = read_expr('all x.(man(x) -> mortal(x))')
-    >>> p2 = read_expr('man(Socrates)')
-    >>> c = read_expr('mortal(Socrates)')
-    >>> logic._counter._value = 0
-    >>> tp = ResolutionProverCommand(c, [p1,p2])
-    >>> tp.prove()
-    True
-    >>> print(tp.proof())
-    [1] {-mortal(Socrates)}     A
-    [2] {-man(z2), mortal(z2)}  A
-    [3] {man(Socrates)}         A
-    [4] {-man(Socrates)}        (1, 2)
-    [5] {mortal(Socrates)}      (2, 3)
-    [6] {}                      (1, 5)
-    <BLANKLINE>
-
-------------------
-Question Answering
-------------------
-One answer
-    >>> p1 = read_expr('father_of(art,john)')
-    >>> p2 = read_expr('father_of(bob,kim)')
-    >>> p3 = read_expr('all x.all y.(father_of(x,y) -> parent_of(x,y))')
-    >>> c = read_expr('all x.(parent_of(x,john) -> ANSWER(x))')
-    >>> logic._counter._value = 0
-    >>> tp = ResolutionProverCommand(None, [p1,p2,p3,c])
-    >>> sorted(tp.find_answers())
-    [<ConstantExpression art>]
-    >>> print(tp.proof()) # doctest: +SKIP
-    [1] {father_of(art,john)}                  A
-    [2] {father_of(bob,kim)}                   A
-    [3] {-father_of(z3,z4), parent_of(z3,z4)}  A
-    [4] {-parent_of(z6,john), ANSWER(z6)}      A
-    [5] {parent_of(art,john)}                  (1, 3)
-    [6] {parent_of(bob,kim)}                   (2, 3)
-    [7] {ANSWER(z6), -father_of(z6,john)}      (3, 4)
-    [8] {ANSWER(art)}                          (1, 7)
-    [9] {ANSWER(art)}                          (4, 5)
-    <BLANKLINE>
-
-Multiple answers
-    >>> p1 = read_expr('father_of(art,john)')
-    >>> p2 = read_expr('mother_of(ann,john)')
-    >>> p3 = read_expr('all x.all y.(father_of(x,y) -> parent_of(x,y))')
-    >>> p4 = read_expr('all x.all y.(mother_of(x,y) -> parent_of(x,y))')
-    >>> c = read_expr('all x.(parent_of(x,john) -> ANSWER(x))')
-    >>> logic._counter._value = 0
-    >>> tp = ResolutionProverCommand(None, [p1,p2,p3,p4,c])
-    >>> sorted(tp.find_answers())
-    [<ConstantExpression ann>, <ConstantExpression art>]
-    >>> print(tp.proof()) # doctest: +SKIP
-    [ 1] {father_of(art,john)}                  A
-    [ 2] {mother_of(ann,john)}                  A
-    [ 3] {-father_of(z3,z4), parent_of(z3,z4)}  A
-    [ 4] {-mother_of(z7,z8), parent_of(z7,z8)}  A
-    [ 5] {-parent_of(z10,john), ANSWER(z10)}    A
-    [ 6] {parent_of(art,john)}                  (1, 3)
-    [ 7] {parent_of(ann,john)}                  (2, 4)
-    [ 8] {ANSWER(z10), -father_of(z10,john)}    (3, 5)
-    [ 9] {ANSWER(art)}                          (1, 8)
-    [10] {ANSWER(z10), -mother_of(z10,john)}    (4, 5)
-    [11] {ANSWER(ann)}                          (2, 10)
-    [12] {ANSWER(art)}                          (5, 6)
-    [13] {ANSWER(ann)}                          (5, 7)
-    <BLANKLINE>
-
+.. Copyright (C) 2001-2018 NLTK Project
+.. For license information, see LICENSE.TXT
+
+=========================
+Resolution Theorem Prover
+=========================
+
+    >>> from nltk.inference.resolution import *
+    >>> from nltk.sem import logic
+    >>> from nltk.sem.logic import *
+    >>> logic._counter._value = 0
+    >>> read_expr = logic.Expression.fromstring
+
+    >>> P = read_expr('P')
+    >>> Q = read_expr('Q')
+    >>> R = read_expr('R')
+    >>> A = read_expr('A')
+    >>> B = read_expr('B')
+    >>> x = read_expr('x')
+    >>> y = read_expr('y')
+    >>> z = read_expr('z')
+
+-------------------------------
+Test most_general_unification()
+-------------------------------
+    >>> print(most_general_unification(x, x))
+    {}
+    >>> print(most_general_unification(A, A))
+    {}
+    >>> print(most_general_unification(A, x))
+    {x: A}
+    >>> print(most_general_unification(x, A))
+    {x: A}
+    >>> print(most_general_unification(x, y))
+    {x: y}
+    >>> print(most_general_unification(P(x), P(A)))
+    {x: A}
+    >>> print(most_general_unification(P(x,B), P(A,y)))
+    {x: A, y: B}
+    >>> print(most_general_unification(P(x,B), P(B,x)))
+    {x: B}
+    >>> print(most_general_unification(P(x,y), P(A,x)))
+    {x: A, y: x}
+    >>> print(most_general_unification(P(Q(x)), P(y)))
+    {y: Q(x)}
+
+------------
+Test unify()
+------------
+    >>> print(Clause([]).unify(Clause([])))
+    []
+    >>> print(Clause([P(x)]).unify(Clause([-P(A)])))
+    [{}]
+    >>> print(Clause([P(A), Q(x)]).unify(Clause([-P(x), R(x)])))
+    [{R(A), Q(A)}]
+    >>> print(Clause([P(A), Q(x), R(x,y)]).unify(Clause([-P(x), Q(y)])))
+    [{Q(y), Q(A), R(A,y)}]
+    >>> print(Clause([P(A), -Q(y)]).unify(Clause([-P(x), Q(B)])))
+    [{}]
+    >>> print(Clause([P(x), Q(x)]).unify(Clause([-P(A), -Q(B)])))
+    [{-Q(B), Q(A)}, {-P(A), P(B)}]
+    >>> print(Clause([P(x,x), Q(x), R(x)]).unify(Clause([-P(A,z), -Q(B)])))
+    [{-Q(B), Q(A), R(A)}, {-P(A,z), R(B), P(B,B)}]
+
+    >>> a = clausify(read_expr('P(A)'))
+    >>> b = clausify(read_expr('A=B'))
+    >>> print(a[0].unify(b[0]))
+    [{P(B)}]
+
+-------------------------
+Test is_tautology()
+-------------------------
+    >>> print(Clause([P(A), -P(A)]).is_tautology())
+    True
+    >>> print(Clause([-P(A), P(A)]).is_tautology())
+    True
+    >>> print(Clause([P(x), -P(A)]).is_tautology())
+    False
+    >>> print(Clause([Q(B), -P(A), P(A)]).is_tautology())
+    True
+    >>> print(Clause([-Q(A), P(R(A)), -P(R(A)), Q(x), -R(y)]).is_tautology())
+    True
+    >>> print(Clause([P(x), -Q(A)]).is_tautology())
+    False
+
+-------------------------
+Test subsumes()
+-------------------------
+    >>> print(Clause([P(A), Q(B)]).subsumes(Clause([P(A), Q(B)])))
+    True
+    >>> print(Clause([-P(A)]).subsumes(Clause([P(A)])))
+    False
+    >>> print(Clause([P(A), Q(B)]).subsumes(Clause([Q(B), P(A)])))
+    True
+    >>> print(Clause([P(A), Q(B)]).subsumes(Clause([Q(B), R(A), P(A)])))
+    True
+    >>> print(Clause([P(A), R(A), Q(B)]).subsumes(Clause([Q(B), P(A)])))
+    False
+    >>> print(Clause([P(x)]).subsumes(Clause([P(A)])))
+    True
+    >>> print(Clause([P(A)]).subsumes(Clause([P(x)])))
+    True
+
+------------
+Test prove()
+------------
+    >>> print(ResolutionProverCommand(read_expr('man(x)')).prove())
+    False
+    >>> print(ResolutionProverCommand(read_expr('(man(x) -> man(x))')).prove())
+    True
+    >>> print(ResolutionProverCommand(read_expr('(man(x) -> --man(x))')).prove())
+    True
+    >>> print(ResolutionProverCommand(read_expr('-(man(x) & -man(x))')).prove())
+    True
+    >>> print(ResolutionProverCommand(read_expr('(man(x) | -man(x))')).prove())
+    True
+    >>> print(ResolutionProverCommand(read_expr('(man(x) -> man(x))')).prove())
+    True
+    >>> print(ResolutionProverCommand(read_expr('-(man(x) & -man(x))')).prove())
+    True
+    >>> print(ResolutionProverCommand(read_expr('(man(x) | -man(x))')).prove())
+    True
+    >>> print(ResolutionProverCommand(read_expr('(man(x) -> man(x))')).prove())
+    True
+    >>> print(ResolutionProverCommand(read_expr('(man(x) <-> man(x))')).prove())
+    True
+    >>> print(ResolutionProverCommand(read_expr('-(man(x) <-> -man(x))')).prove())
+    True
+    >>> print(ResolutionProverCommand(read_expr('all x.man(x)')).prove())
+    False
+    >>> print(ResolutionProverCommand(read_expr('-all x.some y.F(x,y) & some x.all y.(-F(x,y))')).prove())
+    False
+    >>> print(ResolutionProverCommand(read_expr('some x.all y.sees(x,y)')).prove())
+    False
+
+    >>> p1 = read_expr('all x.(man(x) -> mortal(x))')
+    >>> p2 = read_expr('man(Socrates)')
+    >>> c = read_expr('mortal(Socrates)')
+    >>> ResolutionProverCommand(c, [p1,p2]).prove()
+    True
+
+    >>> p1 = read_expr('all x.(man(x) -> walks(x))')
+    >>> p2 = read_expr('man(John)')
+    >>> c = read_expr('some y.walks(y)')
+    >>> ResolutionProverCommand(c, [p1,p2]).prove()
+    True
+
+    >>> p = read_expr('some e1.some e2.(believe(e1,john,e2) & walk(e2,mary))')
+    >>> c = read_expr('some e0.walk(e0,mary)')
+    >>> ResolutionProverCommand(c, [p]).prove()
+    True
+
+------------
+Test proof()
+------------
+    >>> p1 = read_expr('all x.(man(x) -> mortal(x))')
+    >>> p2 = read_expr('man(Socrates)')
+    >>> c = read_expr('mortal(Socrates)')
+    >>> logic._counter._value = 0
+    >>> tp = ResolutionProverCommand(c, [p1,p2])
+    >>> tp.prove()
+    True
+    >>> print(tp.proof())
+    [1] {-mortal(Socrates)}     A
+    [2] {-man(z2), mortal(z2)}  A
+    [3] {man(Socrates)}         A
+    [4] {-man(Socrates)}        (1, 2)
+    [5] {mortal(Socrates)}      (2, 3)
+    [6] {}                      (1, 5)
+    <BLANKLINE>
+
+------------------
+Question Answering
+------------------
+One answer
+    >>> p1 = read_expr('father_of(art,john)')
+    >>> p2 = read_expr('father_of(bob,kim)')
+    >>> p3 = read_expr('all x.all y.(father_of(x,y) -> parent_of(x,y))')
+    >>> c = read_expr('all x.(parent_of(x,john) -> ANSWER(x))')
+    >>> logic._counter._value = 0
+    >>> tp = ResolutionProverCommand(None, [p1,p2,p3,c])
+    >>> sorted(tp.find_answers())
+    [<ConstantExpression art>]
+    >>> print(tp.proof()) # doctest: +SKIP
+    [1] {father_of(art,john)}                  A
+    [2] {father_of(bob,kim)}                   A
+    [3] {-father_of(z3,z4), parent_of(z3,z4)}  A
+    [4] {-parent_of(z6,john), ANSWER(z6)}      A
+    [5] {parent_of(art,john)}                  (1, 3)
+    [6] {parent_of(bob,kim)}                   (2, 3)
+    [7] {ANSWER(z6), -father_of(z6,john)}      (3, 4)
+    [8] {ANSWER(art)}                          (1, 7)
+    [9] {ANSWER(art)}                          (4, 5)
+    <BLANKLINE>
+
+Multiple answers
+    >>> p1 = read_expr('father_of(art,john)')
+    >>> p2 = read_expr('mother_of(ann,john)')
+    >>> p3 = read_expr('all x.all y.(father_of(x,y) -> parent_of(x,y))')
+    >>> p4 = read_expr('all x.all y.(mother_of(x,y) -> parent_of(x,y))')
+    >>> c = read_expr('all x.(parent_of(x,john) -> ANSWER(x))')
+    >>> logic._counter._value = 0
+    >>> tp = ResolutionProverCommand(None, [p1,p2,p3,p4,c])
+    >>> sorted(tp.find_answers())
+    [<ConstantExpression ann>, <ConstantExpression art>]
+    >>> print(tp.proof()) # doctest: +SKIP
+    [ 1] {father_of(art,john)}                  A
+    [ 2] {mother_of(ann,john)}                  A
+    [ 3] {-father_of(z3,z4), parent_of(z3,z4)}  A
+    [ 4] {-mother_of(z7,z8), parent_of(z7,z8)}  A
+    [ 5] {-parent_of(z10,john), ANSWER(z10)}    A
+    [ 6] {parent_of(art,john)}                  (1, 3)
+    [ 7] {parent_of(ann,john)}                  (2, 4)
+    [ 8] {ANSWER(z10), -father_of(z10,john)}    (3, 5)
+    [ 9] {ANSWER(art)}                          (1, 8)
+    [10] {ANSWER(z10), -mother_of(z10,john)}    (4, 5)
+    [11] {ANSWER(ann)}                          (2, 10)
+    [12] {ANSWER(art)}                          (5, 6)
+    [13] {ANSWER(ann)}                          (5, 7)
+    <BLANKLINE>
+

{nltk-3.2 → nltk-3.3}/nltk/test/runtests.py

@@ -1,64 +1,86 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-from __future__ import absolute_import, print_function
-import sys
-import os
-import nose
-from nose.plugins.manager import PluginManager
-from nose.plugins.doctests import Doctest
-from nose.plugins import builtin
-
-NLTK_ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..'))
-sys.path.insert(0, NLTK_ROOT)
-
-NLTK_TEST_DIR = os.path.join(NLTK_ROOT, 'nltk')
-
-if __name__ == '__main__':
-    # there shouldn't be import from NLTK for coverage to work properly
-    from doctest_nose_plugin import DoctestFix
-
-    class NltkPluginManager(PluginManager):
-        """
-        Nose plugin manager that replaces standard doctest plugin
-        with a patched version.
-        """
-        def loadPlugins(self):
-            for plug in builtin.plugins:
-                if plug != Doctest:
-                    self.addPlugin(plug())
-            self.addPlugin(DoctestFix())
-            super(NltkPluginManager, self).loadPlugins()
-
-    manager = NltkPluginManager()
-    manager.loadPlugins()
-
-    # allow passing extra options and running individual tests
-    # Examples:
-    #
-    #    python runtests.py semantics.doctest
-    #    python runtests.py --with-id -v
-    #    python runtests.py --with-id -v nltk.featstruct
-
-    args = sys.argv[1:]
-    if not args:
-        args = [NLTK_TEST_DIR]
-
-    if all(arg.startswith('-') for arg in args):
-        # only extra options were passed
-        args += [NLTK_TEST_DIR]
-
-    arguments = [
-        '--exclude=', # why is this needed?
-        #'--with-xunit',
-        #'--xunit-file=$WORKSPACE/nosetests.xml',
-        #'--nocapture',
-        '--with-doctest',
-        #'--doctest-tests',
-        #'--debug=nose,nose.importer,nose.inspector,nose.plugins,nose.result,nose.selector',
-        '--doctest-extension=.doctest',
-        '--doctest-fixtures=_fixt',
-        '--doctest-options=+ELLIPSIS,+NORMALIZE_WHITESPACE,+IGNORE_EXCEPTION_DETAIL,+ALLOW_UNICODE,doctestencoding=utf-8',
-        #'--verbosity=3',
-    ] + args
-
-    nose.main(argv=arguments, plugins=manager.plugins)
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+from __future__ import absolute_import, print_function
+import sys
+import os
+import nose
+from nose.plugins.manager import PluginManager
+from nose.plugins.doctests import Doctest
+from nose.plugins import builtin
+
+NLTK_ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..'))
+sys.path.insert(0, NLTK_ROOT)
+
+NLTK_TEST_DIR = os.path.join(NLTK_ROOT, 'nltk')
+
+if __name__ == '__main__':
+    # there shouldn't be import from NLTK for coverage to work properly
+    from doctest_nose_plugin import DoctestFix
+
+    try:
+        # Import RedNose plugin for colored test output
+        from rednose import RedNose
+
+        rednose_available = True
+    except ImportError:
+        rednose_available = False
+
+
+    class NltkPluginManager(PluginManager):
+        """
+        Nose plugin manager that replaces standard doctest plugin
+        with a patched version and adds RedNose plugin for colored test output.
+        """
+
+        def loadPlugins(self):
+            for plug in builtin.plugins:
+                if plug != Doctest:
+                    self.addPlugin(plug())
+            self.addPlugin(DoctestFix())
+            if rednose_available:
+                self.addPlugin(RedNose())
+
+            super(NltkPluginManager, self).loadPlugins()
+
+
+    manager = NltkPluginManager()
+    manager.loadPlugins()
+
+    # allow passing extra options and running individual tests
+    # Examples:
+    #
+    #    python runtests.py semantics.doctest
+    #    python runtests.py --with-id -v
+    #    python runtests.py --with-id -v nltk.featstruct
+
+    args = sys.argv[1:]
+    if not args:
+        args = [NLTK_TEST_DIR]
+
+    if all(arg.startswith('-') for arg in args):
+        # only extra options were passed
+        args += [NLTK_TEST_DIR]
+
+    # Activate RedNose and hide skipped test messages from output
+    if rednose_available:
+        args += [
+            '--rednose',
+            '--hide-skips'
+        ]
+
+    arguments = [
+                    '--exclude=',  # why is this needed?
+                    # '--with-xunit',
+                    # '--xunit-file=$WORKSPACE/nosetests.xml',
+                    # '--nocapture',
+                    '--with-doctest',
+                    # '--doctest-tests',
+                    # '--debug=nose,nose.importer,nose.inspector,nose.plugins,nose.result,nose.selector',
+                    '--doctest-extension=.doctest',
+                    '--doctest-fixtures=_fixt',
+                    '--doctest-options=+ELLIPSIS,+NORMALIZE_WHITESPACE,+IGNORE_EXCEPTION_DETAIL,+ALLOW_UNICODE,'
+                    'doctestencoding=utf-8',
+                    # '--verbosity=3',
+                ] + args
+
+    nose.main(argv=arguments, plugins=manager.plugins)

{nltk-3.2 → nltk-3.3}/nltk/test/segmentation_fixt.py

@@ -1,11 +1,11 @@
-# -*- coding: utf-8 -*-
-from __future__ import absolute_import
-
-
-# skip segmentation.doctest if numpy is not available
-def setup_module(module):
-    from nose import SkipTest
-    try:
-        import numpy
-    except ImportError:
+# -*- coding: utf-8 -*-
+from __future__ import absolute_import
+
+
+# skip segmentation.doctest if numpy is not available
+def setup_module(module):
+    from nose import SkipTest
+    try:
+        import numpy
+    except ImportError:
         raise SkipTest("segmentation.doctest requires numpy")