Various fixes to tests in IPython.utils.

IPython/utils/frame.py

@@ -1,85 +1,87 b''
 # encoding: utf-8
 """
 Utilities for working with stack frames.
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-2009  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 sys
+from IPython.utils import py3compat
 
 #-----------------------------------------------------------------------------
 # Code
 #-----------------------------------------------------------------------------
 
[e-mail]_refactor_print
 def extract_vars(*names,**kw):
     """Extract a set of variables by name from another frame.
 
     :Parameters:
       - `*names`: strings
         One or more variable names which will be extracted from the caller's
     frame.
 
     :Keywords:
       - `depth`: integer (0)
         How many frames in the stack to walk when looking for your variables.
 
 
     Examples:
 
         In [2]: def func(x):
            ...:     y = 1
            ...:     print extract_vars('x','y')
            ...:
 
         In [3]: func('hello')
         {'y': 1, 'x': 'hello'}
     """
 
     depth = kw.get('depth',0)
     
     callerNS = sys._getframe(depth+1).f_locals
     return dict((k,callerNS[k]) for k in names)
 
 
 def extract_vars_above(*names):
     """Extract a set of variables by name from another frame.
 
     Similar to extractVars(), but with a specified depth of 1, so that names
     are exctracted exactly from above the caller.
 
     This is simply a convenience function so that the very common case (for us)
     of skipping exactly 1 frame doesn't have to construct a special dict for
     keyword passing."""
 
     callerNS = sys._getframe(2).f_locals
     return dict((k,callerNS[k]) for k in names)
 
 
 def debugx(expr,pre_msg=''):
     """Print the value of an expression from the caller's frame.
 
     Takes an expression, evaluates it in the caller's frame and prints both
     the given expression and the resulting value (as well as a debug mark
     indicating the name of the calling function.  The input must be of a form
     suitable for eval().
 
     An optional message can be passed, which will be prepended to the printed
     expr->value pair."""
 
     cf = sys._getframe(1)
     print '[DBG:%s] %s%s -> %r' % (cf.f_code.co_name,pre_msg,expr,
                                    eval(expr,cf.f_globals,cf.f_locals))
 
 
 # deactivate it by uncommenting the following line, which makes it a no-op
 #def debugx(expr,pre_msg=''): pass
 

IPython/utils/ipstruct.py

@@ -1,395 +1,395 b''
 # encoding: utf-8
 """A dict subclass that supports attribute style access.
 
 Authors:
 
 * Fernando Perez (original)
 * Brian Granger (refactoring to a dict subclass)
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-2009  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 IPython.utils.data import list2dict2
 
 __all__ = ['Struct']
 
 #-----------------------------------------------------------------------------
 # Code
 #-----------------------------------------------------------------------------
 
 
 class Struct(dict):
     """A dict subclass with attribute style access.
 
     This dict subclass has a a few extra features:
 
     * Attribute style access.
     * Protection of class members (like keys, items) when using attribute
       style access.
     * The ability to restrict assignment to only existing keys.
     * Intelligent merging.
     * Overloaded operators.
     """
     _allownew = True
     def __init__(self, *args, **kw):
         """Initialize with a dictionary, another Struct, or data.
 
         Parameters
         ----------
         args : dict, Struct
             Initialize with one dict or Struct
         kw : dict
             Initialize with key, value pairs.
 
         Examples
         --------
 
         >>> s = Struct(a=10,b=30)
         >>> s.a
         10
         >>> s.b
         30
         >>> s2 = Struct(s,c=30)
         >>> s2.keys()
         ['a', 'c', 'b']
         """
         object.__setattr__(self, '_allownew', True)
         dict.__init__(self, *args, **kw)
 
     def __setitem__(self, key, value):
         """Set an item with check for allownew.
 
         Examples
         --------
 
         >>> s = Struct()
         >>> s['a'] = 10
         >>> s.allow_new_attr(False)
         >>> s['a'] = 10
         >>> s['a']
         10
         >>> try:
         ...     s['b'] = 20
         ... except KeyError:
         ...     print 'this is not allowed'
         ...
         this is not allowed
         """
         if not self._allownew and not self.has_key(key):
             raise KeyError(
                 "can't create new attribute %s when allow_new_attr(False)" % key)
         dict.__setitem__(self, key, value)
 
     def __setattr__(self, key, value):
         """Set an attr with protection of class members.
 
         This calls :meth:`self.__setitem__` but convert :exc:`KeyError` to
         :exc:`AttributeError`.
 
         Examples
         --------
 
         >>> s = Struct()
         >>> s.a = 10
         >>> s.a
         10
         >>> try:
         ...     s.get = 10
         ... except AttributeError:
         ...     print "you can't set a class member"
         ...
         you can't set a class member
         """
         # If key is an str it might be a class member or instance var
         if isinstance(key, str):
             # I can't simply call hasattr here because it calls getattr, which
             # calls self.__getattr__, which returns True for keys in
             # self._data.  But I only want keys in the class and in
             # self.__dict__
             if key in self.__dict__ or hasattr(Struct, key):
                 raise AttributeError(
                     'attr %s is a protected member of class Struct.' % key
                 )
         try:
             self.__setitem__(key, value)
         except KeyError, e:
             raise AttributeError(e)
 
     def __getattr__(self, key):
         """Get an attr by calling :meth:`dict.__getitem__`.
 
         Like :meth:`__setattr__`, this method converts :exc:`KeyError` to
         :exc:`AttributeError`.
 
         Examples
         --------
 
         >>> s = Struct(a=10)
         >>> s.a
         10
         >>> type(s.get)
-        <type 'builtin_function_or_method'>
+        <... 'builtin_function_or_method'>
         >>> try:
         ...     s.b
         ... except AttributeError:
         ...     print "I don't have that key"
         ...
         I don't have that key
         """
         try:
             result = self[key]
         except KeyError:
             raise AttributeError(key)
         else:
             return result
 
     def __iadd__(self, other):
         """s += s2 is a shorthand for s.merge(s2).
 
         Examples
         --------
 
         >>> s = Struct(a=10,b=30)
         >>> s2 = Struct(a=20,c=40)
         >>> s += s2
         >>> s
         {'a': 10, 'c': 40, 'b': 30}
         """
         self.merge(other)
         return self
 
     def __add__(self,other):
         """s + s2 -> New Struct made from s.merge(s2).
 
         Examples
         --------
 
         >>> s1 = Struct(a=10,b=30)
         >>> s2 = Struct(a=20,c=40)
         >>> s = s1 + s2
         >>> s
         {'a': 10, 'c': 40, 'b': 30}
         """
         sout = self.copy()
         sout.merge(other)
         return sout
 
     def __sub__(self,other):
         """s1 - s2 -> remove keys in s2 from s1.
 
         Examples
         --------
 
         >>> s1 = Struct(a=10,b=30)
         >>> s2 = Struct(a=40)
         >>> s = s1 - s2
         >>> s
         {'b': 30}
         """
         sout = self.copy()
         sout -= other
         return sout
 
     def __isub__(self,other):
         """Inplace remove keys from self that are in other.
 
         Examples
         --------
 
         >>> s1 = Struct(a=10,b=30)
         >>> s2 = Struct(a=40)
         >>> s1 -= s2
         >>> s1
         {'b': 30}
         """
         for k in other.keys():
             if self.has_key(k):
                 del self[k]
         return self
 
     def __dict_invert(self, data):
         """Helper function for merge.
 
         Takes a dictionary whose values are lists and returns a dict with
         the elements of each list as keys and the original keys as values.
         """
         outdict = {}
         for k,lst in data.items():
             if isinstance(lst, str):
                 lst = lst.split()
             for entry in lst:
                 outdict[entry] = k
         return outdict
 
     def dict(self):
         return self
 
     def copy(self):
         """Return a copy as a Struct.
 
         Examples
         --------
 
         >>> s = Struct(a=10,b=30)
         >>> s2 = s.copy()
         >>> s2
         {'a': 10, 'b': 30}
         >>> type(s2).__name__
         'Struct'
         """
         return Struct(dict.copy(self))
 
     def hasattr(self, key):
         """hasattr function available as a method.
 
         Implemented like has_key.
 
         Examples
         --------
 
         >>> s = Struct(a=10)
         >>> s.hasattr('a')
         True
         >>> s.hasattr('b')
         False
         >>> s.hasattr('get')
         False
         """
         return self.has_key(key)
 
     def allow_new_attr(self, allow = True):
         """Set whether new attributes can be created in this Struct.
 
         This can be used to catch typos by verifying that the attribute user
         tries to change already exists in this Struct.
         """
         object.__setattr__(self, '_allownew', allow)
 
     def merge(self, __loc_data__=None, __conflict_solve=None, **kw):
         """Merge two Structs with customizable conflict resolution.
 
         This is similar to :meth:`update`, but much more flexible. First, a
         dict is made from data+key=value pairs. When merging this dict with
         the Struct S, the optional dictionary 'conflict' is used to decide
         what to do.
 
         If conflict is not given, the default behavior is to preserve any keys
         with their current value (the opposite of the :meth:`update` method's
         behavior).
 
         Parameters
         ----------
         __loc_data : dict, Struct
             The data to merge into self
         __conflict_solve : dict
             The conflict policy dict.  The keys are binary functions used to
             resolve the conflict and the values are lists of strings naming
             the keys the conflict resolution function applies to.  Instead of
             a list of strings a space separated string can be used, like
             'a b c'.
         kw : dict
             Additional key, value pairs to merge in
 
         Notes
         -----
 
         The `__conflict_solve` dict is a dictionary of binary functions which will be used to
         solve key conflicts.  Here is an example::
 
             __conflict_solve = dict(
                 func1=['a','b','c'],
                 func2=['d','e']
             )
 
         In this case, the function :func:`func1` will be used to resolve
         keys 'a', 'b' and 'c' and the function :func:`func2` will be used for
         keys 'd' and 'e'.  This could also be written as::
 
             __conflict_solve = dict(func1='a b c',func2='d e')
 
         These functions will be called for each key they apply to with the
         form::
 
             func1(self['a'], other['a'])
 
         The return value is used as the final merged value.
 
         As a convenience, merge() provides five (the most commonly needed)
         pre-defined policies: preserve, update, add, add_flip and add_s. The
         easiest explanation is their implementation::
 
             preserve = lambda old,new: old
             update   = lambda old,new: new
             add      = lambda old,new: old + new
             add_flip = lambda old,new: new + old  # note change of order!
             add_s    = lambda old,new: old + ' ' + new  # only for str!
 
         You can use those four words (as strings) as keys instead
         of defining them as functions, and the merge method will substitute
         the appropriate functions for you.
 
         For more complicated conflict resolution policies, you still need to
         construct your own functions.
 
         Examples
         --------
 
         This show the default policy:
 
         >>> s = Struct(a=10,b=30)
         >>> s2 = Struct(a=20,c=40)
         >>> s.merge(s2)
         >>> s
         {'a': 10, 'c': 40, 'b': 30}
 
         Now, show how to specify a conflict dict:
 
         >>> s = Struct(a=10,b=30)
         >>> s2 = Struct(a=20,b=40)
         >>> conflict = {'update':'a','add':'b'}
         >>> s.merge(s2,conflict)
         >>> s
         {'a': 20, 'b': 70}
         """
 
         data_dict = dict(__loc_data__,**kw)
 
         # policies for conflict resolution: two argument functions which return
         # the value that will go in the new struct
         preserve = lambda old,new: old
         update   = lambda old,new: new
         add      = lambda old,new: old + new
         add_flip = lambda old,new: new + old  # note change of order!
         add_s    = lambda old,new: old + ' ' + new
 
         # default policy is to keep current keys when there's a conflict
         conflict_solve = list2dict2(self.keys(), default = preserve)
 
         # the conflict_solve dictionary is given by the user 'inverted': we
         # need a name-function mapping, it comes as a function -> names
         # dict. Make a local copy (b/c we'll make changes), replace user
         # strings for the three builtin policies and invert it.
         if __conflict_solve:
             inv_conflict_solve_user = __conflict_solve.copy()
             for name, func in [('preserve',preserve), ('update',update),
                                ('add',add), ('add_flip',add_flip),
                                ('add_s',add_s)]:
                 if name in inv_conflict_solve_user.keys():
                     inv_conflict_solve_user[func] = inv_conflict_solve_user[name]
                     del inv_conflict_solve_user[name]
             conflict_solve.update(self.__dict_invert(inv_conflict_solve_user))
         for key in data_dict:
             if key not in self:
                 self[key] = data_dict[key]
             else:
                 self[key] = conflict_solve[key](self[key],data_dict[key])
 

IPython/utils/sysinfo.py

@@ -1,185 +1,187 b''
 # encoding: utf-8
 """
 Utilities for getting information about IPython and the system it's running in.
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-2009  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 platform
 import pprint
 import sys
 import subprocess
 
 from ConfigParser import ConfigParser
 
 from IPython.core import release
+from IPython.utils import py3compat
 
 #-----------------------------------------------------------------------------
 # Globals
 #-----------------------------------------------------------------------------
 COMMIT_INFO_FNAME = '.git_commit_info.ini'
 
 #-----------------------------------------------------------------------------
 # Code
 #-----------------------------------------------------------------------------
 
 def pkg_commit_hash(pkg_path):
     """Get short form of commit hash given directory `pkg_path`
 
     There should be a file called 'COMMIT_INFO.txt' in `pkg_path`.  This is a
     file in INI file format, with at least one section: ``commit hash``, and two
     variables ``archive_subst_hash`` and ``install_hash``.  The first has a
     substitution pattern in it which may have been filled by the execution of
     ``git archive`` if this is an archive generated that way.  The second is
     filled in by the installation, if the installation is from a git archive.
 
     We get the commit hash from (in order of preference):
 
     * A substituted value in ``archive_subst_hash``
     * A written commit hash value in ``install_hash`
     * git output, if we are in a git repository
 
     If all these fail, we return a not-found placeholder tuple
 
     Parameters
     ----------
     pkg_path : str
        directory containing package
 
     Returns
     -------
     hash_from : str
        Where we got the hash from - description
     hash_str : str
        short form of hash
     """
     # Try and get commit from written commit text file
     pth = os.path.join(pkg_path, COMMIT_INFO_FNAME)
     if not os.path.isfile(pth):
         raise IOError('Missing commit info file %s' % pth)
     cfg_parser = ConfigParser()
     cfg_parser.read(pth)
     archive_subst = cfg_parser.get('commit hash', 'archive_subst_hash')
     if not archive_subst.startswith('$Format'): # it has been substituted
         return 'archive substitution', archive_subst
     install_subst = cfg_parser.get('commit hash', 'install_hash')
     if install_subst != '':
         return 'installation', install_subst
     # maybe we are in a repository
     proc = subprocess.Popen('git rev-parse --short HEAD',
                             stdout=subprocess.PIPE,
                             stderr=subprocess.PIPE,
                             cwd=pkg_path, shell=True)
     repo_commit, _ = proc.communicate()
     if repo_commit:
         return 'repository', repo_commit.strip()
     return '(none found)', '<not found>'
 
 
 def pkg_info(pkg_path):
     """Return dict describing the context of this package
 
     Parameters
     ----------
     pkg_path : str
        path containing __init__.py for package
 
     Returns
     -------
     context : dict
        with named parameters of interest
     """
     src, hsh = pkg_commit_hash(pkg_path)
     return dict(
         ipython_version=release.version,
         ipython_path=pkg_path,
         commit_source=src,
         commit_hash=hsh,
         sys_version=sys.version,
         sys_executable=sys.executable,
         sys_platform=sys.platform,
         platform=platform.platform(),
         os_name=os.name,
         )
 
 
[e-mail]_refactor_print
 def sys_info():
     """Return useful information about IPython and the system, as a string.
 
     Example
     -------
     In [2]: print sys_info()
     {'commit_hash': '144fdae',      # random
      'commit_source': 'repository',
      'ipython_path': '/home/fperez/usr/lib/python2.6/site-packages/IPython',
      'ipython_version': '0.11.dev',
      'os_name': 'posix',
      'platform': 'Linux-2.6.35-22-generic-i686-with-Ubuntu-10.10-maverick',
      'sys_executable': '/usr/bin/python',
      'sys_platform': 'linux2',
      'sys_version': '2.6.6 (r266:84292, Sep 15 2010, 15:52:39) \\n[GCC 4.4.5]'}
    """
     p = os.path
     path = p.dirname(p.abspath(p.join(__file__, '..')))
     return pprint.pformat(pkg_info(path))
 
 
 def _num_cpus_unix():
     """Return the number of active CPUs on a Unix system."""
     return os.sysconf("SC_NPROCESSORS_ONLN")
 
 
 def _num_cpus_darwin():
     """Return the number of active CPUs on a Darwin system."""
     p = subprocess.Popen(['sysctl','-n','hw.ncpu'],stdout=subprocess.PIPE)
     return p.stdout.read()
 
 
 def _num_cpus_windows():
     """Return the number of active CPUs on a Windows system."""
     return os.environ.get("NUMBER_OF_PROCESSORS")
 
 
 def num_cpus():
    """Return the effective number of CPUs in the system as an integer.
 
    This cross-platform function makes an attempt at finding the total number of
    available CPUs in the system, as returned by various underlying system and
    python calls.
 
    If it can't find a sensible answer, it returns 1 (though an error *may* make
    it return a large positive number that's actually incorrect).
    """
 
    # Many thanks to the Parallel Python project (http://www.parallelpython.com)
    # for the names of the keys we needed to look up for this function.  This
    # code was inspired by their equivalent function.
 
    ncpufuncs = {'Linux':_num_cpus_unix,
                 'Darwin':_num_cpus_darwin,
                 'Windows':_num_cpus_windows,
                 # On Vista, python < 2.5.2 has a bug and returns 'Microsoft'
                 # See http://bugs.python.org/issue1082 for details.
                 'Microsoft':_num_cpus_windows,
                 }
 
    ncpufunc = ncpufuncs.get(platform.system(),
                             # default to unix version (Solaris, AIX, etc)
                             _num_cpus_unix)
 
    try:
        ncpus = max(1,int(ncpufunc()))
    except:
        ncpus = 1
    return ncpus
 

IPython/utils/tests/test_io.py

@@ -1,71 +1,75 b''
 # encoding: utf-8
 """Tests for io.py"""
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008  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 sys
 
 from StringIO import StringIO
 from subprocess import Popen, PIPE
 
 import nose.tools as nt
 
 from IPython.testing import decorators as dec
 from IPython.utils.io import Tee
+from IPython.utils.py3compat import doctest_refactor_print
 
 #-----------------------------------------------------------------------------
 # Tests
 #-----------------------------------------------------------------------------
 
 
 def test_tee_simple():
     "Very simple check with stdout only"
     chan = StringIO()
     text = 'Hello'
     tee = Tee(chan, channel='stdout')
-    print >> chan, text,
-    nt.assert_equal(chan.getvalue(), text)
+    print >> chan, text
+    nt.assert_equal(chan.getvalue(), text+"\n")
 
 
 class TeeTestCase(dec.ParametricTestCase):
 
     def tchan(self, channel, check='close'):
         trap = StringIO()
         chan = StringIO()
         text = 'Hello'
         
         std_ori = getattr(sys, channel)
         setattr(sys, channel, trap)
 
         tee = Tee(chan, channel=channel)
         print >> chan, text,
         setattr(sys, channel, std_ori)
         trap_val = trap.getvalue()
         nt.assert_equals(chan.getvalue(), text)
         if check=='close':
             tee.close()
         else:
             del tee
 
     def test(self):
         for chan in ['stdout', 'stderr']:
             for check in ['close', 'del']:
                 yield self.tchan(chan, check)
 
 def test_io_init():
     """Test that io.stdin/out/err exist at startup"""
     for name in ('stdin', 'stdout', 'stderr'):
-        p = Popen([sys.executable, '-c', "from IPython.utils import io;print io.%s.__class__"%name],
+        cmd = doctest_refactor_print("from IPython.utils import io;print io.%s.__class__"%name)
+        p = Popen([sys.executable, '-c', cmd],
                     stdout=PIPE)
         p.wait()
-        classname = p.stdout.read().strip()
-        nt.assert_equals(classname, 'IPython.utils.io.IOStream')
+        classname = p.stdout.read().strip().decode('ascii')
+        # __class__ is a reference to the class object in Python 3, so we can't
+        # just test for string equality.
+        assert 'IPython.utils.io.IOStream' in classname, classname

IPython/utils/tests/test_path.py

@@ -1,450 +1,450 b''
 # encoding: utf-8
 """Tests for IPython.utils.path.py"""
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008  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 with_statement
 
 import os
 import shutil
 import sys
 import tempfile
-import StringIO
+from io import StringIO
 
 from os.path import join, abspath, split
 
 import nose.tools as nt
 
 from nose import with_setup
 
 import IPython
 from IPython.testing import decorators as dec
 from IPython.testing.decorators import skip_if_not_win32, skip_win32
 from IPython.testing.tools import make_tempfile
 from IPython.utils import path, io
 from IPython.utils import py3compat
 
 # Platform-dependent imports
 try:
     import _winreg as wreg
 except ImportError:
     #Fake _winreg module on none windows platforms
     import types
     wr_name = "winreg" if py3compat.PY3 else "_winreg"
     sys.modules[wr_name] = types.ModuleType(wr_name)
     import _winreg as wreg
     #Add entries that needs to be stubbed by the testing code
     (wreg.OpenKey, wreg.QueryValueEx,) = (None, None)
 
 try:
     reload
 except NameError:   # Python 3
     from imp import reload
 
 #-----------------------------------------------------------------------------
 # Globals
 #-----------------------------------------------------------------------------
 env = os.environ
 TEST_FILE_PATH = split(abspath(__file__))[0]
 TMP_TEST_DIR = tempfile.mkdtemp()
 HOME_TEST_DIR = join(TMP_TEST_DIR, "home_test_dir")
 XDG_TEST_DIR = join(HOME_TEST_DIR, "xdg_test_dir")
 IP_TEST_DIR = join(HOME_TEST_DIR,'.ipython')
 #
 # Setup/teardown functions/decorators
 #
 
 def setup():
     """Setup testenvironment for the module:
 
             - Adds dummy home dir tree
     """
     # Do not mask exceptions here.  In particular, catching WindowsError is a
     # problem because that exception is only defined on Windows...
     os.makedirs(IP_TEST_DIR)
     os.makedirs(os.path.join(XDG_TEST_DIR, 'ipython'))
 
 
 def teardown():
     """Teardown testenvironment for the module:
 
             - Remove dummy home dir tree
     """
     # Note: we remove the parent test dir, which is the root of all test
     # subdirs we may have created.  Use shutil instead of os.removedirs, so
     # that non-empty directories are all recursively removed.
     shutil.rmtree(TMP_TEST_DIR)
 
 
 def setup_environment():
     """Setup testenvironment for some functions that are tested
     in this module. In particular this functions stores attributes
     and other things that we need to stub in some test functions.
     This needs to be done on a function level and not module level because
     each testfunction needs a pristine environment.
     """
     global oldstuff, platformstuff
     oldstuff = (env.copy(), os.name, path.get_home_dir, IPython.__file__, os.getcwd())
 
     if os.name == 'nt':
         platformstuff = (wreg.OpenKey, wreg.QueryValueEx,)
 
 
 def teardown_environment():
     """Restore things that were remebered by the setup_environment function
     """
     (oldenv, os.name, path.get_home_dir, IPython.__file__, old_wd) = oldstuff
     os.chdir(old_wd)
     reload(path)
 
     for key in env.keys():
         if key not in oldenv:
             del env[key]
     env.update(oldenv)
     if hasattr(sys, 'frozen'):
         del sys.frozen
     if os.name == 'nt':
         (wreg.OpenKey, wreg.QueryValueEx,) = platformstuff
 
 # Build decorator that uses the setup_environment/setup_environment
 with_environment = with_setup(setup_environment, teardown_environment)
 
 
 @skip_if_not_win32
 @with_environment
 def test_get_home_dir_1():
     """Testcase for py2exe logic, un-compressed lib
     """
     sys.frozen = True
 
     #fake filename for IPython.__init__
     IPython.__file__ = abspath(join(HOME_TEST_DIR, "Lib/IPython/__init__.py"))
 
     home_dir = path.get_home_dir()
     nt.assert_equal(home_dir, abspath(HOME_TEST_DIR))
 
 
 @skip_if_not_win32
 @with_environment
 def test_get_home_dir_2():
     """Testcase for py2exe logic, compressed lib
     """
     sys.frozen = True
     #fake filename for IPython.__init__
     IPython.__file__ = abspath(join(HOME_TEST_DIR, "Library.zip/IPython/__init__.py")).lower()
 
     home_dir = path.get_home_dir()
     nt.assert_equal(home_dir, abspath(HOME_TEST_DIR).lower())
 
 
 @with_environment
 @skip_win32
 def test_get_home_dir_3():
     """Testcase $HOME is set, then use its value as home directory."""
     env["HOME"] = HOME_TEST_DIR
     home_dir = path.get_home_dir()
     nt.assert_equal(home_dir, env["HOME"])
 
 
 @with_environment
 @skip_win32
 def test_get_home_dir_4():
     """Testcase $HOME is not set, os=='posix'.
     This should fail with HomeDirError"""
 
     os.name = 'posix'
     if 'HOME' in env: del env['HOME']
     nt.assert_raises(path.HomeDirError, path.get_home_dir)
 
 
 @skip_if_not_win32
 @with_environment
 def test_get_home_dir_5():
     """Using HOMEDRIVE + HOMEPATH, os=='nt'.
 
     HOMESHARE is missing.
     """
 
     os.name = 'nt'
     env.pop('HOMESHARE', None)
     env['HOMEDRIVE'], env['HOMEPATH'] = os.path.splitdrive(HOME_TEST_DIR)
     home_dir = path.get_home_dir()
     nt.assert_equal(home_dir, abspath(HOME_TEST_DIR))
 
 
 @skip_if_not_win32
 @with_environment
 def test_get_home_dir_6():
     """Using USERPROFILE, os=='nt'.
 
     HOMESHARE, HOMEDRIVE, HOMEPATH are missing.
     """
 
     os.name = 'nt'
     env.pop('HOMESHARE', None)
     env.pop('HOMEDRIVE', None)
     env.pop('HOMEPATH', None)
     env["USERPROFILE"] = abspath(HOME_TEST_DIR)
     home_dir = path.get_home_dir()
     nt.assert_equal(home_dir, abspath(HOME_TEST_DIR))
 
 
 @skip_if_not_win32
 @with_environment
 def test_get_home_dir_7():
     """Using HOMESHARE, os=='nt'."""
 
     os.name = 'nt'
     env["HOMESHARE"] = abspath(HOME_TEST_DIR)
     home_dir = path.get_home_dir()
     nt.assert_equal(home_dir, abspath(HOME_TEST_DIR))
 
 
 # Should we stub wreg fully so we can run the test on all platforms?
 @skip_if_not_win32
 @with_environment
 def test_get_home_dir_8():
     """Using registry hack for 'My Documents', os=='nt'
 
     HOMESHARE, HOMEDRIVE, HOMEPATH, USERPROFILE and others are missing.
     """
     os.name = 'nt'
     # Remove from stub environment all keys that may be set
     for key in ['HOME', 'HOMESHARE', 'HOMEDRIVE', 'HOMEPATH', 'USERPROFILE']:
         env.pop(key, None)
 
     #Stub windows registry functions
     def OpenKey(x, y):
         class key:
             def Close(self):
                 pass
         return key()
     def QueryValueEx(x, y):
         return [abspath(HOME_TEST_DIR)]
 
     wreg.OpenKey = OpenKey
     wreg.QueryValueEx = QueryValueEx
 
     home_dir = path.get_home_dir()
     nt.assert_equal(home_dir, abspath(HOME_TEST_DIR))
 
 
 @with_environment
 def test_get_ipython_dir_1():
     """test_get_ipython_dir_1, Testcase to see if we can call get_ipython_dir without Exceptions."""
     env_ipdir = os.path.join("someplace", ".ipython")
     path._writable_dir = lambda path: True
     env['IPYTHON_DIR'] = env_ipdir
     ipdir = path.get_ipython_dir()
     nt.assert_equal(ipdir, env_ipdir)
 
 
 @with_environment
 def test_get_ipython_dir_2():
     """test_get_ipython_dir_2, Testcase to see if we can call get_ipython_dir without Exceptions."""
     path.get_home_dir = lambda : "someplace"
     path.get_xdg_dir = lambda : None
     path._writable_dir = lambda path: True
     os.name = "posix"
     env.pop('IPYTHON_DIR', None)
     env.pop('IPYTHONDIR', None)
     env.pop('XDG_CONFIG_HOME', None)
     ipdir = path.get_ipython_dir()
     nt.assert_equal(ipdir, os.path.join("someplace", ".ipython"))
 
 @with_environment
 def test_get_ipython_dir_3():
     """test_get_ipython_dir_3, use XDG if defined, and .ipython doesn't exist."""
     path.get_home_dir = lambda : "someplace"
     path._writable_dir = lambda path: True
     os.name = "posix"
     env.pop('IPYTHON_DIR', None)
     env.pop('IPYTHONDIR', None)
     env['XDG_CONFIG_HOME'] = XDG_TEST_DIR
     ipdir = path.get_ipython_dir()
     nt.assert_equal(ipdir, os.path.join(XDG_TEST_DIR, "ipython"))
 
 @with_environment
 def test_get_ipython_dir_4():
     """test_get_ipython_dir_4, use XDG if both exist."""
     path.get_home_dir = lambda : HOME_TEST_DIR
     os.name = "posix"
     env.pop('IPYTHON_DIR', None)
     env.pop('IPYTHONDIR', None)
     env['XDG_CONFIG_HOME'] = XDG_TEST_DIR
     xdg_ipdir = os.path.join(XDG_TEST_DIR, "ipython")
     ipdir = path.get_ipython_dir()
     nt.assert_equal(ipdir, xdg_ipdir)
 
 @with_environment
 def test_get_ipython_dir_5():
     """test_get_ipython_dir_5, use .ipython if exists and XDG defined, but doesn't exist."""
     path.get_home_dir = lambda : HOME_TEST_DIR
     os.name = "posix"
     env.pop('IPYTHON_DIR', None)
     env.pop('IPYTHONDIR', None)
     env['XDG_CONFIG_HOME'] = XDG_TEST_DIR
     os.rmdir(os.path.join(XDG_TEST_DIR, 'ipython'))
     ipdir = path.get_ipython_dir()
     nt.assert_equal(ipdir, IP_TEST_DIR)
 
 @with_environment
 def test_get_ipython_dir_6():
     """test_get_ipython_dir_6, use XDG if defined and neither exist."""
     xdg = os.path.join(HOME_TEST_DIR, 'somexdg')
     os.mkdir(xdg)
     shutil.rmtree(os.path.join(HOME_TEST_DIR, '.ipython'))
     path.get_home_dir = lambda : HOME_TEST_DIR
     path.get_xdg_dir = lambda : xdg
     os.name = "posix"
     env.pop('IPYTHON_DIR', None)
     env.pop('IPYTHONDIR', None)
     env.pop('XDG_CONFIG_HOME', None)
     xdg_ipdir = os.path.join(xdg, "ipython")
     ipdir = path.get_ipython_dir()
     nt.assert_equal(ipdir, xdg_ipdir)
 
 @with_environment
 def test_get_ipython_dir_7():
     """test_get_ipython_dir_7, test home directory expansion on IPYTHON_DIR"""
     path._writable_dir = lambda path: True
     home_dir = os.path.expanduser('~')
     env['IPYTHON_DIR'] = os.path.join('~', 'somewhere')
     ipdir = path.get_ipython_dir()
     nt.assert_equal(ipdir, os.path.join(home_dir, 'somewhere'))
 
 
 @with_environment
 def test_get_xdg_dir_1():
     """test_get_xdg_dir_1, check xdg_dir"""
     reload(path)
     path._writable_dir = lambda path: True
     path.get_home_dir = lambda : 'somewhere'
     os.name = "posix"
     env.pop('IPYTHON_DIR', None)
     env.pop('IPYTHONDIR', None)
     env.pop('XDG_CONFIG_HOME', None)
 
     nt.assert_equal(path.get_xdg_dir(), os.path.join('somewhere', '.config'))
 
 
 @with_environment
 def test_get_xdg_dir_1():
     """test_get_xdg_dir_1, check nonexistant xdg_dir"""
     reload(path)
     path.get_home_dir = lambda : HOME_TEST_DIR
     os.name = "posix"
     env.pop('IPYTHON_DIR', None)
     env.pop('IPYTHONDIR', None)
     env.pop('XDG_CONFIG_HOME', None)
     nt.assert_equal(path.get_xdg_dir(), None)
 
 @with_environment
 def test_get_xdg_dir_2():
     """test_get_xdg_dir_2, check xdg_dir default to ~/.config"""
     reload(path)
     path.get_home_dir = lambda : HOME_TEST_DIR
     os.name = "posix"
     env.pop('IPYTHON_DIR', None)
     env.pop('IPYTHONDIR', None)
     env.pop('XDG_CONFIG_HOME', None)
     cfgdir=os.path.join(path.get_home_dir(), '.config')
     os.makedirs(cfgdir)
 
     nt.assert_equal(path.get_xdg_dir(), cfgdir)
 
 def test_filefind():
     """Various tests for filefind"""
     f = tempfile.NamedTemporaryFile()
     # print 'fname:',f.name
     alt_dirs = path.get_ipython_dir()
     t = path.filefind(f.name, alt_dirs)
     # print 'found:',t
 
 
 def test_get_ipython_package_dir():
     ipdir = path.get_ipython_package_dir()
     nt.assert_true(os.path.isdir(ipdir))
 
 
 def test_get_ipython_module_path():
     ipapp_path = path.get_ipython_module_path('IPython.frontend.terminal.ipapp')
     nt.assert_true(os.path.isfile(ipapp_path))
 
 
 @dec.skip_if_not_win32
 def test_get_long_path_name_win32():
     p = path.get_long_path_name('c:\\docume~1')
     nt.assert_equals(p,u'c:\\Documents and Settings')
 
 
 @dec.skip_win32
 def test_get_long_path_name():
     p = path.get_long_path_name('/usr/local')
     nt.assert_equals(p,'/usr/local')
 
 @dec.skip_win32 # can't create not-user-writable dir on win
 @with_environment
 def test_not_writable_ipdir():
     tmpdir = tempfile.mkdtemp()
     os.name = "posix"
     env.pop('IPYTHON_DIR', None)
     env.pop('IPYTHONDIR', None)
     env.pop('XDG_CONFIG_HOME', None)
     env['HOME'] = tmpdir
     ipdir = os.path.join(tmpdir, '.ipython')
     os.mkdir(ipdir)
     os.chmod(ipdir, 600)
     stderr = io.stderr
-    pipe = StringIO.StringIO()
+    pipe = StringIO()
     io.stderr = pipe
     ipdir = path.get_ipython_dir()
     io.stderr.flush()
     io.stderr = stderr
     nt.assert_true('WARNING' in pipe.getvalue())
     env.pop('IPYTHON_DIR', None)
 
 def test_unquote_filename():
     for win32 in (True, False):
         nt.assert_equals(path.unquote_filename('foo.py', win32=win32), 'foo.py')
         nt.assert_equals(path.unquote_filename('foo bar.py', win32=win32), 'foo bar.py')
     nt.assert_equals(path.unquote_filename('"foo.py"', win32=True), 'foo.py')
     nt.assert_equals(path.unquote_filename('"foo bar.py"', win32=True), 'foo bar.py')
     nt.assert_equals(path.unquote_filename("'foo.py'", win32=True), 'foo.py')
     nt.assert_equals(path.unquote_filename("'foo bar.py'", win32=True), 'foo bar.py')
     nt.assert_equals(path.unquote_filename('"foo.py"', win32=False), '"foo.py"')
     nt.assert_equals(path.unquote_filename('"foo bar.py"', win32=False), '"foo bar.py"')
     nt.assert_equals(path.unquote_filename("'foo.py'", win32=False), "'foo.py'")
     nt.assert_equals(path.unquote_filename("'foo bar.py'", win32=False), "'foo bar.py'")
 
 @with_environment
 def test_get_py_filename():
     os.chdir(TMP_TEST_DIR)
     for win32 in (True, False):
         with make_tempfile('foo.py'):
             nt.assert_equals(path.get_py_filename('foo.py', force_win32=win32), 'foo.py')
             nt.assert_equals(path.get_py_filename('foo', force_win32=win32), 'foo.py')
         with make_tempfile('foo'):
             nt.assert_equals(path.get_py_filename('foo', force_win32=win32), 'foo')
             nt.assert_raises(IOError, path.get_py_filename, 'foo.py', force_win32=win32)
         nt.assert_raises(IOError, path.get_py_filename, 'foo', force_win32=win32)
         nt.assert_raises(IOError, path.get_py_filename, 'foo.py', force_win32=win32)
         true_fn = 'foo with spaces.py'
         with make_tempfile(true_fn):
             nt.assert_equals(path.get_py_filename('foo with spaces', force_win32=win32), true_fn)
             nt.assert_equals(path.get_py_filename('foo with spaces.py', force_win32=win32), true_fn)
             if win32:
                 nt.assert_equals(path.get_py_filename('"foo with spaces.py"', force_win32=True), true_fn)
                 nt.assert_equals(path.get_py_filename("'foo with spaces.py'", force_win32=True), true_fn)
             else:
                 nt.assert_raises(IOError, path.get_py_filename, '"foo with spaces.py"', force_win32=False)
                 nt.assert_raises(IOError, path.get_py_filename, "'foo with spaces.py'", force_win32=False)

IPython/utils/tests/test_text.py

@@ -1,87 +1,87 b''
 # encoding: utf-8
 """Tests for IPython.utils.text"""
 
 #-----------------------------------------------------------------------------
 #  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
 #-----------------------------------------------------------------------------
 
 import os
 import math
 
 import nose.tools as nt
 
 from nose import with_setup
 
 from IPython.testing import decorators as dec
 from IPython.utils import text
 
 #-----------------------------------------------------------------------------
 # Globals
 #-----------------------------------------------------------------------------
 
 def test_columnize():
     """Basic columnize tests."""
     size = 5
     items = [l*size for l in 'abc']
     out = text.columnize(items, displaywidth=80)
     nt.assert_equals(out, 'aaaaa  bbbbb  ccccc\n')
     out = text.columnize(items, displaywidth=10)
     nt.assert_equals(out, 'aaaaa  ccccc\nbbbbb\n')
 
 
 def test_columnize_long():
     """Test columnize with inputs longer than the display window"""
     text.columnize(['a'*81, 'b'*81], displaywidth=80)
     size = 11
     items = [l*size for l in 'abc']
     out = text.columnize(items, displaywidth=size-1)
     nt.assert_equals(out, '\n'.join(items+['']))
 
 def test_eval_formatter():
     f = text.EvalFormatter()
     ns = dict(n=12, pi=math.pi, stuff='hello there', os=os)
-    s = f.format("{n} {n/4} {stuff.split()[0]}", **ns)
+    s = f.format("{n} {n//4} {stuff.split()[0]}", **ns)
     nt.assert_equals(s, "12 3 hello")
     s = f.format(' '.join(['{n//%i}'%i for i in range(1,8)]), **ns)
     nt.assert_equals(s, "12 6 4 3 2 2 1")
     s = f.format('{[n//i for i in range(1,8)]}', **ns)
     nt.assert_equals(s, "[12, 6, 4, 3, 2, 2, 1]")
     s = f.format("{stuff!s}", **ns)
     nt.assert_equals(s, ns['stuff'])
     s = f.format("{stuff!r}", **ns)
     nt.assert_equals(s, repr(ns['stuff']))
     
     nt.assert_raises(NameError, f.format, '{dne}', **ns)
 
 
 def test_eval_formatter_slicing():
     f = text.EvalFormatter()
     f.allow_slicing = True
     ns = dict(n=12, pi=math.pi, stuff='hello there', os=os)
     s = f.format(" {stuff.split()[:]} ", **ns)
     nt.assert_equals(s, " ['hello', 'there'] ")
     s = f.format(" {stuff.split()[::-1]} ", **ns)
     nt.assert_equals(s, " ['there', 'hello'] ")
     s = f.format("{stuff[::2]}", **ns)
     nt.assert_equals(s, ns['stuff'][::2])
     
     nt.assert_raises(SyntaxError, f.format, "{n:x}", **ns)
     
 
 def test_eval_formatter_no_slicing():
     f = text.EvalFormatter()
     f.allow_slicing = False
     ns = dict(n=12, pi=math.pi, stuff='hello there', os=os)
     
     s = f.format('{n:x} {pi**2:+f}', **ns)
     nt.assert_equals(s, "c +9.869604")
     
     nt.assert_raises(SyntaxError, f.format, "{a[:]}")
 

IPython/utils/tests/test_traitlets.py

@@ -1,846 +1,855 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-2009  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 sys
 from unittest import TestCase
 
 from IPython.utils.traitlets import (
     HasTraits, MetaHasTraits, TraitType, Any, CBytes,
     Int, Long, Float, Complex, Bytes, Unicode, TraitError,
     Undefined, Type, This, Instance, TCPAddress, List, Tuple,
     ObjectName, DottedObjectName
 )
-
+from IPython.utils import py3compat
 
 #-----------------------------------------------------------------------------
 # 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.assertEquals(a.a, Undefined)
 
     def test_set(self):
         class A(HasTraitsStub):
             a = TraitType
 
         a = A()
         a.a = 10
         self.assertEquals(a.a, 10)
         self.assertEquals(a._notify_name, 'a')
         self.assertEquals(a._notify_old, Undefined)
         self.assertEquals(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.assertEquals(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.assertEquals(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.assertEquals(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.assertEquals(a.tt, 20)
 
     def test_info(self):
         class A(HasTraits):
             tt = TraitType
         a = A()
         self.assertEquals(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.assertEquals(a._trait_values, {})
         self.assertEquals(a._trait_dyn_inits.keys(), ['x'])
         self.assertEquals(a.x, 11)
         self.assertEquals(a._trait_values, {'x': 11})
         b = B()
         self.assertEquals(b._trait_values, {'x': 20})
         self.assertEquals(a._trait_dyn_inits.keys(), ['x'])
         self.assertEquals(b.x, 20)
         c = C()
         self.assertEquals(c._trait_values, {})
         self.assertEquals(a._trait_dyn_inits.keys(), ['x'])
         self.assertEquals(c.x, 21)
         self.assertEquals(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.assertEquals(a._trait_values, {})
         self.assertEquals(a._trait_dyn_inits.keys(), ['x'])
         self.assertEquals(a.x, 11)
         self.assertEquals(a._trait_values, {'x': 11})
 
 
 
 class TestHasTraitsMeta(TestCase):
 
     def test_metaclass(self):
         self.assertEquals(type(HasTraits), MetaHasTraits)
 
         class A(HasTraits):
             a = Int
 
         a = A()
         self.assertEquals(type(a.__class__), MetaHasTraits)
         self.assertEquals(a.a,0)
         a.a = 10
         self.assertEquals(a.a,10)
 
         class B(HasTraits):
             b = Int()
 
         b = B()
         self.assertEquals(b.b,0)
         b.b = 10
         self.assertEquals(b.b,10)
 
         class C(HasTraits):
             c = Int(30)
 
         c = C()
         self.assertEquals(c.c,30)
         c.c = 10
         self.assertEquals(c.c,10)
 
     def test_this_class(self):
         class A(HasTraits):
             t = This()
             tt = This()
         class B(A):
             tt = This()
             ttt = This()
         self.assertEquals(A.t.this_class, A)
         self.assertEquals(B.t.this_class, A)
         self.assertEquals(B.tt.this_class, B)
         self.assertEquals(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.assertEquals(len(self._notify1),0)
         a.b = 0.0
         self.assertEquals(len(self._notify1),0)
         a.a = 10
         self.assert_(('a',0,10) in self._notify1)
         a.b = 10.0
         self.assert_(('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.assertEquals(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.assertEquals(len(self._notify1),0)
         a.a = 10
         self.assert_(('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.assertEquals(b.a,0)
         self.assertEquals(b.b,0.0)
         b.a = 100
         b.b = 100.0
         self.assertEquals(b.a,100)
         self.assertEquals(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.assertEquals(len(self._notify1),0)
         self.assertEquals(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)
 
     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.assertEquals(len(a._notify1),0)
         a.a = 10
         self.assert_(('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)
 
     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.assertEquals(self.cb,())
         a.on_trait_change(callback0, 'a', remove=True)
 
         a.on_trait_change(callback1, 'a')
         a.a = 100
         self.assertEquals(self.cb,('a',))
         a.on_trait_change(callback1, 'a', remove=True)
 
         a.on_trait_change(callback2, 'a')
         a.a = 1000
         self.assertEquals(self.cb,('a',1000))
         a.on_trait_change(callback2, 'a', remove=True)
 
         a.on_trait_change(callback3, 'a')
         a.a = 10000
         self.assertEquals(self.cb,('a',1000,10000))
         a.on_trait_change(callback3, 'a', remove=True)
 
         self.assertEquals(len(a._trait_notifiers['a']),0)
 
 
 class TestHasTraits(TestCase):
 
     def test_trait_names(self):
         class A(HasTraits):
             i = Int
             f = Float
         a = A()
         self.assertEquals(a.trait_names(),['i','f'])
         self.assertEquals(A.class_trait_names(),['i','f'])
 
     def test_trait_metadata(self):
         class A(HasTraits):
             i = Int(config_key='MY_VALUE')
         a = A()
         self.assertEquals(a.trait_metadata('i','config_key'), 'MY_VALUE')
 
     def test_traits(self):
         class A(HasTraits):
             i = Int
             f = Float
         a = A()
         self.assertEquals(a.traits(), dict(i=A.i, f=A.f))
         self.assertEquals(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.assertEquals(a.traits(), dict(i=A.i, f=A.f, j=A.j))
         traits = a.traits(config_key='VALUE1', other_thing='VALUE2')
         self.assertEquals(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.assertEquals(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.assertEquals(a.i, 1)
         self.assertEquals(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.assertEquals(a.klass, None)
 
         a.klass = B
         self.assertEquals(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.assertEquals(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.assertEquals(a.klass, B)
         self.assertRaises(TraitError, setattr, a, 'klass', None)
         a.klass = C
         self.assertEquals(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.assertEquals(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)
         a.inst = Foo()
         self.assert_(isinstance(a.inst, Foo))
         a.inst = Bar()
         self.assert_(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)
 
     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.assertEquals(a.inst.c, 10)
 
         class B(HasTraits):
             inst = Instance(Bah, args=(10,), kw=dict(d=20))
         b = B()
         self.assertEquals(b.inst.c, 10)
         self.assertEquals(b.inst.d, 20)
 
         class C(HasTraits):
             inst = Instance(Foo)
         c = C()
         self.assert_(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.assertEquals(f.this, None)
         g = Foo()
         f.this = g
         self.assertEquals(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))
 
     def test_subclass(self):
         class Foo(HasTraits):
             t = This()
         class Bar(Foo):
             pass
         f = Foo()
         b = Bar()
         f.t = b
         b.t = f
         self.assertEquals(f.t, b)
         self.assertEquals(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.assertEquals(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.assertEquals(self.obj.value, self.coerce(value))
 
     def test_bad_values(self):
         if hasattr(self, '_bad_values'):
             for value in self._bad_values:
-                self.assertRaises(TraitError, self.assign, value)
+                try:
+                    self.assertRaises(TraitError, self.assign, value)
+                except AssertionError:
+                    assert False, value
 
     def test_default_value(self):
         if hasattr(self, '_default_value'):
             self.assertEquals(self._default_value, self.obj.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, 10L,
-                      -10L, 10.1, -10.1, '10L', '-10L', '10.1', '-10.1', u'10L',
+    _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])
 
 
 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']
 
 
 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    = [10L, -10L, 'ten', u'ten', [10], {'ten': 10},(10,), None,
+    _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    = [10L, -10L, u'10L', u'-10L', 'ten', [10], {'ten': 10},(10,), None]
+    _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,'bottles'])
+    value = Tuple(Int, Bytes, default_value=[99,b'bottles'])
 
 class TestMultiTuple(TraitTestBase):
 
     obj = MultiTupleTrait()
 
-    _default_value = (99,'bottles')
-    _good_values = [(1,'a'), (2,'b')]
-    _bad_values = ((),10, 'a', (1,'a',3), ('a',1))
+    _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'))