s/assert_/assertTrue/

IPython/config/tests/test_configurable.py

@@ -1,183 +1,183 b''
 # encoding: utf-8
 """
 Tests for IPython.config.configurable
 
 Authors:
 
 * Brian Granger
 * Fernando Perez (design help)
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-2011  The 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 unittest import TestCase
 
 from IPython.config.configurable import (
     Configurable, 
     SingletonConfigurable
 )
 
 from IPython.utils.traitlets import (
     Integer, Float, Unicode
 )
 
 from IPython.config.loader import Config
 from IPython.utils.py3compat import PY3
 
 #-----------------------------------------------------------------------------
 # Test cases
 #-----------------------------------------------------------------------------
 
 
 class MyConfigurable(Configurable):
     a = Integer(1, config=True, help="The integer a.")
     b = Float(1.0, config=True, help="The integer b.")
     c = Unicode('no config')
 
 
 mc_help=u"""MyConfigurable options
 ----------------------
 --MyConfigurable.a=<Integer>
     Default: 1
     The integer a.
 --MyConfigurable.b=<Float>
     Default: 1.0
     The integer b."""
 
 mc_help_inst=u"""MyConfigurable options
 ----------------------
 --MyConfigurable.a=<Integer>
     Current: 5
     The integer a.
 --MyConfigurable.b=<Float>
     Current: 4.0
     The integer b."""
 
 # On Python 3, the Integer trait is a synonym for Int
 if PY3:
     mc_help = mc_help.replace(u"<Integer>", u"<Int>")
     mc_help_inst = mc_help_inst.replace(u"<Integer>", u"<Int>")
 
 class Foo(Configurable):
     a = Integer(0, config=True, help="The integer a.")
     b = Unicode('nope', config=True)
 
 
 class Bar(Foo):
     b = Unicode('gotit', config=False, help="The string b.")
     c = Float(config=True, help="The string c.")
 
 
 class TestConfigurable(TestCase):
 
     def test_default(self):
         c1 = Configurable()
         c2 = Configurable(config=c1.config)
         c3 = Configurable(config=c2.config)
         self.assertEqual(c1.config, c2.config)
         self.assertEqual(c2.config, c3.config)
 
     def test_custom(self):
         config = Config()
         config.foo = 'foo'
         config.bar = 'bar'
         c1 = Configurable(config=config)
         c2 = Configurable(config=c1.config)
         c3 = Configurable(config=c2.config)
         self.assertEqual(c1.config, config)
         self.assertEqual(c2.config, config)
         self.assertEqual(c3.config, config)
         # Test that copies are not made
-        self.assert_(c1.config is config)
-        self.assert_(c2.config is config)
-        self.assert_(c3.config is config)
-        self.assert_(c1.config is c2.config)
-        self.assert_(c2.config is c3.config)
+        self.assertTrue(c1.config is config)
+        self.assertTrue(c2.config is config)
+        self.assertTrue(c3.config is config)
+        self.assertTrue(c1.config is c2.config)
+        self.assertTrue(c2.config is c3.config)
         
     def test_inheritance(self):
         config = Config()
         config.MyConfigurable.a = 2
         config.MyConfigurable.b = 2.0
         c1 = MyConfigurable(config=config)
         c2 = MyConfigurable(config=c1.config)
         self.assertEqual(c1.a, config.MyConfigurable.a)
         self.assertEqual(c1.b, config.MyConfigurable.b)
         self.assertEqual(c2.a, config.MyConfigurable.a)
         self.assertEqual(c2.b, config.MyConfigurable.b)
 
     def test_parent(self):
         config = Config()
         config.Foo.a = 10
         config.Foo.b = "wow"
         config.Bar.b = 'later'
         config.Bar.c = 100.0
         f = Foo(config=config)
         b = Bar(config=f.config)
         self.assertEqual(f.a, 10)
         self.assertEqual(f.b, 'wow')
         self.assertEqual(b.b, 'gotit')
         self.assertEqual(b.c, 100.0)
 
     def test_override1(self):
         config = Config()
         config.MyConfigurable.a = 2
         config.MyConfigurable.b = 2.0
         c = MyConfigurable(a=3, config=config)
         self.assertEqual(c.a, 3)
         self.assertEqual(c.b, config.MyConfigurable.b)
         self.assertEqual(c.c, 'no config')
 
     def test_override2(self):
         config = Config()
         config.Foo.a = 1
         config.Bar.b = 'or'  # Up above b is config=False, so this won't do it.
         config.Bar.c = 10.0
         c = Bar(config=config)
         self.assertEqual(c.a, config.Foo.a)
         self.assertEqual(c.b, 'gotit')
         self.assertEqual(c.c, config.Bar.c)
         c = Bar(a=2, b='and', c=20.0, config=config)
         self.assertEqual(c.a, 2)
         self.assertEqual(c.b, 'and')
         self.assertEqual(c.c, 20.0)
 
     def test_help(self):
         self.assertEqual(MyConfigurable.class_get_help(), mc_help)
 
     def test_help_inst(self):
         inst = MyConfigurable(a=5, b=4)
         self.assertEqual(MyConfigurable.class_get_help(inst), mc_help_inst)
 
 
 class TestSingletonConfigurable(TestCase):
 
     def test_instance(self):
         from IPython.config.configurable import SingletonConfigurable
         class Foo(SingletonConfigurable): pass
         self.assertEqual(Foo.initialized(), False)
         foo = Foo.instance()
         self.assertEqual(Foo.initialized(), True)
         self.assertEqual(foo, Foo.instance())
         self.assertEqual(SingletonConfigurable._instance, None)
 
     def test_inheritance(self):
         class Bar(SingletonConfigurable): pass
         class Bam(Bar): pass
         self.assertEqual(Bar.initialized(), False)
         self.assertEqual(Bam.initialized(), False)
         bam = Bam.instance()
         bam == Bar.instance()
         self.assertEqual(Bar.initialized(), True)
         self.assertEqual(Bam.initialized(), True)
         self.assertEqual(bam, Bam._instance)
         self.assertEqual(bam, Bar._instance)
         self.assertEqual(SingletonConfigurable._instance, None)

IPython/config/tests/test_loader.py

@@ -1,263 +1,263 b''
 # encoding: utf-8
 """
 Tests for IPython.config.loader
 
 Authors:
 
 * Brian Granger
 * Fernando Perez (design help)
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-2011  The 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 sys
 from tempfile import mkstemp
 from unittest import TestCase
 
 from nose import SkipTest
 
 from IPython.testing.tools import mute_warn
 
 from IPython.utils.traitlets import Unicode
 from IPython.config.configurable import Configurable
 from IPython.config.loader import (
     Config,
     PyFileConfigLoader,
     KeyValueConfigLoader,
     ArgParseConfigLoader,
     KVArgParseConfigLoader,
     ConfigError
 )
 
 #-----------------------------------------------------------------------------
 # Actual tests
 #-----------------------------------------------------------------------------
 
 
 pyfile = """
 c = get_config()
 c.a=10
 c.b=20
 c.Foo.Bar.value=10
 c.Foo.Bam.value=list(range(10))  # list() is just so it's the same on Python 3
 c.D.C.value='hi there'
 """
 
 class TestPyFileCL(TestCase):
 
     def test_basic(self):
         fd, fname = mkstemp('.py')
         f = os.fdopen(fd, 'w')
         f.write(pyfile)
         f.close()
         # Unlink the file
         cl = PyFileConfigLoader(fname)
         config = cl.load_config()
         self.assertEqual(config.a, 10)
         self.assertEqual(config.b, 20)
         self.assertEqual(config.Foo.Bar.value, 10)
         self.assertEqual(config.Foo.Bam.value, range(10))
         self.assertEqual(config.D.C.value, 'hi there')
 
 class MyLoader1(ArgParseConfigLoader):
     def _add_arguments(self, aliases=None, flags=None):
         p = self.parser
         p.add_argument('-f', '--foo', dest='Global.foo', type=str)
         p.add_argument('-b', dest='MyClass.bar', type=int)
         p.add_argument('-n', dest='n', action='store_true')
         p.add_argument('Global.bam', type=str)
 
 class MyLoader2(ArgParseConfigLoader):
     def _add_arguments(self, aliases=None, flags=None):
         subparsers = self.parser.add_subparsers(dest='subparser_name')
         subparser1 = subparsers.add_parser('1')
         subparser1.add_argument('-x',dest='Global.x')
         subparser2 = subparsers.add_parser('2')
         subparser2.add_argument('y')
 
 class TestArgParseCL(TestCase):
 
     def test_basic(self):
         cl = MyLoader1()
         config = cl.load_config('-f hi -b 10 -n wow'.split())
         self.assertEqual(config.Global.foo, 'hi')
         self.assertEqual(config.MyClass.bar, 10)
         self.assertEqual(config.n, True)
         self.assertEqual(config.Global.bam, 'wow')
         config = cl.load_config(['wow'])
         self.assertEqual(config.keys(), ['Global'])
         self.assertEqual(config.Global.keys(), ['bam'])
         self.assertEqual(config.Global.bam, 'wow')
 
     def test_add_arguments(self):
         cl = MyLoader2()
         config = cl.load_config('2 frobble'.split())
         self.assertEqual(config.subparser_name, '2')
         self.assertEqual(config.y, 'frobble')
         config = cl.load_config('1 -x frobble'.split())
         self.assertEqual(config.subparser_name, '1')
         self.assertEqual(config.Global.x, 'frobble')
 
     def test_argv(self):
         cl = MyLoader1(argv='-f hi -b 10 -n wow'.split())
         config = cl.load_config()
         self.assertEqual(config.Global.foo, 'hi')
         self.assertEqual(config.MyClass.bar, 10)
         self.assertEqual(config.n, True)
         self.assertEqual(config.Global.bam, 'wow')
 
 
 class TestKeyValueCL(TestCase):
     klass = KeyValueConfigLoader
 
     def test_basic(self):
         cl = self.klass()
         argv = ['--'+s.strip('c.') for s in pyfile.split('\n')[2:-1]]
         with mute_warn():
             config = cl.load_config(argv)
         self.assertEqual(config.a, 10)
         self.assertEqual(config.b, 20)
         self.assertEqual(config.Foo.Bar.value, 10)
         self.assertEqual(config.Foo.Bam.value, range(10))
         self.assertEqual(config.D.C.value, 'hi there')
     
     def test_expanduser(self):
         cl = self.klass()
         argv = ['--a=~/1/2/3', '--b=~', '--c=~/', '--d="~/"']
         with mute_warn():
             config = cl.load_config(argv)
         self.assertEqual(config.a, os.path.expanduser('~/1/2/3'))
         self.assertEqual(config.b, os.path.expanduser('~'))
         self.assertEqual(config.c, os.path.expanduser('~/'))
         self.assertEqual(config.d, '~/')
     
     def test_extra_args(self):
         cl = self.klass()
         with mute_warn():
             config = cl.load_config(['--a=5', 'b', '--c=10', 'd'])
         self.assertEqual(cl.extra_args, ['b', 'd'])
         self.assertEqual(config.a, 5)
         self.assertEqual(config.c, 10)
         with mute_warn():
             config = cl.load_config(['--', '--a=5', '--c=10'])
         self.assertEqual(cl.extra_args, ['--a=5', '--c=10'])
     
     def test_unicode_args(self):
         cl = self.klass()
         argv = [u'--a=épsîlön']
         with mute_warn():
             config = cl.load_config(argv)
         self.assertEqual(config.a, u'épsîlön')
     
     def test_unicode_bytes_args(self):
         uarg = u'--a=é'
         try:
             barg = uarg.encode(sys.stdin.encoding)
         except (TypeError, UnicodeEncodeError):
             raise SkipTest("sys.stdin.encoding can't handle 'é'")
         
         cl = self.klass()
         with mute_warn():
             config = cl.load_config([barg])
         self.assertEqual(config.a, u'é')
     
     def test_unicode_alias(self):
         cl = self.klass()
         argv = [u'--a=épsîlön']
         with mute_warn():
             config = cl.load_config(argv, aliases=dict(a='A.a'))
         self.assertEqual(config.A.a, u'épsîlön')
 
 
 class TestArgParseKVCL(TestKeyValueCL):
     klass = KVArgParseConfigLoader
 
     def test_expanduser2(self):
         cl = self.klass()
         argv = ['-a', '~/1/2/3', '--b', "'~/1/2/3'"]
         with mute_warn():
             config = cl.load_config(argv, aliases=dict(a='A.a', b='A.b'))
         self.assertEqual(config.A.a, os.path.expanduser('~/1/2/3'))
         self.assertEqual(config.A.b, '~/1/2/3')
     
     def test_eval(self):
         cl = self.klass()
         argv = ['-c', 'a=5']
         with mute_warn():
             config = cl.load_config(argv, aliases=dict(c='A.c'))
         self.assertEqual(config.A.c, u"a=5")
     
 
 class TestConfig(TestCase):
 
     def test_setget(self):
         c = Config()
         c.a = 10
         self.assertEqual(c.a, 10)
         self.assertEqual('b' in c, False)
 
     def test_auto_section(self):
         c = Config()
         self.assertEqual('A' in c, True)
         self.assertEqual(c._has_section('A'), False)
         A = c.A
         A.foo = 'hi there'
         self.assertEqual(c._has_section('A'), True)
         self.assertEqual(c.A.foo, 'hi there')
         del c.A
         self.assertEqual(len(c.A.keys()),0)
 
     def test_merge_doesnt_exist(self):
         c1 = Config()
         c2 = Config()
         c2.bar = 10
         c2.Foo.bar = 10
         c1._merge(c2)
         self.assertEqual(c1.Foo.bar, 10)
         self.assertEqual(c1.bar, 10)
         c2.Bar.bar = 10
         c1._merge(c2)
         self.assertEqual(c1.Bar.bar, 10)
 
     def test_merge_exists(self):
         c1 = Config()
         c2 = Config()
         c1.Foo.bar = 10
         c1.Foo.bam = 30
         c2.Foo.bar = 20
         c2.Foo.wow = 40
         c1._merge(c2)
         self.assertEqual(c1.Foo.bam, 30)
         self.assertEqual(c1.Foo.bar, 20)
         self.assertEqual(c1.Foo.wow, 40)
         c2.Foo.Bam.bam = 10
         c1._merge(c2)
         self.assertEqual(c1.Foo.Bam.bam, 10)
 
     def test_deepcopy(self):
         c1 = Config()
         c1.Foo.bar = 10
         c1.Foo.bam = 30
         c1.a = 'asdf'
         c1.b = range(10)
         import copy
         c2 = copy.deepcopy(c1)
         self.assertEqual(c1, c2)
