test_traitlets.py
908 lines
| 23.9 KiB
| text/x-python
|
PythonLexer
|
r2175 | # 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. | ||||
""" | ||||
#----------------------------------------------------------------------------- | ||||
|
r5390 | # Copyright (C) 2008-2011 The IPython Development Team | ||
|
r2175 | # | ||
# Distributed under the terms of the BSD License. The full license is in | ||||
# the file COPYING, distributed as part of this software. | ||||
#----------------------------------------------------------------------------- | ||||
#----------------------------------------------------------------------------- | ||||
# Imports | ||||
#----------------------------------------------------------------------------- | ||||
|
r6750 | import re | ||
|
r4047 | import sys | ||
|
r2175 | from unittest import TestCase | ||
|
r6270 | from nose import SkipTest | ||
|
r2175 | from IPython.utils.traitlets import ( | ||
|
r4046 | HasTraits, MetaHasTraits, TraitType, Any, CBytes, | ||
|
r5344 | Int, Long, Integer, Float, Complex, Bytes, Unicode, TraitError, | ||
|
r4047 | Undefined, Type, This, Instance, TCPAddress, List, Tuple, | ||
|
r6750 | ObjectName, DottedObjectName, CRegExp | ||
|
r2175 | ) | ||
|
r4891 | from IPython.utils import py3compat | ||
|
r5344 | from IPython.testing.decorators import skipif | ||
|
r2175 | |||
#----------------------------------------------------------------------------- | ||||
# Helper classes for testing | ||||
#----------------------------------------------------------------------------- | ||||
|
r2385 | class HasTraitsStub(HasTraits): | ||
|
r2175 | |||
|
r2385 | def _notify_trait(self, name, old, new): | ||
|
r2175 | self._notify_name = name | ||
self._notify_old = old | ||||
self._notify_new = new | ||||
#----------------------------------------------------------------------------- | ||||
# Test classes | ||||
#----------------------------------------------------------------------------- | ||||
|
r2385 | class TestTraitType(TestCase): | ||
|
r2175 | |||
|
r2177 | def test_get_undefined(self): | ||
|
r2384 | class A(HasTraits): | ||
|
r2385 | a = TraitType | ||
|
r2182 | a = A() | ||
|
r7874 | self.assertEqual(a.a, Undefined) | ||
|
r2175 | |||
def test_set(self): | ||||
|
r2385 | class A(HasTraitsStub): | ||
a = TraitType | ||||
|
r2182 | |||
a = A() | ||||
a.a = 10 | ||||
|
r7874 | self.assertEqual(a.a, 10) | ||
self.assertEqual(a._notify_name, 'a') | ||||
self.assertEqual(a._notify_old, Undefined) | ||||
self.assertEqual(a._notify_new, 10) | ||||
|
r2175 | |||
def test_validate(self): | ||||
|
r2385 | class MyTT(TraitType): | ||
|
r2175 | def validate(self, inst, value): | ||
return -1 | ||||
|
r2385 | class A(HasTraitsStub): | ||
|
r2182 | tt = MyTT | ||
|
r4872 | |||
|
r2182 | a = A() | ||
a.tt = 10 | ||||
|
r7874 | self.assertEqual(a.tt, -1) | ||
|
r2175 | |||
|
r2177 | def test_default_validate(self): | ||
|
r2385 | class MyIntTT(TraitType): | ||
|
r2177 | def validate(self, obj, value): | ||
if isinstance(value, int): | ||||
return value | ||||
self.error(obj, value) | ||||
|
r2384 | class A(HasTraits): | ||
|
r2182 | tt = MyIntTT(10) | ||
a = A() | ||||
|
r7874 | self.assertEqual(a.tt, 10) | ||
|
r2182 | |||
|
r2384 | # Defaults are validated when the HasTraits is instantiated | ||
class B(HasTraits): | ||||
|
r2182 | tt = MyIntTT('bad default') | ||
|
r2385 | self.assertRaises(TraitError, B) | ||
|
r2177 | |||
|
r2175 | def test_is_valid_for(self): | ||
|
r2385 | class MyTT(TraitType): | ||
|
r2175 | def is_valid_for(self, value): | ||
return True | ||||
|
r2384 | class A(HasTraits): | ||
|
r2182 | tt = MyTT | ||
a = A() | ||||
a.tt = 10 | ||||
|
r7874 | self.assertEqual(a.tt, 10) | ||
|
r2175 | |||
def test_value_for(self): | ||||
|
r2385 | class MyTT(TraitType): | ||
|
r2175 | def value_for(self, value): | ||
return 20 | ||||
|
r2384 | class A(HasTraits): | ||
|
r2182 | tt = MyTT | ||
a = A() | ||||
a.tt = 10 | ||||
|
r7874 | self.assertEqual(a.tt, 20) | ||
|
r2175 | |||
def test_info(self): | ||||
|
r2384 | class A(HasTraits): | ||
|
r2385 | tt = TraitType | ||
|
r2182 | a = A() | ||
|
r7874 | self.assertEqual(A.tt.info(), 'any value') | ||
|
r2175 | |||
def test_error(self): | ||||
|
r2384 | class A(HasTraits): | ||
|
r2385 | tt = TraitType | ||
|
r2182 | a = A() | ||
|
r2385 | self.assertRaises(TraitError, A.tt.error, a, 10) | ||
|
r2175 | |||
|
r3207 | 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() | ||||
|
r7874 | 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}) | ||||
|
r3207 | b = B() | ||
|
r7874 | self.assertEqual(b._trait_values, {'x': 20}) | ||
self.assertEqual(a._trait_dyn_inits.keys(), ['x']) | ||||
self.assertEqual(b.x, 20) | ||||
|
r3207 | c = C() | ||
|
r7874 | 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}) | ||||
|
r3336 | # Ensure that the base class remains unmolested when the _default | ||
# initializer gets overridden in a subclass. | ||||
a = A() | ||||
c = C() | ||||
|
r7874 | 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}) | ||||
|
r3336 | |||
|
r3207 | |||
|
r2175 | |||
|
r2384 | class TestHasTraitsMeta(TestCase): | ||
|
r2175 | |||
def test_metaclass(self): | ||||
|
r7874 | self.assertEqual(type(HasTraits), MetaHasTraits) | ||
|
r2175 | |||
|
r2384 | class A(HasTraits): | ||
|
r2175 | a = Int | ||
a = A() | ||||
|
r7874 | self.assertEqual(type(a.__class__), MetaHasTraits) | ||
self.assertEqual(a.a,0) | ||||
|
r2175 | a.a = 10 | ||
|
r7874 | self.assertEqual(a.a,10) | ||
|
r2175 | |||
|
r2384 | class B(HasTraits): | ||
|
r2175 | b = Int() | ||
b = B() | ||||
|
r7874 | self.assertEqual(b.b,0) | ||
|
r2175 | b.b = 10 | ||
|
r7874 | self.assertEqual(b.b,10) | ||
|
r2175 | |||
|
r2384 | class C(HasTraits): | ||
|
r2175 | c = Int(30) | ||
c = C() | ||||
|
r7874 | self.assertEqual(c.c,30) | ||
|
r2175 | c.c = 10 | ||
|
r7874 | self.assertEqual(c.c,10) | ||
|
r2175 | |||
|
r2183 | def test_this_class(self): | ||
|
r2384 | class A(HasTraits): | ||
|
r2183 | t = This() | ||
tt = This() | ||||
class B(A): | ||||
tt = This() | ||||
ttt = This() | ||||
|
r7874 | 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) | ||||
|
r2175 | |||
|
r2384 | class TestHasTraitsNotify(TestCase): | ||
|
r2175 | |||
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): | ||||
|
r2384 | class A(HasTraits): | ||
|
r2175 | a = Int | ||
b = Float | ||||
a = A() | ||||
|
r2384 | a.on_trait_change(self.notify1) | ||
|
r2175 | a.a = 0 | ||
|
r7874 | self.assertEqual(len(self._notify1),0) | ||
|
r2175 | a.b = 0.0 | ||
|
r7874 | self.assertEqual(len(self._notify1),0) | ||
|
r2175 | a.a = 10 | ||
|
r7876 | self.assertTrue(('a',0,10) in self._notify1) | ||
|
r2175 | a.b = 10.0 | ||
|
r7876 | self.assertTrue(('b',0.0,10.0) in self._notify1) | ||
|
r2385 | self.assertRaises(TraitError,setattr,a,'a','bad string') | ||
self.assertRaises(TraitError,setattr,a,'b','bad string') | ||||
|
r2175 | self._notify1 = [] | ||
|
r2384 | a.on_trait_change(self.notify1,remove=True) | ||
|
r2175 | a.a = 20 | ||
a.b = 20.0 | ||||
|
r7874 | self.assertEqual(len(self._notify1),0) | ||
|
r2175 | |||
def test_notify_one(self): | ||||
|
r2384 | class A(HasTraits): | ||
|
r2175 | a = Int | ||
b = Float | ||||
a = A() | ||||
|
r2384 | a.on_trait_change(self.notify1, 'a') | ||
|
r2175 | a.a = 0 | ||
|
r7874 | self.assertEqual(len(self._notify1),0) | ||
|
r2175 | a.a = 10 | ||
|
r7876 | self.assertTrue(('a',0,10) in self._notify1) | ||
|
r2385 | self.assertRaises(TraitError,setattr,a,'a','bad string') | ||
|
r2175 | |||
def test_subclass(self): | ||||
|
r2384 | class A(HasTraits): | ||
|
r2175 | a = Int | ||
class B(A): | ||||
b = Float | ||||
b = B() | ||||
|
r7874 | self.assertEqual(b.a,0) | ||
self.assertEqual(b.b,0.0) | ||||
|
r2175 | b.a = 100 | ||
b.b = 100.0 | ||||
|
r7874 | self.assertEqual(b.a,100) | ||
self.assertEqual(b.b,100.0) | ||||
|
r2175 | |||
def test_notify_subclass(self): | ||||
|
r2384 | class A(HasTraits): | ||
|
r2175 | a = Int | ||
class B(A): | ||||
b = Float | ||||
b = B() | ||||
|
r2384 | b.on_trait_change(self.notify1, 'a') | ||
b.on_trait_change(self.notify2, 'b') | ||||
|
r2175 | b.a = 0 | ||
b.b = 0.0 | ||||
|
r7874 | self.assertEqual(len(self._notify1),0) | ||
self.assertEqual(len(self._notify2),0) | ||||
|
r2175 | b.a = 10 | ||
b.b = 10.0 | ||||
|
r7876 | self.assertTrue(('a',0,10) in self._notify1) | ||
self.assertTrue(('b',0.0,10.0) in self._notify2) | ||||
|
r2175 | |||
def test_static_notify(self): | ||||
|
r2384 | class A(HasTraits): | ||
|
r2175 | a = Int | ||
_notify1 = [] | ||||
def _a_changed(self, name, old, new): | ||||
self._notify1.append((name, old, new)) | ||||
a = A() | ||||
a.a = 0 | ||||
|
r2182 | # This is broken!!! | ||
|
r7874 | self.assertEqual(len(a._notify1),0) | ||
|
r2175 | a.a = 10 | ||
|
r7876 | self.assertTrue(('a',0,10) in a._notify1) | ||
|
r2175 | |||
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 | ||||
|
r7876 | self.assertTrue(('a',0,10) in b._notify1) | ||
self.assertTrue(('b',0.0,10.0) in b._notify2) | ||||
|
r2175 | |||
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) | ||||
|
r2384 | class A(HasTraits): | ||
|
r2175 | a = Int | ||
a = A() | ||||
|
r2384 | a.on_trait_change(callback0, 'a') | ||
|
r2175 | a.a = 10 | ||
|
r7874 | self.assertEqual(self.cb,()) | ||
|
r2384 | a.on_trait_change(callback0, 'a', remove=True) | ||
|
r2175 | |||
|
r2384 | a.on_trait_change(callback1, 'a') | ||
|
r2175 | a.a = 100 | ||
|
r7874 | self.assertEqual(self.cb,('a',)) | ||
|
r2384 | a.on_trait_change(callback1, 'a', remove=True) | ||
|
r2175 | |||
|
r2384 | a.on_trait_change(callback2, 'a') | ||
|
r2175 | a.a = 1000 | ||
|
r7874 | self.assertEqual(self.cb,('a',1000)) | ||
|
r2384 | a.on_trait_change(callback2, 'a', remove=True) | ||
|
r2175 | |||
|
r2384 | a.on_trait_change(callback3, 'a') | ||
|
r2175 | a.a = 10000 | ||
|
r7874 | self.assertEqual(self.cb,('a',1000,10000)) | ||
|
r2384 | a.on_trait_change(callback3, 'a', remove=True) | ||
|
r2175 | |||
|
r7874 | self.assertEqual(len(a._trait_notifiers['a']),0) | ||
|
r2175 | |||
|
r2384 | class TestHasTraits(TestCase): | ||
|
r2179 | |||
|
r2384 | def test_trait_names(self): | ||
class A(HasTraits): | ||||
|
r2184 | i = Int | ||
f = Float | ||||
a = A() | ||||
|
r7874 | self.assertEqual(sorted(a.trait_names()),['f','i']) | ||
self.assertEqual(sorted(A.class_trait_names()),['f','i']) | ||||
|
r2184 | |||
|
r2384 | def test_trait_metadata(self): | ||
class A(HasTraits): | ||||
|
r2184 | i = Int(config_key='MY_VALUE') | ||
|
r2179 | a = A() | ||
|
r7874 | self.assertEqual(a.trait_metadata('i','config_key'), 'MY_VALUE') | ||
|
r2179 | |||
|
r2384 | def test_traits(self): | ||
class A(HasTraits): | ||||
|
r2184 | i = Int | ||
f = Float | ||||
a = A() | ||||
|
r7874 | self.assertEqual(a.traits(), dict(i=A.i, f=A.f)) | ||
self.assertEqual(A.class_traits(), dict(i=A.i, f=A.f)) | ||||
|
r2184 | |||
|
r2384 | def test_traits_metadata(self): | ||
class A(HasTraits): | ||||
|
r2184 | i = Int(config_key='VALUE1', other_thing='VALUE2') | ||
f = Float(config_key='VALUE3', other_thing='VALUE2') | ||||
|
r2245 | j = Int(0) | ||
|
r2184 | a = A() | ||
|
r7874 | self.assertEqual(a.traits(), dict(i=A.i, f=A.f, j=A.j)) | ||
|
r2385 | traits = a.traits(config_key='VALUE1', other_thing='VALUE2') | ||
|
r7874 | self.assertEqual(traits, dict(i=A.i)) | ||
|
r2245 | |||
|
r4872 | # This passes, but it shouldn't because I am replicating a bug in | ||
|
r2245 | # traits. | ||
|
r2385 | traits = a.traits(config_key=lambda v: True) | ||
|
r7874 | self.assertEqual(traits, dict(i=A.i, f=A.f, j=A.j)) | ||
|
r2245 | |||
|
r2740 | def test_init(self): | ||
class A(HasTraits): | ||||
i = Int() | ||||
x = Float() | ||||
a = A(i=1, x=10.0) | ||||
|
r7874 | self.assertEqual(a.i, 1) | ||
self.assertEqual(a.x, 10.0) | ||||
|
r2175 | |||
#----------------------------------------------------------------------------- | ||||
|
r2385 | # Tests for specific trait types | ||
|
r2175 | #----------------------------------------------------------------------------- | ||
|
r2177 | |||
class TestType(TestCase): | ||||
def test_default(self): | ||||
class B(object): pass | ||||
|
r2384 | class A(HasTraits): | ||
|
r2177 | klass = Type | ||
a = A() | ||||
|
r7874 | self.assertEqual(a.klass, None) | ||
|
r2229 | |||
|
r2177 | a.klass = B | ||
|
r7874 | self.assertEqual(a.klass, B) | ||
|
r2385 | self.assertRaises(TraitError, setattr, a, 'klass', 10) | ||
|
r2177 | |||
def test_value(self): | ||||
class B(object): pass | ||||
class C(object): pass | ||||
|
r2384 | class A(HasTraits): | ||
|
r2177 | klass = Type(B) | ||
|
r4872 | |||
|
r2177 | a = A() | ||
|
r7874 | self.assertEqual(a.klass, B) | ||
|
r2385 | self.assertRaises(TraitError, setattr, a, 'klass', C) | ||
self.assertRaises(TraitError, setattr, a, 'klass', object) | ||||
|
r2177 | a.klass = B | ||
def test_allow_none(self): | ||||
class B(object): pass | ||||
class C(B): pass | ||||
|
r2384 | class A(HasTraits): | ||
|
r2177 | klass = Type(B, allow_none=False) | ||
a = A() | ||||
|
r7874 | self.assertEqual(a.klass, B) | ||
|
r2385 | self.assertRaises(TraitError, setattr, a, 'klass', None) | ||
|
r2177 | a.klass = C | ||
|
r7874 | self.assertEqual(a.klass, C) | ||
|
r2177 | |||
|
r2182 | def test_validate_klass(self): | ||
|
r2384 | class A(HasTraits): | ||
|
r2229 | klass = Type('no strings allowed') | ||
self.assertRaises(ImportError, A) | ||||
|
r2182 | |||
|
r2384 | class A(HasTraits): | ||
|
r2229 | klass = Type('rub.adub.Duck') | ||
self.assertRaises(ImportError, A) | ||||
|
r2182 | |||
def test_validate_default(self): | ||||
class B(object): pass | ||||
|
r2384 | class A(HasTraits): | ||
|
r2182 | klass = Type('bad default', B) | ||
|
r2229 | self.assertRaises(ImportError, A) | ||
|
r2182 | |||
|
r2384 | class C(HasTraits): | ||
|
r2182 | klass = Type(None, B, allow_none=False) | ||
|
r2385 | self.assertRaises(TraitError, C) | ||
|
r2177 | |||
|
r2229 | def test_str_klass(self): | ||
|
r2384 | class A(HasTraits): | ||
|
r2229 | klass = Type('IPython.utils.ipstruct.Struct') | ||
from IPython.utils.ipstruct import Struct | ||||
a = A() | ||||
a.klass = Struct | ||||
|
r7874 | self.assertEqual(a.klass, Struct) | ||
|
r4872 | |||
|
r2385 | self.assertRaises(TraitError, setattr, a, 'klass', 10) | ||
|
r2229 | |||
|
r2177 | class TestInstance(TestCase): | ||
def test_basic(self): | ||||
class Foo(object): pass | ||||
class Bar(Foo): pass | ||||
class Bah(object): pass | ||||
|
r4872 | |||
|
r2384 | class A(HasTraits): | ||
|
r2177 | inst = Instance(Foo) | ||
a = A() | ||||
|
r7876 | self.assertTrue(a.inst is None) | ||
|
r2177 | a.inst = Foo() | ||
|
r7876 | self.assertTrue(isinstance(a.inst, Foo)) | ||
|
r2177 | a.inst = Bar() | ||
|
r7876 | self.assertTrue(isinstance(a.inst, Foo)) | ||
|
r2385 | self.assertRaises(TraitError, setattr, a, 'inst', Foo) | ||
self.assertRaises(TraitError, setattr, a, 'inst', Bar) | ||||
self.assertRaises(TraitError, setattr, a, 'inst', Bah()) | ||||
|
r2177 | |||
def test_unique_default_value(self): | ||||
|
r2229 | class Foo(object): pass | ||
|
r2384 | class A(HasTraits): | ||
|
r2182 | inst = Instance(Foo,(),{}) | ||
|
r2177 | |||
a = A() | ||||
b = A() | ||||
|
r7876 | self.assertTrue(a.inst is not b.inst) | ||
|
r2177 | |||
def test_args_kw(self): | ||||
class Foo(object): | ||||
def __init__(self, c): self.c = c | ||||
|
r2182 | class Bar(object): pass | ||
class Bah(object): | ||||
def __init__(self, c, d): | ||||
self.c = c; self.d = d | ||||
|
r2177 | |||
|
r2384 | class A(HasTraits): | ||
|
r2182 | inst = Instance(Foo, (10,)) | ||
|
r2177 | a = A() | ||
|
r7874 | self.assertEqual(a.inst.c, 10) | ||
|
r2177 | |||
|
r2384 | class B(HasTraits): | ||
|
r2182 | inst = Instance(Bah, args=(10,), kw=dict(d=20)) | ||
|
r2177 | b = B() | ||
|
r7874 | self.assertEqual(b.inst.c, 10) | ||
self.assertEqual(b.inst.d, 20) | ||||
|
r2177 | |||
|
r2384 | class C(HasTraits): | ||
|
r2182 | inst = Instance(Foo) | ||
c = C() | ||||
|
r7876 | self.assertTrue(c.inst is None) | ||
|
r2182 | |||
def test_bad_default(self): | ||||
|
r2177 | class Foo(object): pass | ||
|
r2384 | class A(HasTraits): | ||
|
r2182 | inst = Instance(Foo, allow_none=False) | ||
|
r4872 | |||
|
r2385 | self.assertRaises(TraitError, A) | ||
|
r2182 | |||
def test_instance(self): | ||||
class Foo(object): pass | ||||
def inner(): | ||||
|
r2384 | class A(HasTraits): | ||
|
r2182 | inst = Instance(Foo()) | ||
|
r4872 | |||
|
r2385 | self.assertRaises(TraitError, inner) | ||
|
r2177 | |||
|
r2180 | |||
class TestThis(TestCase): | ||||
def test_this_class(self): | ||||
|
r2384 | class Foo(HasTraits): | ||
|
r2180 | this = This | ||
f = Foo() | ||||
|
r7874 | self.assertEqual(f.this, None) | ||
|
r2180 | g = Foo() | ||
f.this = g | ||||
|
r7874 | self.assertEqual(f.this, g) | ||
|
r2385 | self.assertRaises(TraitError, setattr, f, 'this', 10) | ||
|
r2180 | |||
def test_this_inst(self): | ||||
|
r2384 | class Foo(HasTraits): | ||
|
r2180 | this = This() | ||
|
r4872 | |||
|
r2180 | f = Foo() | ||
f.this = Foo() | ||||
|
r7876 | self.assertTrue(isinstance(f.this, Foo)) | ||
|
r2180 | |||
|
r2183 | def test_subclass(self): | ||
|
r2384 | class Foo(HasTraits): | ||
|
r2183 | t = This() | ||
class Bar(Foo): | ||||
pass | ||||
f = Foo() | ||||
b = Bar() | ||||
f.t = b | ||||
b.t = f | ||||
|
r7874 | self.assertEqual(f.t, b) | ||
self.assertEqual(b.t, f) | ||||
|
r2183 | |||
def test_subclass_override(self): | ||||
|
r2384 | class Foo(HasTraits): | ||
|
r2183 | t = This() | ||
class Bar(Foo): | ||||
t = This() | ||||
f = Foo() | ||||
b = Bar() | ||||
f.t = b | ||||
|
r7874 | self.assertEqual(f.t, b) | ||
|
r2385 | self.assertRaises(TraitError, setattr, b, 't', f) | ||
|
r2180 | |||
|
r2385 | class TraitTestBase(TestCase): | ||
"""A best testing class for basic trait types.""" | ||||
|
r2175 | |||
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) | ||||
|
r7874 | self.assertEqual(self.obj.value, self.coerce(value)) | ||
|
r2175 | |||
def test_bad_values(self): | ||||
if hasattr(self, '_bad_values'): | ||||
for value in self._bad_values: | ||||
|
r4891 | try: | ||
self.assertRaises(TraitError, self.assign, value) | ||||
except AssertionError: | ||||
assert False, value | ||||
|
r2175 | |||
def test_default_value(self): | ||||
if hasattr(self, '_default_value'): | ||||
|
r7874 | self.assertEqual(self._default_value, self.obj.value) | ||
|
r2175 | |||
|
r5344 | def tearDown(self): | ||
# restore default value after tests, if set | ||||
if hasattr(self, '_default_value'): | ||||
self.obj.value = self._default_value | ||||
|
r2175 | |||
|
r2385 | class AnyTrait(HasTraits): | ||
|
r2175 | |||
value = Any | ||||
|
r2385 | class AnyTraitTest(TraitTestBase): | ||
|
r2175 | |||
|
r2385 | obj = AnyTrait() | ||
|
r2175 | |||
_default_value = None | ||||
_good_values = [10.0, 'ten', u'ten', [10], {'ten': 10},(10,), None, 1j] | ||||
_bad_values = [] | ||||
|
r2385 | class IntTrait(HasTraits): | ||
|
r2175 | |||
value = Int(99) | ||||
|
r2385 | class TestInt(TraitTestBase): | ||
|
r2175 | |||
|
r2385 | obj = IntTrait() | ||
|
r2175 | _default_value = 99 | ||
_good_values = [10, -10] | ||||
|
r4891 | _bad_values = ['ten', u'ten', [10], {'ten': 10},(10,), None, 1j, | ||
10.1, -10.1, '10L', '-10L', '10.1', '-10.1', u'10L', | ||||
|
r2175 | u'-10L', u'10.1', u'-10.1', '10', '-10', u'10', u'-10'] | ||
|
r4891 | if not py3compat.PY3: | ||
|
r5344 | _bad_values.extend([10L, -10L, 10*sys.maxint, -10*sys.maxint]) | ||
|
r2175 | |||
|
r2385 | class LongTrait(HasTraits): | ||
|
r2175 | |||
value = Long(99L) | ||||
|
r2385 | class TestLong(TraitTestBase): | ||
|
r2175 | |||
|
r2385 | obj = LongTrait() | ||
|
r2175 | |||
_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'] | ||||
|
r5344 | 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 | ||||
|
r7874 | self.assertEqual(type(self.obj.value), long) | ||
|
r5344 | |||
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 | ||||
|
r7874 | self.assertEqual(type(self.obj.value), int) | ||
|
r2175 | |||
|
r2385 | class FloatTrait(HasTraits): | ||
|
r2175 | |||
value = Float(99.0) | ||||
|
r2385 | class TestFloat(TraitTestBase): | ||
|
r2175 | |||
|
r2385 | obj = FloatTrait() | ||
|
r2175 | |||
_default_value = 99.0 | ||||
_good_values = [10, -10, 10.1, -10.1] | ||||
|
r4891 | _bad_values = ['ten', u'ten', [10], {'ten': 10},(10,), None, | ||
|
r2175 | 1j, '10', '-10', '10L', '-10L', '10.1', '-10.1', u'10', | ||
u'-10', u'10L', u'-10L', u'10.1', u'-10.1'] | ||||
|
r4891 | if not py3compat.PY3: | ||
_bad_values.extend([10L, -10L]) | ||||
|
r2175 | |||
|
r2385 | class ComplexTrait(HasTraits): | ||
|
r2175 | |||
value = Complex(99.0-99.0j) | ||||
|
r2385 | class TestComplex(TraitTestBase): | ||
|
r2175 | |||
|
r2385 | obj = ComplexTrait() | ||
|
r2175 | |||
_default_value = 99.0-99.0j | ||||
|
r4872 | _good_values = [10, -10, 10.1, -10.1, 10j, 10+10j, 10-10j, | ||
|
r2175 | 10.1j, 10.1+10.1j, 10.1-10.1j] | ||
|
r4891 | _bad_values = [u'10L', u'-10L', 'ten', [10], {'ten': 10},(10,), None] | ||
if not py3compat.PY3: | ||||
_bad_values.extend([10L, -10L]) | ||||
|
r2175 | |||
|
r4046 | class BytesTrait(HasTraits): | ||
|
r2175 | |||
|
r4110 | value = Bytes(b'string') | ||
|
r2175 | |||
|
r4046 | class TestBytes(TraitTestBase): | ||
|
r2175 | |||
|
r4046 | obj = BytesTrait() | ||
|
r2175 | |||
|
r4110 | _default_value = b'string' | ||
_good_values = [b'10', b'-10', b'10L', | ||||
b'-10L', b'10.1', b'-10.1', b'string'] | ||||
|
r2175 | _bad_values = [10, -10, 10L, -10L, 10.1, -10.1, 1j, [10], | ||
['ten'],{'ten': 10},(10,), None, u'string'] | ||||
|
r2385 | class UnicodeTrait(HasTraits): | ||
|
r2175 | |||
value = Unicode(u'unicode') | ||||
|
r2385 | class TestUnicode(TraitTestBase): | ||
|
r2175 | |||
|
r2385 | obj = UnicodeTrait() | ||
|
r2175 | |||
_default_value = u'unicode' | ||||
|
r4872 | _good_values = ['10', '-10', '10L', '-10L', '10.1', | ||
|
r4047 | '-10.1', '', u'', 'string', u'string', u"€"] | ||
|
r2175 | _bad_values = [10, -10, 10L, -10L, 10.1, -10.1, 1j, | ||
[10], ['ten'], [u'ten'], {'ten': 10},(10,), None] | ||||
|
r2742 | |||
|
r4047 | class ObjectNameTrait(HasTraits): | ||
value = ObjectName("abc") | ||||
|
r4872 | |||
|
r4047 | class TestObjectName(TraitTestBase): | ||
obj = ObjectNameTrait() | ||||
|
r4872 | |||
|
r4047 | _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() | ||||
|
r4872 | |||
|
r4047 | _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.þ") | ||||
|
r2742 | 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)] | ||||
|
r3870 | |||
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') | ||||
|
r4046 | t = Tuple(Int, CBytes, default_value=(1,5)) | ||
|
r3870 | |||
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') | ||||
|
r4046 | t = Tuple(Int, CBytes, default_value=(1,5)) | ||
|
r3870 | |||
class MultiTupleTrait(HasTraits): | ||||
|
r4891 | value = Tuple(Int, Bytes, default_value=[99,b'bottles']) | ||
|
r3870 | |||
class TestMultiTuple(TraitTestBase): | ||||
obj = MultiTupleTrait() | ||||
|
r4891 | _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')) | ||||
|
r6750 | |||
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, ()] | ||||