-        self.assert_(c1 is not c2)
-        self.assert_(c1.Foo is not c2.Foo)
+        self.assertTrue(c1 is not c2)
+        self.assertTrue(c1.Foo is not c2.Foo)
 
     def test_builtin(self):
         c1 = Config()
         exec 'foo = True' in c1
         self.assertEqual(c1.foo, True)
         self.assertRaises(ConfigError, setattr, c1, 'ValueError', 10)

IPython/frontend/html/notebook/tests/test_kernelsession.py

@@ -1,27 +1,27 b''
 """Tests for the notebook kernel and session manager."""
 
 from unittest import TestCase
 
 from IPython.frontend.html.notebook.kernelmanager import MultiKernelManager
 
 class TestKernelManager(TestCase):
 
     def test_km_lifecycle(self):
         km = MultiKernelManager()
         kid = km.start_kernel()
-        self.assert_(kid in km)
+        self.assertTrue(kid in km)
         self.assertEqual(len(km),1)
         km.kill_kernel(kid)
-        self.assert_(not kid in km)
+        self.assertTrue(not kid in km)
 
         kid = km.start_kernel()
         self.assertEqual('127.0.0.1',km.get_kernel_ip(kid))
         port_dict = km.get_kernel_ports(kid)
-        self.assert_('stdin_port' in port_dict)
-        self.assert_('iopub_port' in port_dict)
-        self.assert_('shell_port' in port_dict)
-        self.assert_('hb_port' in port_dict)
+        self.assertTrue('stdin_port' in port_dict)
+        self.assertTrue('iopub_port' in port_dict)
+        self.assertTrue('shell_port' in port_dict)
+        self.assertTrue('hb_port' in port_dict)
         km.get_kernel(kid)
         km.kill_kernel(kid)
 
 

IPython/frontend/qt/console/tests/test_kill_ring.py

@@ -1,85 +1,85 b''
 # Standard library imports
 import unittest
 
 # System library imports
 from IPython.external.qt import QtCore, QtGui
 
 # Local imports
 from IPython.frontend.qt.console.kill_ring import KillRing, QtKillRing
 
 
 class TestKillRing(unittest.TestCase):
 
     @classmethod
     def setUpClass(cls):
         """ Create the application for the test case.
         """
         cls._app = QtGui.QApplication.instance()
         if cls._app is None:
             cls._app = QtGui.QApplication([])
         cls._app.setQuitOnLastWindowClosed(False)
 
     @classmethod
     def tearDownClass(cls):
         """ Exit the application.
         """
         QtGui.QApplication.quit()
 
     def test_generic(self):
         """ Does the generic kill ring work?
         """
         ring = KillRing()
-        self.assert_(ring.yank() is None)
-        self.assert_(ring.rotate() is None)
+        self.assertTrue(ring.yank() is None)
+        self.assertTrue(ring.rotate() is None)
 
         ring.kill('foo')
         self.assertEqual(ring.yank(), 'foo')
-        self.assert_(ring.rotate() is None)
+        self.assertTrue(ring.rotate() is None)
         self.assertEqual(ring.yank(), 'foo')
 
         ring.kill('bar')
         self.assertEqual(ring.yank(), 'bar')
         self.assertEqual(ring.rotate(), 'foo')
 
         ring.clear()
-        self.assert_(ring.yank() is None)
-        self.assert_(ring.rotate() is None)
+        self.assertTrue(ring.yank() is None)
+        self.assertTrue(ring.rotate() is None)
 
     def test_qt_basic(self):
         """ Does the Qt kill ring work?
         """
         text_edit = QtGui.QPlainTextEdit()
         ring = QtKillRing(text_edit)
 
         ring.kill('foo')
         ring.kill('bar')
         ring.yank()
         ring.rotate()
         ring.yank()
         self.assertEqual(text_edit.toPlainText(), 'foobar')
 
         text_edit.clear()
         ring.kill('baz')
         ring.yank()
         ring.rotate()
         ring.rotate()
         ring.rotate()
         self.assertEqual(text_edit.toPlainText(), 'foo')
 
     def test_qt_cursor(self):
         """ Does the Qt kill ring maintain state with cursor movement?
         """
         text_edit = QtGui.QPlainTextEdit()
         ring = QtKillRing(text_edit)
         
         ring.kill('foo')
         ring.kill('bar')
         ring.yank()
         text_edit.moveCursor(QtGui.QTextCursor.Left)
         ring.rotate()
         self.assertEqual(text_edit.toPlainText(), 'bar')
 
 
 if __name__ == '__main__':
     import nose
     nose.main()

IPython/lib/tests/test_irunner.py

@@ -1,180 +1,180 b''
 """Test suite for the irunner module.
 
 Not the most elegant or fine-grained, but it does cover at least the bulk
 functionality."""
 from __future__ import print_function
 
 # Global to make tests extra verbose and help debugging
 VERBOSE = True
 
 # stdlib imports
 import StringIO
 import sys
 import unittest
 
 # IPython imports
 from IPython.lib import irunner
 from IPython.utils.py3compat import doctest_refactor_print
 
 # Testing code begins
 class RunnerTestCase(unittest.TestCase):
 
     def setUp(self):
         self.out = StringIO.StringIO()
         #self.out = sys.stdout
 
     def _test_runner(self,runner,source,output):
         """Test that a given runner's input/output match."""
         
         runner.run_source(source)
         out = self.out.getvalue()
         #out = ''
         # this output contains nasty \r\n lineends, and the initial ipython
         # banner.  clean it up for comparison, removing lines of whitespace
         output_l = [l for l in output.splitlines() if l and not l.isspace()]
         out_l = [l for l in out.splitlines() if l and not l.isspace()]
         mismatch  = 0
         if len(output_l) != len(out_l):
             message = ("Mismatch in number of lines\n\n"
                        "Expected:\n"
                        "~~~~~~~~~\n"
                        "%s\n\n"
                        "Got:\n"
                        "~~~~~~~~~\n"
                        "%s"
                        ) % ("\n".join(output_l), "\n".join(out_l))
             self.fail(message)
         for n in range(len(output_l)):
             # Do a line-by-line comparison
             ol1 = output_l[n].strip()
             ol2 = out_l[n].strip()
             if ol1 != ol2:
                 mismatch += 1
                 if VERBOSE:
                     print('<<< line %s does not match:' % n)
                     print(repr(ol1))
                     print(repr(ol2))
                     print('>>>')
-        self.assert_(mismatch==0,'Number of mismatched lines: %s' %
+        self.assertTrue(mismatch==0,'Number of mismatched lines: %s' %
                      mismatch)
 
     def testIPython(self):
         """Test the IPython runner."""
         source = doctest_refactor_print("""
 print 'hello, this is python'
 # some more code
 x=1;y=2
 x+y**2
 
 # An example of autocall functionality
 from math import *
 autocall 1
 cos pi
 autocall 0
 cos pi
 cos(pi)
 
 for i in range(5):
     print i
 
 print "that's all folks!"
 
 exit
 """)
         output = doctest_refactor_print("""\
 In [1]: print 'hello, this is python'
 hello, this is python
 
 
 # some more code
 In [2]: x=1;y=2
 
 In [3]: x+y**2
 Out[3]: 5
 
 
 # An example of autocall functionality
 In [4]: from math import *
 
 In [5]: autocall 1
 Automatic calling is: Smart
 
 In [6]: cos pi
 ------> cos(pi)
 Out[6]: -1.0
 
 In [7]: autocall 0
 Automatic calling is: OFF
 
 In [8]: cos pi
    File "<ipython-input-8-6bd7313dd9a9>", line 1
      cos pi
           ^
 SyntaxError: invalid syntax
 
 
 In [9]: cos(pi)
 Out[9]: -1.0
 
 
 In [10]: for i in range(5):
    ....:     print i
    ....:
 0
 1
 2
 3
 4
 
 In [11]: print "that's all folks!"
 that's all folks!
 
 
 In [12]: exit
 """)
         runner = irunner.IPythonRunner(out=self.out)
         self._test_runner(runner,source,output)
 
     def testPython(self):
         """Test the Python runner."""
         runner = irunner.PythonRunner(out=self.out)
         source = doctest_refactor_print("""
 print 'hello, this is python'
 
 # some more code
 x=1;y=2
 x+y**2
 
 from math import *
 cos(pi)
 
 for i in range(5):
     print i
 
 print "that's all folks!"
         """)
         output = doctest_refactor_print("""\
 >>> print 'hello, this is python'
 hello, this is python
 
 # some more code
 >>> x=1;y=2
 >>> x+y**2
 5
 
 >>> from math import *
 >>> cos(pi)
 -1.0
 
 >>> for i in range(5):
 ...     print i
 ...
 0
 1
 2
 3
 4
 >>> print "that's all folks!"
 that's all folks!
 """)
         self._test_runner(runner,source,output)

IPython/lib/tests/test_irunner_pylab_magic.py

@@ -1,119 +1,119 b''
 """Test suite for pylab_import_all magic
 Modified from the irunner module but using regex.
 """
 from __future__ import print_function
 
 # Global to make tests extra verbose and help debugging
 VERBOSE = True
 
 # stdlib imports
 import StringIO
 import sys
 import unittest
 import re
 
 # IPython imports
 from IPython.lib import irunner
 from IPython.testing import decorators
 
 def pylab_not_importable():
     """Test if importing pylab fails with RuntimeError (true when having no display)"""
     try:
         import pylab
         return False
     except RuntimeError:
         return True
 
 # Testing code begins
 class RunnerTestCase(unittest.TestCase):
 
     def setUp(self):
         self.out = StringIO.StringIO()
         #self.out = sys.stdout
 
     def _test_runner(self,runner,source,output):
         """Test that a given runner's input/output match."""
 
         runner.run_source(source)
         out = self.out.getvalue()
         #out = ''
         # this output contains nasty \r\n lineends, and the initial ipython
         # banner.  clean it up for comparison, removing lines of whitespace
         output_l = [l for l in output.splitlines() if l and not l.isspace()]
         out_l = [l for l in out.splitlines() if l and not l.isspace()]
         mismatch  = 0
         if len(output_l) != len(out_l):
             message = ("Mismatch in number of lines\n\n"
                        "Expected:\n"
                        "~~~~~~~~~\n"
                        "%s\n\n"
                        "Got:\n"
                        "~~~~~~~~~\n"
                        "%s"
                        ) % ("\n".join(output_l), "\n".join(out_l))
             self.fail(message)
         for n in range(len(output_l)):
             # Do a line-by-line comparison
             ol1 = output_l[n].strip()
             ol2 = out_l[n].strip()
             if not re.match(ol1,ol2):
                 mismatch += 1
                 if VERBOSE:
                     print('<<< line %s does not match:' % n)
                     print(repr(ol1))
                     print(repr(ol2))
                     print('>>>')
-        self.assert_(mismatch==0,'Number of mismatched lines: %s' %
+        self.assertTrue(mismatch==0,'Number of mismatched lines: %s' %
                      mismatch)
 
     @decorators.skipif_not_matplotlib
     @decorators.skipif(pylab_not_importable, "Likely a run without X.")
     def test_pylab_import_all_enabled(self):
         "Verify that plot is available when pylab_import_all = True"
         source = """
 from IPython.config.application import Application
 app = Application.instance()
 app.pylab_import_all = True
 pylab
 ip=get_ipython()
 'plot' in ip.user_ns
         """
         output = """
 In \[1\]: from IPython\.config\.application import Application
 In \[2\]: app = Application\.instance\(\)
 In \[3\]: app\.pylab_import_all = True
 In \[4\]: pylab
 ^Welcome to pylab, a matplotlib-based Python environment
 For more information, type 'help\(pylab\)'\.
 In \[5\]: ip=get_ipython\(\)
 In \[6\]: \'plot\' in ip\.user_ns
 Out\[6\]: True
 """
         runner = irunner.IPythonRunner(out=self.out)
         self._test_runner(runner,source,output)
 
     @decorators.skipif_not_matplotlib
     @decorators.skipif(pylab_not_importable, "Likely a run without X.")
     def test_pylab_import_all_disabled(self):
         "Verify that plot is not available when pylab_import_all = False"
         source = """
 from IPython.config.application import Application
 app = Application.instance()
 app.pylab_import_all = False
 pylab
 ip=get_ipython()
 'plot' in ip.user_ns
         """
         output = """
 In \[1\]: from IPython\.config\.application import Application
 In \[2\]: app = Application\.instance\(\)
 In \[3\]: app\.pylab_import_all = False
 In \[4\]: pylab
 ^Welcome to pylab, a matplotlib-based Python environment
 For more information, type 'help\(pylab\)'\.
 In \[5\]: ip=get_ipython\(\)
 In \[6\]: \'plot\' in ip\.user_ns
 Out\[6\]: False
 """
         runner = irunner.IPythonRunner(out=self.out)
         self._test_runner(runner,source,output)

IPython/parallel/tests/test_client.py

@@ -1,455 +1,455 b''
 """Tests for parallel client.py
 
 Authors:
 
 * Min RK
 """
 
 #-------------------------------------------------------------------------------
 #  Copyright (C) 2011  The 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 __future__ import division
 
 import time
 from datetime import datetime
 from tempfile import mktemp
 
 import zmq
 
 from IPython import parallel
 from IPython.parallel.client import client as clientmod
 from IPython.parallel import error
 from IPython.parallel import AsyncResult, AsyncHubResult
 from IPython.parallel import LoadBalancedView, DirectView
 
 from clienttest import ClusterTestCase, segfault, wait, add_engines
 
 def setup():
     add_engines(4, total=True)
 
 class TestClient(ClusterTestCase):
     
     def test_ids(self):
         n = len(self.client.ids)
         self.add_engines(2)
         self.assertEqual(len(self.client.ids), n+2)
     
     def test_view_indexing(self):
         """test index access for views"""
         self.minimum_engines(4)
         targets = self.client._build_targets('all')[-1]
         v = self.client[:]
         self.assertEqual(v.targets, targets)
         t = self.client.ids[2]
         v = self.client[t]
-        self.assert_(isinstance(v, DirectView))
+        self.assertTrue(isinstance(v, DirectView))
         self.assertEqual(v.targets, t)
         t = self.client.ids[2:4]
         v = self.client[t]
-        self.assert_(isinstance(v, DirectView))
+        self.assertTrue(isinstance(v, DirectView))
         self.assertEqual(v.targets, t)
         v = self.client[::2]
-        self.assert_(isinstance(v, DirectView))
+        self.assertTrue(isinstance(v, DirectView))
         self.assertEqual(v.targets, targets[::2])
         v = self.client[1::3]
-        self.assert_(isinstance(v, DirectView))
+        self.assertTrue(isinstance(v, DirectView))
         self.assertEqual(v.targets, targets[1::3])
         v = self.client[:-3]
-        self.assert_(isinstance(v, DirectView))
+        self.assertTrue(isinstance(v, DirectView))
         self.assertEqual(v.targets, targets[:-3])
         v = self.client[-1]
-        self.assert_(isinstance(v, DirectView))
+        self.assertTrue(isinstance(v, DirectView))
         self.assertEqual(v.targets, targets[-1])
         self.assertRaises(TypeError, lambda : self.client[None])
     
     def test_lbview_targets(self):
         """test load_balanced_view targets"""
         v = self.client.load_balanced_view()
         self.assertEqual(v.targets, None)
         v = self.client.load_balanced_view(-1)
         self.assertEqual(v.targets, [self.client.ids[-1]])
         v = self.client.load_balanced_view('all')
         self.assertEqual(v.targets, None)
     
     def test_dview_targets(self):
         """test direct_view targets"""
         v = self.client.direct_view()
         self.assertEqual(v.targets, 'all')
         v = self.client.direct_view('all')
         self.assertEqual(v.targets, 'all')
         v = self.client.direct_view(-1)
         self.assertEqual(v.targets, self.client.ids[-1])
     
     def test_lazy_all_targets(self):
         """test lazy evaluation of rc.direct_view('all')"""
         v = self.client.direct_view()
         self.assertEqual(v.targets, 'all')
         
         def double(x):
             return x*2
         seq = range(100)
         ref = [ double(x) for x in seq ]
         
         # add some engines, which should be used
         self.add_engines(1)
         n1 = len(self.client.ids)
         
         # simple apply
         r = v.apply_sync(lambda : 1)
         self.assertEqual(r, [1] * n1)
         
         # map goes through remotefunction
         r = v.map_sync(double, seq)
         self.assertEqual(r, ref)
 
         # add a couple more engines, and try again
         self.add_engines(2)
         n2 = len(self.client.ids)
         self.assertNotEquals(n2, n1)
         
         # apply
         r = v.apply_sync(lambda : 1)
         self.assertEqual(r, [1] * n2)
         
         # map
         r = v.map_sync(double, seq)
         self.assertEqual(r, ref)
     
     def test_targets(self):
         """test various valid targets arguments"""
         build = self.client._build_targets
         ids = self.client.ids
         idents,targets = build(None)
         self.assertEqual(ids, targets)
     
     def test_clear(self):
         """test clear behavior"""
         self.minimum_engines(2)
         v = self.client[:]
         v.block=True
         v.push(dict(a=5))
         v.pull('a')
         id0 = self.client.ids[-1]
         self.client.clear(targets=id0, block=True)
         a = self.client[:-1].get('a')
         self.assertRaisesRemote(NameError, self.client[id0].get, 'a')
         self.client.clear(block=True)
         for i in self.client.ids:
             self.assertRaisesRemote(NameError, self.client[i].get, 'a')
     
     def test_get_result(self):
         """test getting results from the Hub."""
         c = clientmod.Client(profile='iptest')
         t = c.ids[-1]
         ar = c[t].apply_async(wait, 1)
         # give the monitor time to notice the message
         time.sleep(.25)
         ahr = self.client.get_result(ar.msg_ids)
         self.assertTrue(isinstance(ahr, AsyncHubResult))
         self.assertEqual(ahr.get(), ar.get())
         ar2 = self.client.get_result(ar.msg_ids)
         self.assertFalse(isinstance(ar2, AsyncHubResult))
         c.close()
     
     def test_get_execute_result(self):
         """test getting execute results from the Hub."""
         c = clientmod.Client(profile='iptest')
         t = c.ids[-1]
         cell = '\n'.join([
             'import time',
             'time.sleep(0.25)',
             '5'
         ])
         ar = c[t].execute("import time; time.sleep(1)", silent=False)
         # give the monitor time to notice the message
         time.sleep(.25)
         ahr = self.client.get_result(ar.msg_ids)
         self.assertTrue(isinstance(ahr, AsyncHubResult))
         self.assertEqual(ahr.get().pyout, ar.get().pyout)
         ar2 = self.client.get_result(ar.msg_ids)
         self.assertFalse(isinstance(ar2, AsyncHubResult))
         c.close()
     
     def test_ids_list(self):
         """test client.ids"""
         ids = self.client.ids
         self.assertEqual(ids, self.client._ids)
         self.assertFalse(ids is self.client._ids)
         ids.remove(ids[-1])
         self.assertNotEquals(ids, self.client._ids)
     
     def test_queue_status(self):
         ids = self.client.ids
         id0 = ids[0]
         qs = self.client.queue_status(targets=id0)
         self.assertTrue(isinstance(qs, dict))
         self.assertEqual(sorted(qs.keys()), ['completed', 'queue', 'tasks'])
         allqs = self.client.queue_status()
         self.assertTrue(isinstance(allqs, dict))
         intkeys = list(allqs.keys())
         intkeys.remove('unassigned')
         self.assertEqual(sorted(intkeys), sorted(self.client.ids))
         unassigned = allqs.pop('unassigned')
         for eid,qs in allqs.items():
             self.assertTrue(isinstance(qs, dict))
             self.assertEqual(sorted(qs.keys()), ['completed', 'queue', 'tasks'])
 
     def test_shutdown(self):
         ids = self.client.ids
         id0 = ids[0]
         self.client.shutdown(id0, block=True)
         while id0 in self.client.ids:
             time.sleep(0.1)
             self.client.spin()
         
         self.assertRaises(IndexError, lambda : self.client[id0])
         
     def test_result_status(self):
         pass
         # to be written
     
     def test_db_query_dt(self):
         """test db query by date"""
         hist = self.client.hub_history()
         middle = self.client.db_query({'msg_id' : hist[len(hist)//2]})[0]
         tic = middle['submitted']
         before = self.client.db_query({'submitted' : {'$lt' : tic}})
         after = self.client.db_query({'submitted' : {'$gte' : tic}})
         self.assertEqual(len(before)+len(after),len(hist))
         for b in before:
             self.assertTrue(b['submitted'] < tic)
         for a in after:
             self.assertTrue(a['submitted'] >= tic)
         same = self.client.db_query({'submitted' : tic})
         for s in same:
             self.assertTrue(s['submitted'] == tic)
     
     def test_db_query_keys(self):
         """test extracting subset of record keys"""
         found = self.client.db_query({'msg_id': {'$ne' : ''}},keys=['submitted', 'completed'])
         for rec in found:
             self.assertEqual(set(rec.keys()), set(['msg_id', 'submitted', 'completed']))
     
     def test_db_query_default_keys(self):
         """default db_query excludes buffers"""
         found = self.client.db_query({'msg_id': {'$ne' : ''}})
         for rec in found:
             keys = set(rec.keys())
             self.assertFalse('buffers' in keys, "'buffers' should not be in: %s" % keys)
             self.assertFalse('result_buffers' in keys, "'result_buffers' should not be in: %s" % keys)
     
     def test_db_query_msg_id(self):
         """ensure msg_id is always in db queries"""
         found = self.client.db_query({'msg_id': {'$ne' : ''}},keys=['submitted', 'completed'])
         for rec in found:
             self.assertTrue('msg_id' in rec.keys())
         found = self.client.db_query({'msg_id': {'$ne' : ''}},keys=['submitted'])
         for rec in found:
             self.assertTrue('msg_id' in rec.keys())
         found = self.client.db_query({'msg_id': {'$ne' : ''}},keys=['msg_id'])
         for rec in found:
             self.assertTrue('msg_id' in rec.keys())
     
     def test_db_query_get_result(self):
         """pop in db_query shouldn't pop from result itself"""
         self.client[:].apply_sync(lambda : 1)
         found = self.client.db_query({'msg_id': {'$ne' : ''}})
         rc2 = clientmod.Client(profile='iptest')
         # If this bug is not fixed, this call will hang:
         ar = rc2.get_result(self.client.history[-1])
         ar.wait(2)
         self.assertTrue(ar.ready())
         ar.get()
         rc2.close()
     
     def test_db_query_in(self):
         """test db query with '$in','$nin' operators"""
         hist = self.client.hub_history()
         even = hist[::2]
         odd = hist[1::2]
         recs = self.client.db_query({ 'msg_id' : {'$in' : even}})
         found = [ r['msg_id'] for r in recs ]
         self.assertEqual(set(even), set(found))
         recs = self.client.db_query({ 'msg_id' : {'$nin' : even}})
         found = [ r['msg_id'] for r in recs ]
         self.assertEqual(set(odd), set(found))
     
     def test_hub_history(self):
         hist = self.client.hub_history()
         recs = self.client.db_query({ 'msg_id' : {"$ne":''}})
         recdict = {}
         for rec in recs:
             recdict[rec['msg_id']] = rec
         
         latest = datetime(1984,1,1)
         for msg_id in hist:
             rec = recdict[msg_id]
             newt = rec['submitted']
             self.assertTrue(newt >= latest)
             latest = newt
         ar = self.client[-1].apply_async(lambda : 1)
         ar.get()
         time.sleep(0.25)
         self.assertEqual(self.client.hub_history()[-1:],ar.msg_ids)
     
     def _wait_for_idle(self):
         """wait for an engine to become idle, according to the Hub"""
         rc = self.client
         
         # timeout 5s, polling every 100ms
         qs = rc.queue_status()
         for i in range(50):
             if qs['unassigned'] or any(qs[eid]['tasks'] for eid in rc.ids):
                 time.sleep(0.1)
                 qs = rc.queue_status()
             else:
                 break
         
         # ensure Hub up to date:
         self.assertEqual(qs['unassigned'], 0)
         for eid in rc.ids:
             self.assertEqual(qs[eid]['tasks'], 0)
     
     
     def test_resubmit(self):
         def f():
             import random
             return random.random()
         v = self.client.load_balanced_view()
         ar = v.apply_async(f)
         r1 = ar.get(1)
         # give the Hub a chance to notice:
         self._wait_for_idle()
         ahr = self.client.resubmit(ar.msg_ids)
         r2 = ahr.get(1)
         self.assertFalse(r1 == r2)
 
     def test_resubmit_chain(self):
         """resubmit resubmitted tasks"""
         v = self.client.load_balanced_view()
         ar = v.apply_async(lambda x: x, 'x'*1024)
         ar.get()
         self._wait_for_idle()
         ars = [ar]
         
         for i in range(10):
             ar = ars[-1]
             ar2 = self.client.resubmit(ar.msg_ids)
         
         [ ar.get() for ar in ars ]
 
     def test_resubmit_header(self):
         """resubmit shouldn't clobber the whole header"""
         def f():
             import random
             return random.random()
         v = self.client.load_balanced_view()
         v.retries = 1
         ar = v.apply_async(f)
         r1 = ar.get(1)
         # give the Hub a chance to notice:
         self._wait_for_idle()
         ahr = self.client.resubmit(ar.msg_ids)
         ahr.get(1)
         time.sleep(0.5)
         records = self.client.db_query({'msg_id': {'$in': ar.msg_ids + ahr.msg_ids}}, keys='header')
         h1,h2 = [ r['header'] for r in records ]
         for key in set(h1.keys()).union(set(h2.keys())):
             if key in ('msg_id', 'date'):
                 self.assertNotEquals(h1[key], h2[key])
             else:
                 self.assertEqual(h1[key], h2[key])
 
     def test_resubmit_aborted(self):
         def f():
             import random
             return random.random()
         v = self.client.load_balanced_view()
         # restrict to one engine, so we can put a sleep
         # ahead of the task, so it will get aborted
         eid = self.client.ids[-1]
         v.targets = [eid]
         sleep = v.apply_async(time.sleep, 0.5)
         ar = v.apply_async(f)
         ar.abort()
         self.assertRaises(error.TaskAborted, ar.get)
         # Give the Hub a chance to get up to date:
         self._wait_for_idle()
         ahr = self.client.resubmit(ar.msg_ids)
         r2 = ahr.get(1)
 
     def test_resubmit_inflight(self):
         """resubmit of inflight task"""
         v = self.client.load_balanced_view()
         ar = v.apply_async(time.sleep,1)
         # give the message a chance to arrive
         time.sleep(0.2)
         ahr = self.client.resubmit(ar.msg_ids)
         ar.get(2)
         ahr.get(2)
 
     def test_resubmit_badkey(self):
         """ensure KeyError on resubmit of nonexistant task"""
         self.assertRaisesRemote(KeyError, self.client.resubmit, ['invalid'])
 
     def test_purge_results(self):
         # ensure there are some tasks
         for i in range(5):
             self.client[:].apply_sync(lambda : 1)
         # Wait for the Hub to realise the result is done:
         # This prevents a race condition, where we
         # might purge a result the Hub still thinks is pending.
         time.sleep(0.1)
         rc2 = clientmod.Client(profile='iptest')
         hist = self.client.hub_history()
         ahr = rc2.get_result([hist[-1]])
         ahr.wait(10)
         self.client.purge_results(hist[-1])
         newhist = self.client.hub_history()
         self.assertEqual(len(newhist)+1,len(hist))
         rc2.spin()
         rc2.close()
         
     def test_purge_all_results(self):
         self.client.purge_results('all')
         hist = self.client.hub_history()
         self.assertEqual(len(hist), 0)
     
     def test_spin_thread(self):
         self.client.spin_thread(0.01)
         ar = self.client[-1].apply_async(lambda : 1)
         time.sleep(0.1)
         self.assertTrue(ar.wall_time < 0.1,
             "spin should have kept wall_time < 0.1, but got %f" % ar.wall_time
         )
     
     def test_stop_spin_thread(self):
         self.client.spin_thread(0.01)
         self.client.stop_spin_thread()
         ar = self.client[-1].apply_async(lambda : 1)
         time.sleep(0.15)
         self.assertTrue(ar.wall_time > 0.1,
             "Shouldn't be spinning, but got wall_time=%f" % ar.wall_time
         )
     
     def test_activate(self):
         ip = get_ipython()
         magics = ip.magics_manager.magics
         self.assertTrue('px' in magics['line'])
         self.assertTrue('px' in magics['cell'])
         v0 = self.client.activate(-1, '0')
         self.assertTrue('px0' in magics['line'])
         self.assertTrue('px0' in magics['cell'])
         self.assertEqual(v0.targets, self.client.ids[-1])
         v0 = self.client.activate('all', 'all')
         self.assertTrue('pxall' in magics['line'])
         self.assertTrue('pxall' in magics['cell'])
         self.assertEqual(v0.targets, 'all')

IPython/utils/tests/test_notification.py

@@ -1,150 +1,150 b''
 # encoding: utf-8
 
 """This file contains unittests for the notification.py module."""
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-2011  The 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 unittest
 
 from IPython.utils.notification import shared_center
 
 #-----------------------------------------------------------------------------
 # Support Classes
 #-----------------------------------------------------------------------------
 
 
 class Observer(object):
 
     def __init__(self, expected_ntype, expected_sender,
                     center=shared_center, *args, **kwargs):
         super(Observer, self).__init__()
         self.expected_ntype = expected_ntype
         self.expected_sender = expected_sender
         self.expected_args = args
         self.expected_kwargs = kwargs
         self.recieved = False
         center.add_observer(self.callback,
                             self.expected_ntype,
                             self.expected_sender)
 
     def callback(self, ntype, sender, *args, **kwargs):
         assert(ntype == self.expected_ntype or
                 self.expected_ntype == None)
         assert(sender == self.expected_sender or
                 self.expected_sender == None)
         assert(args == self.expected_args)
         assert(kwargs == self.expected_kwargs)
         self.recieved = True
 
     def verify(self):
         assert(self.recieved)
 
     def reset(self):
         self.recieved = False
 
 
 class Notifier(object):
 
     def __init__(self, ntype, **kwargs):
         super(Notifier, self).__init__()
         self.ntype = ntype
         self.kwargs = kwargs
 
     def post(self, center=shared_center):
 
         center.post_notification(self.ntype, self,
             **self.kwargs)
 
 
 #-----------------------------------------------------------------------------
 # Tests
 #-----------------------------------------------------------------------------
 
 
 class NotificationTests(unittest.TestCase):
 
     def tearDown(self):
         shared_center.remove_all_observers()
 
     def test_notification_delivered(self):
         """Test that notifications are delivered"""
 
         expected_ntype = 'EXPECTED_TYPE'
         sender = Notifier(expected_ntype)
         observer = Observer(expected_ntype, sender)
 
         sender.post()
         observer.verify()
 
     def test_type_specificity(self):
         """Test that observers are registered by type"""
 
         expected_ntype = 1
         unexpected_ntype = "UNEXPECTED_TYPE"
         sender = Notifier(expected_ntype)
         unexpected_sender = Notifier(unexpected_ntype)
         observer = Observer(expected_ntype, sender)
 
         sender.post()
         unexpected_sender.post()
         observer.verify()
 
     def test_sender_specificity(self):
         """Test that observers are registered by sender"""
 
         expected_ntype = "EXPECTED_TYPE"
         sender1 = Notifier(expected_ntype)
         sender2 = Notifier(expected_ntype)
         observer = Observer(expected_ntype, sender1)
 
         sender1.post()
         sender2.post()
 
         observer.verify()
 
     def test_remove_all_observers(self):
         """White-box test for remove_all_observers"""
 
         for i in xrange(10):
             Observer('TYPE', None, center=shared_center)
 
-        self.assert_(len(shared_center.observers[('TYPE',None)]) >= 10,
+        self.assertTrue(len(shared_center.observers[('TYPE',None)]) >= 10,
             "observers registered")
 
         shared_center.remove_all_observers()
-        self.assert_(len(shared_center.observers) == 0, "observers removed")
+        self.assertTrue(len(shared_center.observers) == 0, "observers removed")
 
     def test_any_sender(self):
         expected_ntype = "EXPECTED_TYPE"
         sender1 = Notifier(expected_ntype)
         sender2 = Notifier(expected_ntype)
         observer = Observer(expected_ntype, None)
 
         sender1.post()
         observer.verify()
 
         observer.reset()
         sender2.post()
         observer.verify()
 
     def test_post_performance(self):
         """Test that post_notification, even with many registered irrelevant
         observers is fast"""
 
         for i in xrange(10):
             Observer("UNRELATED_TYPE", None)
 
         o = Observer('EXPECTED_TYPE', None)
         shared_center.post_notification('EXPECTED_TYPE', self)
         o.verify()
 
 

IPython/utils/tests/test_traitlets.py

@@ -1,908 +1,908 b''
 # encoding: utf-8
 """
 Tests for IPython.utils.traitlets.
 
 Authors:
 
 * Brian Granger
 * Enthought, Inc.  Some of the code in this file comes from enthought.traits
   and is licensed under the BSD license.  Also, many of the ideas also come
   from enthought.traits even though our implementation is very different.
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-2011  The 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 re
 import sys
 from unittest import TestCase
 
 from nose import SkipTest
 
 from IPython.utils.traitlets import (
     HasTraits, MetaHasTraits, TraitType, Any, CBytes,
     Int, Long, Integer, Float, Complex, Bytes, Unicode, TraitError,
     Undefined, Type, This, Instance, TCPAddress, List, Tuple,
     ObjectName, DottedObjectName, CRegExp
 )
 from IPython.utils import py3compat
 from IPython.testing.decorators import skipif
 
 #-----------------------------------------------------------------------------
 # Helper classes for testing
 #-----------------------------------------------------------------------------
 
 
 class HasTraitsStub(HasTraits):
 
     def _notify_trait(self, name, old, new):
         self._notify_name = name
         self._notify_old = old
         self._notify_new = new
 
 
 #-----------------------------------------------------------------------------
 # Test classes
 #-----------------------------------------------------------------------------
 
 
 class TestTraitType(TestCase):
 
     def test_get_undefined(self):
         class A(HasTraits):
             a = TraitType
         a = A()
         self.assertEqual(a.a, Undefined)
 
     def test_set(self):
         class A(HasTraitsStub):
             a = TraitType
 
         a = A()
         a.a = 10
         self.assertEqual(a.a, 10)
         self.assertEqual(a._notify_name, 'a')
         self.assertEqual(a._notify_old, Undefined)
         self.assertEqual(a._notify_new, 10)
 
     def test_validate(self):
         class MyTT(TraitType):
             def validate(self, inst, value):
                 return -1
         class A(HasTraitsStub):
             tt = MyTT
 
         a = A()
         a.tt = 10
         self.assertEqual(a.tt, -1)
 
     def test_default_validate(self):
         class MyIntTT(TraitType):
             def validate(self, obj, value):
                 if isinstance(value, int):
                     return value
                 self.error(obj, value)
         class A(HasTraits):
             tt = MyIntTT(10)
         a = A()
         self.assertEqual(a.tt, 10)
 
         # Defaults are validated when the HasTraits is instantiated
         class B(HasTraits):
             tt = MyIntTT('bad default')
         self.assertRaises(TraitError, B)
 
     def test_is_valid_for(self):
         class MyTT(TraitType):
             def is_valid_for(self, value):
                 return True
         class A(HasTraits):
             tt = MyTT
 
         a = A()
         a.tt = 10
         self.assertEqual(a.tt, 10)
 
     def test_value_for(self):
         class MyTT(TraitType):
             def value_for(self, value):
                 return 20
         class A(HasTraits):
             tt = MyTT
 
         a = A()
         a.tt = 10
         self.assertEqual(a.tt, 20)
 
     def test_info(self):
         class A(HasTraits):
             tt = TraitType
         a = A()
         self.assertEqual(A.tt.info(), 'any value')
 
     def test_error(self):
         class A(HasTraits):
             tt = TraitType
         a = A()
         self.assertRaises(TraitError, A.tt.error, a, 10)
 
     def test_dynamic_initializer(self):
         class A(HasTraits):
             x = Int(10)
             def _x_default(self):
                 return 11
         class B(A):
             x = Int(20)
         class C(A):
             def _x_default(self):
                 return 21
 
         a = A()
         self.assertEqual(a._trait_values, {})
         self.assertEqual(a._trait_dyn_inits.keys(), ['x'])
         self.assertEqual(a.x, 11)
         self.assertEqual(a._trait_values, {'x': 11})
         b = B()
         self.assertEqual(b._trait_values, {'x': 20})
         self.assertEqual(a._trait_dyn_inits.keys(), ['x'])
         self.assertEqual(b.x, 20)
         c = C()
         self.assertEqual(c._trait_values, {})
         self.assertEqual(a._trait_dyn_inits.keys(), ['x'])
         self.assertEqual(c.x, 21)
         self.assertEqual(c._trait_values, {'x': 21})
         # Ensure that the base class remains unmolested when the _default
         # initializer gets overridden in a subclass.
         a = A()
         c = C()
         self.assertEqual(a._trait_values, {})
         self.assertEqual(a._trait_dyn_inits.keys(), ['x'])
         self.assertEqual(a.x, 11)
         self.assertEqual(a._trait_values, {'x': 11})
 
 
 
 class TestHasTraitsMeta(TestCase):
 
     def test_metaclass(self):
         self.assertEqual(type(HasTraits), MetaHasTraits)
 
         class A(HasTraits):
             a = Int
 
         a = A()
         self.assertEqual(type(a.__class__), MetaHasTraits)
         self.assertEqual(a.a,0)
         a.a = 10
         self.assertEqual(a.a,10)
 
         class B(HasTraits):
             b = Int()
 
         b = B()
         self.assertEqual(b.b,0)
         b.b = 10
         self.assertEqual(b.b,10)
 
         class C(HasTraits):
             c = Int(30)
 
         c = C()
         self.assertEqual(c.c,30)
         c.c = 10
         self.assertEqual(c.c,10)
 
     def test_this_class(self):
         class A(HasTraits):
             t = This()
             tt = This()
         class B(A):
             tt = This()
             ttt = This()
         self.assertEqual(A.t.this_class, A)
         self.assertEqual(B.t.this_class, A)
         self.assertEqual(B.tt.this_class, B)
         self.assertEqual(B.ttt.this_class, B)
 
 class TestHasTraitsNotify(TestCase):
 
     def setUp(self):
         self._notify1 = []
         self._notify2 = []
 
     def notify1(self, name, old, new):
         self._notify1.append((name, old, new))
 
     def notify2(self, name, old, new):
         self._notify2.append((name, old, new))
 
     def test_notify_all(self):
 
         class A(HasTraits):
             a = Int
             b = Float
 
         a = A()
         a.on_trait_change(self.notify1)
         a.a = 0
         self.assertEqual(len(self._notify1),0)
         a.b = 0.0
         self.assertEqual(len(self._notify1),0)
         a.a = 10
-        self.assert_(('a',0,10) in self._notify1)
+        self.assertTrue(('a',0,10) in self._notify1)
         a.b = 10.0
-        self.assert_(('b',0.0,10.0) in self._notify1)
+        self.assertTrue(('b',0.0,10.0) in self._notify1)
         self.assertRaises(TraitError,setattr,a,'a','bad string')
         self.assertRaises(TraitError,setattr,a,'b','bad string')
         self._notify1 = []
         a.on_trait_change(self.notify1,remove=True)
         a.a = 20
         a.b = 20.0
         self.assertEqual(len(self._notify1),0)
 
     def test_notify_one(self):
 
         class A(HasTraits):
             a = Int
             b = Float
 
         a = A()
         a.on_trait_change(self.notify1, 'a')
         a.a = 0
         self.assertEqual(len(self._notify1),0)
         a.a = 10
-        self.assert_(('a',0,10) in self._notify1)
+        self.assertTrue(('a',0,10) in self._notify1)
         self.assertRaises(TraitError,setattr,a,'a','bad string')
 
     def test_subclass(self):
 
         class A(HasTraits):
             a = Int
 
         class B(A):
             b = Float
 
         b = B()
         self.assertEqual(b.a,0)
         self.assertEqual(b.b,0.0)
         b.a = 100
         b.b = 100.0
         self.assertEqual(b.a,100)
         self.assertEqual(b.b,100.0)
 
     def test_notify_subclass(self):
 
         class A(HasTraits):
             a = Int
 
         class B(A):
             b = Float
 
         b = B()
         b.on_trait_change(self.notify1, 'a')
         b.on_trait_change(self.notify2, 'b')
         b.a = 0
         b.b = 0.0
         self.assertEqual(len(self._notify1),0)
         self.assertEqual(len(self._notify2),0)
         b.a = 10
         b.b = 10.0
-        self.assert_(('a',0,10) in self._notify1)
-        self.assert_(('b',0.0,10.0) in self._notify2)
+        self.assertTrue(('a',0,10) in self._notify1)
+        self.assertTrue(('b',0.0,10.0) in self._notify2)
 
     def test_static_notify(self):
 
         class A(HasTraits):
             a = Int
             _notify1 = []
             def _a_changed(self, name, old, new):
                 self._notify1.append((name, old, new))
 
         a = A()
         a.a = 0
         # This is broken!!!
         self.assertEqual(len(a._notify1),0)
         a.a = 10
-        self.assert_(('a',0,10) in a._notify1)
+        self.assertTrue(('a',0,10) in a._notify1)
 
         class B(A):
             b = Float
             _notify2 = []
             def _b_changed(self, name, old, new):
                 self._notify2.append((name, old, new))
 
         b = B()
         b.a = 10
         b.b = 10.0
-        self.assert_(('a',0,10) in b._notify1)
-        self.assert_(('b',0.0,10.0) in b._notify2)
+        self.assertTrue(('a',0,10) in b._notify1)
+        self.assertTrue(('b',0.0,10.0) in b._notify2)
 
     def test_notify_args(self):
 
         def callback0():
             self.cb = ()
         def callback1(name):
             self.cb = (name,)
         def callback2(name, new):
             self.cb = (name, new)
         def callback3(name, old, new):
             self.cb = (name, old, new)
 
         class A(HasTraits):
             a = Int
 
         a = A()
         a.on_trait_change(callback0, 'a')
         a.a = 10
         self.assertEqual(self.cb,())
         a.on_trait_change(callback0, 'a', remove=True)
 
         a.on_trait_change(callback1, 'a')
         a.a = 100
         self.assertEqual(self.cb,('a',))
         a.on_trait_change(callback1, 'a', remove=True)
 
         a.on_trait_change(callback2, 'a')
         a.a = 1000
         self.assertEqual(self.cb,('a',1000))
         a.on_trait_change(callback2, 'a', remove=True)
 
         a.on_trait_change(callback3, 'a')
         a.a = 10000
         self.assertEqual(self.cb,('a',1000,10000))
         a.on_trait_change(callback3, 'a', remove=True)
 
         self.assertEqual(len(a._trait_notifiers['a']),0)
 
 
 class TestHasTraits(TestCase):
 
     def test_trait_names(self):
         class A(HasTraits):
             i = Int
             f = Float
         a = A()
         self.assertEqual(sorted(a.trait_names()),['f','i'])
         self.assertEqual(sorted(A.class_trait_names()),['f','i'])
 
     def test_trait_metadata(self):
         class A(HasTraits):
             i = Int(config_key='MY_VALUE')
         a = A()
         self.assertEqual(a.trait_metadata('i','config_key'), 'MY_VALUE')
 
     def test_traits(self):
         class A(HasTraits):
             i = Int
             f = Float
         a = A()
         self.assertEqual(a.traits(), dict(i=A.i, f=A.f))
         self.assertEqual(A.class_traits(), dict(i=A.i, f=A.f))
 
     def test_traits_metadata(self):
         class A(HasTraits):
             i = Int(config_key='VALUE1', other_thing='VALUE2')
             f = Float(config_key='VALUE3', other_thing='VALUE2')
             j = Int(0)
         a = A()
         self.assertEqual(a.traits(), dict(i=A.i, f=A.f, j=A.j))
         traits = a.traits(config_key='VALUE1', other_thing='VALUE2')
         self.assertEqual(traits, dict(i=A.i))
 
         # This passes, but it shouldn't because I am replicating a bug in
         # traits.
         traits = a.traits(config_key=lambda v: True)
         self.assertEqual(traits, dict(i=A.i, f=A.f, j=A.j))
 
     def test_init(self):
         class A(HasTraits):
             i = Int()
             x = Float()
         a = A(i=1, x=10.0)
         self.assertEqual(a.i, 1)
         self.assertEqual(a.x, 10.0)
 
 #-----------------------------------------------------------------------------
 # Tests for specific trait types
 #-----------------------------------------------------------------------------
 
 
 class TestType(TestCase):
 
     def test_default(self):
 
         class B(object): pass
         class A(HasTraits):
             klass = Type
 
         a = A()
         self.assertEqual(a.klass, None)
 
         a.klass = B
         self.assertEqual(a.klass, B)
         self.assertRaises(TraitError, setattr, a, 'klass', 10)
 
     def test_value(self):
 
         class B(object): pass
         class C(object): pass
         class A(HasTraits):
             klass = Type(B)
 
         a = A()
         self.assertEqual(a.klass, B)
         self.assertRaises(TraitError, setattr, a, 'klass', C)
         self.assertRaises(TraitError, setattr, a, 'klass', object)
         a.klass = B
 
     def test_allow_none(self):
 
         class B(object): pass
         class C(B): pass
         class A(HasTraits):
             klass = Type(B, allow_none=False)
 
         a = A()
         self.assertEqual(a.klass, B)
         self.assertRaises(TraitError, setattr, a, 'klass', None)
         a.klass = C
         self.assertEqual(a.klass, C)
 
     def test_validate_klass(self):
 
         class A(HasTraits):
             klass = Type('no strings allowed')
 
         self.assertRaises(ImportError, A)
 
         class A(HasTraits):
             klass = Type('rub.adub.Duck')
 
         self.assertRaises(ImportError, A)
 
     def test_validate_default(self):
 
         class B(object): pass
         class A(HasTraits):
             klass = Type('bad default', B)
 
         self.assertRaises(ImportError, A)
 
         class C(HasTraits):
             klass = Type(None, B, allow_none=False)
 
         self.assertRaises(TraitError, C)
 
     def test_str_klass(self):
 
         class A(HasTraits):
             klass = Type('IPython.utils.ipstruct.Struct')
 
         from IPython.utils.ipstruct import Struct
         a = A()
         a.klass = Struct
         self.assertEqual(a.klass, Struct)
 
         self.assertRaises(TraitError, setattr, a, 'klass', 10)
 
 class TestInstance(TestCase):
 
     def test_basic(self):
         class Foo(object): pass
         class Bar(Foo): pass
         class Bah(object): pass
 
         class A(HasTraits):
             inst = Instance(Foo)
 
         a = A()
-        self.assert_(a.inst is None)
+        self.assertTrue(a.inst is None)
         a.inst = Foo()
-        self.assert_(isinstance(a.inst, Foo))
+        self.assertTrue(isinstance(a.inst, Foo))
         a.inst = Bar()
-        self.assert_(isinstance(a.inst, Foo))
+        self.assertTrue(isinstance(a.inst, Foo))
         self.assertRaises(TraitError, setattr, a, 'inst', Foo)
         self.assertRaises(TraitError, setattr, a, 'inst', Bar)
         self.assertRaises(TraitError, setattr, a, 'inst', Bah())
 
     def test_unique_default_value(self):
         class Foo(object): pass
         class A(HasTraits):
             inst = Instance(Foo,(),{})
 
         a = A()
         b = A()
-        self.assert_(a.inst is not b.inst)
+        self.assertTrue(a.inst is not b.inst)
 
     def test_args_kw(self):
         class Foo(object):
             def __init__(self, c): self.c = c
         class Bar(object): pass
         class Bah(object):
             def __init__(self, c, d):
                 self.c = c; self.d = d
 
         class A(HasTraits):
             inst = Instance(Foo, (10,))
         a = A()
         self.assertEqual(a.inst.c, 10)
 
         class B(HasTraits):
             inst = Instance(Bah, args=(10,), kw=dict(d=20))
         b = B()
         self.assertEqual(b.inst.c, 10)
         self.assertEqual(b.inst.d, 20)
 
         class C(HasTraits):
             inst = Instance(Foo)
         c = C()
-        self.assert_(c.inst is None)
+        self.assertTrue(c.inst is None)
 
     def test_bad_default(self):
         class Foo(object): pass
 
         class A(HasTraits):
             inst = Instance(Foo, allow_none=False)
 
         self.assertRaises(TraitError, A)
 
     def test_instance(self):
         class Foo(object): pass
 
         def inner():
             class A(HasTraits):
                 inst = Instance(Foo())
 
         self.assertRaises(TraitError, inner)
 
 
 class TestThis(TestCase):
 
     def test_this_class(self):
         class Foo(HasTraits):
             this = This
 
         f = Foo()
         self.assertEqual(f.this, None)
         g = Foo()
         f.this = g
         self.assertEqual(f.this, g)
         self.assertRaises(TraitError, setattr, f, 'this', 10)
 
     def test_this_inst(self):
         class Foo(HasTraits):
             this = This()
 
         f = Foo()
         f.this = Foo()
-        self.assert_(isinstance(f.this, Foo))
+        self.assertTrue(isinstance(f.this, Foo))
 
     def test_subclass(self):
         class Foo(HasTraits):
             t = This()
         class Bar(Foo):
             pass
         f = Foo()
         b = Bar()
         f.t = b
         b.t = f
         self.assertEqual(f.t, b)
         self.assertEqual(b.t, f)
 
     def test_subclass_override(self):
         class Foo(HasTraits):
             t = This()
         class Bar(Foo):
             t = This()
         f = Foo()
         b = Bar()
         f.t = b
         self.assertEqual(f.t, b)
         self.assertRaises(TraitError, setattr, b, 't', f)
 
 class TraitTestBase(TestCase):
     """A best testing class for basic trait types."""
 
     def assign(self, value):
         self.obj.value = value
 
     def coerce(self, value):
         return value
 
     def test_good_values(self):
         if hasattr(self, '_good_values'):
             for value in self._good_values:
                 self.assign(value)
                 self.assertEqual(self.obj.value, self.coerce(value))
 
     def test_bad_values(self):
         if hasattr(self, '_bad_values'):
             for value in self._bad_values:
                 try:
                     self.assertRaises(TraitError, self.assign, value)
                 except AssertionError:
                     assert False, value
 
     def test_default_value(self):
         if hasattr(self, '_default_value'):
             self.assertEqual(self._default_value, self.obj.value)
 
     def tearDown(self):
         # restore default value after tests, if set
         if hasattr(self, '_default_value'):
             self.obj.value = self._default_value
 
 
 class AnyTrait(HasTraits):
 
     value = Any
 
 class AnyTraitTest(TraitTestBase):
 
     obj = AnyTrait()
 
     _default_value = None
     _good_values   = [10.0, 'ten', u'ten', [10], {'ten': 10},(10,), None, 1j]
     _bad_values    = []
 
 
 class IntTrait(HasTraits):
 
     value = Int(99)
 
 class TestInt(TraitTestBase):
 
     obj = IntTrait()
     _default_value = 99
     _good_values   = [10, -10]
     _bad_values    = ['ten', u'ten', [10], {'ten': 10},(10,), None, 1j,
                       10.1, -10.1, '10L', '-10L', '10.1', '-10.1', u'10L',
                       u'-10L', u'10.1', u'-10.1',  '10', '-10', u'10', u'-10']
     if not py3compat.PY3:
         _bad_values.extend([10L, -10L, 10*sys.maxint, -10*sys.maxint])
 
 
 class LongTrait(HasTraits):
 
     value = Long(99L)
 
 class TestLong(TraitTestBase):
 
     obj = LongTrait()
 
     _default_value = 99L
     _good_values   = [10, -10, 10L, -10L]
     _bad_values    = ['ten', u'ten', [10], [10l], {'ten': 10},(10,),(10L,),
                       None, 1j, 10.1, -10.1, '10', '-10', '10L', '-10L', '10.1',
                       '-10.1', u'10', u'-10', u'10L', u'-10L', u'10.1',
                       u'-10.1']
     if not py3compat.PY3:
         # maxint undefined on py3, because int == long
         _good_values.extend([10*sys.maxint, -10*sys.maxint])
 
     @skipif(py3compat.PY3, "not relevant on py3")
     def test_cast_small(self):
         """Long casts ints to long"""
         self.obj.value = 10
         self.assertEqual(type(self.obj.value), long)
 
 
 class IntegerTrait(HasTraits):
     value = Integer(1)
 
 class TestInteger(TestLong):
     obj = IntegerTrait()
     _default_value = 1
 
     def coerce(self, n):
         return int(n)
 
     @skipif(py3compat.PY3, "not relevant on py3")
     def test_cast_small(self):
         """Integer casts small longs to int"""
         if py3compat.PY3:
             raise SkipTest("not relevant on py3")
 
         self.obj.value = 100L
         self.assertEqual(type(self.obj.value), int)
 
 
 class FloatTrait(HasTraits):
 
     value = Float(99.0)
 
 class TestFloat(TraitTestBase):
 
     obj = FloatTrait()
 
     _default_value = 99.0
     _good_values   = [10, -10, 10.1, -10.1]
     _bad_values    = ['ten', u'ten', [10], {'ten': 10},(10,), None,
                       1j, '10', '-10', '10L', '-10L', '10.1', '-10.1', u'10',
                       u'-10', u'10L', u'-10L', u'10.1', u'-10.1']
     if not py3compat.PY3:
         _bad_values.extend([10L, -10L])
 
 
 class ComplexTrait(HasTraits):
 
     value = Complex(99.0-99.0j)
 
 class TestComplex(TraitTestBase):
 
     obj = ComplexTrait()
 
     _default_value = 99.0-99.0j
     _good_values   = [10, -10, 10.1, -10.1, 10j, 10+10j, 10-10j,
                       10.1j, 10.1+10.1j, 10.1-10.1j]
     _bad_values    = [u'10L', u'-10L', 'ten', [10], {'ten': 10},(10,), None]
     if not py3compat.PY3:
         _bad_values.extend([10L, -10L])
 
 
 class BytesTrait(HasTraits):
 
     value = Bytes(b'string')
 
 class TestBytes(TraitTestBase):
 
     obj = BytesTrait()
 
     _default_value = b'string'
     _good_values   = [b'10', b'-10', b'10L',
                       b'-10L', b'10.1', b'-10.1', b'string']
     _bad_values    = [10, -10, 10L, -10L, 10.1, -10.1, 1j, [10],
                       ['ten'],{'ten': 10},(10,), None,  u'string']
 
 
 class UnicodeTrait(HasTraits):
 
     value = Unicode(u'unicode')
 
 class TestUnicode(TraitTestBase):
 
     obj = UnicodeTrait()
 
     _default_value = u'unicode'
     _good_values   = ['10', '-10', '10L', '-10L', '10.1',
                       '-10.1', '', u'', 'string', u'string', u"€"]
     _bad_values    = [10, -10, 10L, -10L, 10.1, -10.1, 1j,
                       [10], ['ten'], [u'ten'], {'ten': 10},(10,), None]
 
 
 class ObjectNameTrait(HasTraits):
     value = ObjectName("abc")
 
 class TestObjectName(TraitTestBase):
     obj = ObjectNameTrait()
 
     _default_value = "abc"
     _good_values = ["a", "gh", "g9", "g_", "_G", u"a345_"]
     _bad_values = [1, "", u"€", "9g", "!", "#abc", "aj@", "a.b", "a()", "a[0]",
                                                             object(), object]
     if sys.version_info[0] < 3:
         _bad_values.append(u"þ")
     else:
         _good_values.append(u"þ")  # þ=1 is valid in Python 3 (PEP 3131).
 
 
 class DottedObjectNameTrait(HasTraits):
     value = DottedObjectName("a.b")
 
 class TestDottedObjectName(TraitTestBase):
     obj = DottedObjectNameTrait()
 
     _default_value = "a.b"
     _good_values = ["A", "y.t", "y765.__repr__", "os.path.join", u"os.path.join"]
     _bad_values = [1, u"abc.€", "_.@", ".", ".abc", "abc.", ".abc."]
     if sys.version_info[0] < 3:
         _bad_values.append(u"t.þ")
     else:
         _good_values.append(u"t.þ")
 
 
 class TCPAddressTrait(HasTraits):
 
     value = TCPAddress()
 
 class TestTCPAddress(TraitTestBase):
 
     obj = TCPAddressTrait()
 
     _default_value = ('127.0.0.1',0)
     _good_values = [('localhost',0),('192.168.0.1',1000),('www.google.com',80)]
     _bad_values = [(0,0),('localhost',10.0),('localhost',-1)]
 
 class ListTrait(HasTraits):
 
     value = List(Int)
 
 class TestList(TraitTestBase):
 
     obj = ListTrait()
 
     _default_value = []
     _good_values = [[], [1], range(10)]
     _bad_values = [10, [1,'a'], 'a', (1,2)]
 
 class LenListTrait(HasTraits):
 
     value = List(Int, [0], minlen=1, maxlen=2)
 
 class TestLenList(TraitTestBase):
 
     obj = LenListTrait()
 
     _default_value = [0]
     _good_values = [[1], range(2)]
     _bad_values = [10, [1,'a'], 'a', (1,2), [], range(3)]
 
 class TupleTrait(HasTraits):
 
     value = Tuple(Int)
 
 class TestTupleTrait(TraitTestBase):
 
     obj = TupleTrait()
 
     _default_value = None
     _good_values = [(1,), None,(0,)]
     _bad_values = [10, (1,2), [1],('a'), ()]
 
     def test_invalid_args(self):
         self.assertRaises(TypeError, Tuple, 5)
         self.assertRaises(TypeError, Tuple, default_value='hello')
         t = Tuple(Int, CBytes, default_value=(1,5))
 
 class LooseTupleTrait(HasTraits):
 
     value = Tuple((1,2,3))
 
 class TestLooseTupleTrait(TraitTestBase):
 
     obj = LooseTupleTrait()
 
     _default_value = (1,2,3)
     _good_values = [(1,), None, (0,), tuple(range(5)), tuple('hello'), ('a',5), ()]
     _bad_values = [10, 'hello', [1], []]
 
     def test_invalid_args(self):
         self.assertRaises(TypeError, Tuple, 5)
         self.assertRaises(TypeError, Tuple, default_value='hello')
         t = Tuple(Int, CBytes, default_value=(1,5))
 
 
 class MultiTupleTrait(HasTraits):
 
     value = Tuple(Int, Bytes, default_value=[99,b'bottles'])
 
 class TestMultiTuple(TraitTestBase):
 
     obj = MultiTupleTrait()
 
     _default_value = (99,b'bottles')
     _good_values = [(1,b'a'), (2,b'b')]
     _bad_values = ((),10, b'a', (1,b'a',3), (b'a',1), (1, u'a'))
 
 class CRegExpTrait(HasTraits):
 
     value = CRegExp(r'')
 
 class TestCRegExp(TraitTestBase):
 
     def coerce(self, value):
         return re.compile(value)
 
     obj = CRegExpTrait()
 
     _default_value = re.compile(r'')
     _good_values = [r'\d+', re.compile(r'\d+')]
     _bad_values = [r'(', None, ()]