def append(self, element):
if self.feature_no:
assert self.feature_no == element.feature_no()
else:
self.feature_no = element.feature_no()
UserList.append(self, element)
self.init_precomputed()
def append(self, light):
if self.enforce_limit:
_constrain_lights(len(self) + 1)
light.light_no = lightno(len(self))
else:
light.light_no = vlightno(len(self))
UserList.append(self, light)
class MD_Schema(UserDict):
def __init__(self, spec):
self.data = {}
self.fields = UserList()
self.field_order = UserList()
for item in spec:
field = MD_Schema_Field(item)
self.data[field.name] = field
self.fields.append(field)
self.field_order.append(field.name)
self.quoted_schema = self._get_quoted_schema()
def get_index(self, field):
return self.field_order.index(field.name)
def _get_quoted_schema(self):
return ','.join(map(lambda x: "'%s'" % x, self.field_order))
def obj_to_data_values(self, obj):
row_value_list = []
for field in self.fields:
val = obj[self.get_index(field)]
if type(val) == type(''):
# row_value_list.append("'{}'".format(val.replace ("'", "%27")))
row_value_list.append("'{}'".format(val.replace("'", "\'\'")))
if type(val) == type(1) or type(val) == type(1.5):
row_value_list.append(str(val))
# quoted_values = ','.join(map (lambda x:x.replace ("'", "''"), row_value_list))
quoted_values = ','.join(row_value_list)
return quoted_values
def testSequenceArrayConversionTypeChecking(self):
"""Test error handling for sequence conversion to array arguments."""
from Python.Test import ArrayConversionTest
from Python.Test import Spam
from UserList import UserList
# This should work, because null / None is a valid value in an
# array of reference types.
items = UserList()
for i in range(10):
items.append(Spam(str(i)))
items[1] = None
result = ArrayConversionTest.EchoRange(items)
self.failUnless(result[0].__class__ == Spam)
self.failUnless(result[1] == None)
self.failUnless(len(result) == 10)
def test(items=items):
items[1] = 1
result = ArrayConversionTest.EchoRange(items)
self.failUnlessRaises(TypeError, test)
def test(items=items):
items[1] = "spam"
result = ArrayConversionTest.EchoRange(items)
self.failUnlessRaises(TypeError, test)
def append(self, element):
if self.feature_no:
assert self.feature_no == element.feature_no()
else:
self.feature_no = element.feature_no()
UserList.append(self, element)
self.init_precomputed()
def testSequenceArrayConversionTypeChecking(self):
"""Test error handling for sequence conversion to array arguments."""
from Python.Test import ArrayConversionTest
from Python.Test import Spam
from UserList import UserList
# This should work, because null / None is a valid value in an
# array of reference types.
items = UserList()
for i in range(10):
items.append(Spam(str(i)))
items[1] = None
result = ArrayConversionTest.EchoRange(items)
self.failUnless(result[0].__class__ == Spam)
self.failUnless(result[1] == None)
self.failUnless(len(result) == 10)
def test(items=items):
items[1] = 1
result = ArrayConversionTest.EchoRange(items)
self.failUnlessRaises(TypeError, test)
def test(items=items):
items[1] = "spam"
result = ArrayConversionTest.EchoRange(items)
self.failUnlessRaises(TypeError, test)
def append(self, *others):
for other in others:
if not other:
continue
if isinstance(other, Frag) or \
type(other) == type(()) or \
type(other) == type([]):
List.extend(self, other)
else:
List.append(self, other)
def append(self, *others):
for other in others:
if not other:
continue
if isinstance(other, Frag) or \
type(other) == type(()) or \
type(other) == type([]):
List.extend(self, other)
else:
List.append(self, other)
def recursion():
from UserList import UserList
a = UserList(); a.append(a)
b = UserList(); b.append(b)
def check(s, a=a, b=b):
if verbose:
print "check", s
try:
if not eval(s):
raise TestFailed, s + " was false but expected to be true"
except RuntimeError, msg:
raise TestFailed, str(msg)
def recursion():
from UserList import UserList
a = UserList(); a.append(a)
b = UserList(); b.append(b)
def check(s, a=a, b=b):
if verbose:
print "check", s
try:
if not eval(s):
raise TestFailed, s + " was false but expected to be true"
except RuntimeError, msg:
raise TestFailed, str(msg)
def test_mutation(self):
d = UserList(range(n))
it = reversed(d)
it.next()
it.next()
self.assertEqual(len(it), n - 2)
d.append(n)
self.assertEqual(len(it), n - 2) # ignore append
d[1:] = []
self.assertEqual(len(it), 0)
self.assertEqual(list(it), []) # confirm invariant
d.extend(xrange(20))
self.assertEqual(len(it), 0)
def test_mutation(self):
d = UserList(range(n))
it = iter(d)
it.next()
it.next()
self.assertEqual(len(it), n - 2)
d.append(n)
self.assertEqual(len(it), n - 1) # grow with append
d[1:] = []
self.assertEqual(len(it), 0)
self.assertEqual(list(it), [])
d.extend(xrange(20))
self.assertEqual(len(it), 0)
def testSequenceArrayConversion(self):
"""Test conversion of sequence-like objects to array arguments."""
from Python.Test import ArrayConversionTest
from Python.Test import Spam
from UserList import UserList
items = UserList()
for i in range(10):
items.append(Spam(str(i)))
result = ArrayConversionTest.EchoRange(items)
self.failUnless(result[0].__class__ == Spam)
self.failUnless(len(result) == 10)
def test_cmp_cyclic(self):
if not self.sane_lookup:
skip("underlying Python implementation has insane dict lookup")
a = []; a.append(a)
b = []; b.append(b)
from UserList import UserList
c = UserList(); c.append(c)
raises(RuntimeError, cmp, a, b)
raises(RuntimeError, cmp, b, c)
raises(RuntimeError, cmp, c, a)
raises(RuntimeError, cmp, a, c)
# okay, now break the cycles
a.pop(); b.pop(); c.pop()
def testSequenceArrayConversion(self):
"""Test conversion of sequence-like objects to array arguments."""
from Python.Test import ArrayConversionTest
from Python.Test import Spam
from UserList import UserList
items = UserList()
for i in range(10):
items.append(Spam(str(i)))
result = ArrayConversionTest.EchoRange(items)
self.failUnless(result[0].__class__ == Spam)
self.failUnless(len(result) == 10)
def test_cmp_cyclic(self):
if not self.sane_lookup:
skip("underlying Python implementation has insane dict lookup")
a = []; a.append(a)
b = []; b.append(b)
from UserList import UserList
c = UserList(); c.append(c)
raises(RuntimeError, cmp, a, b)
raises(RuntimeError, cmp, b, c)
raises(RuntimeError, cmp, c, a)
raises(RuntimeError, cmp, a, c)
# okay, now break the cycles
a.pop(); b.pop(); c.pop()
def test_mutation(self):
d = UserList(range(n))
it = reversed(d)
it.next()
it.next()
self.assertEqual(len(it), n-2)
d.append(n)
self.assertEqual(len(it), n-2) # ignore append
d[1:] = []
self.assertEqual(len(it), 0)
self.assertEqual(list(it), []) # confirm invariant
d.extend(xrange(20))
self.assertEqual(len(it), 0)
def test_mutation(self):
d = UserList(range(n))
it = iter(d)
it.next()
it.next()
self.assertEqual(len(it), n-2)
d.append(n)
self.assertEqual(len(it), n-1) # grow with append
d[1:] = []
self.assertEqual(len(it), 0)
self.assertEqual(list(it), [])
d.extend(xrange(20))
self.assertEqual(len(it), 0)
def test_recursion(self):
# Check that comparison for recursive objects fails gracefully
from UserList import UserList
a = UserList()
b = UserList()
a.append(b)
b.append(a)
self.assertRaises(RuntimeError, operator.eq, a, b)
self.assertRaises(RuntimeError, operator.ne, a, b)
self.assertRaises(RuntimeError, operator.lt, a, b)
self.assertRaises(RuntimeError, operator.le, a, b)
self.assertRaises(RuntimeError, operator.gt, a, b)
self.assertRaises(RuntimeError, operator.ge, a, b)
b.append(17)
# Even recursive lists of different lengths are different,
# but they cannot be ordered
self.assert_(not (a == b))
self.assert_(a != b)
self.assertRaises(RuntimeError, operator.lt, a, b)
self.assertRaises(RuntimeError, operator.le, a, b)
self.assertRaises(RuntimeError, operator.gt, a, b)
self.assertRaises(RuntimeError, operator.ge, a, b)
a.append(17)
self.assertRaises(RuntimeError, operator.eq, a, b)
self.assertRaises(RuntimeError, operator.ne, a, b)
a.insert(0, 11)
b.insert(0, 12)
self.assert_(not (a == b))
self.assert_(a != b)
self.assert_(a < b)
def test_recursion(self):
# Check that comparison for recursive objects fails gracefully
from UserList import UserList
a = UserList()
b = UserList()
a.append(b)
b.append(a)
self.assertRaises(RuntimeError, operator.eq, a, b)
self.assertRaises(RuntimeError, operator.ne, a, b)
self.assertRaises(RuntimeError, operator.lt, a, b)
self.assertRaises(RuntimeError, operator.le, a, b)
self.assertRaises(RuntimeError, operator.gt, a, b)
self.assertRaises(RuntimeError, operator.ge, a, b)
b.append(17)
# Even recursive lists of different lengths are different,
# but they cannot be ordered
self.assert_(not (a == b))
self.assert_(a != b)
self.assertRaises(RuntimeError, operator.lt, a, b)
self.assertRaises(RuntimeError, operator.le, a, b)
self.assertRaises(RuntimeError, operator.gt, a, b)
self.assertRaises(RuntimeError, operator.ge, a, b)
a.append(17)
self.assertRaises(RuntimeError, operator.eq, a, b)
self.assertRaises(RuntimeError, operator.ne, a, b)
a.insert(0, 11)
b.insert(0, 12)
self.assert_(not (a == b))
self.assert_(a != b)
self.assert_(a < b)
def test_mutation_seqiter_reversed(self):
from UserList import UserList
n = 5
d = UserList(range(n))
it = reversed(d)
it.next()
it.next()
assert len(it) == n-2
d.append(n)
assert len(it) == n-2 # ignore append
d[1:] = []
assert len(it) == 0
assert list(it) == []
d.extend(xrange(20))
assert len(it) == 0
def test_mutation_seqiter(self):
from UserList import UserList
n = 5
d = UserList(range(n))
it = iter(d)
it.next()
it.next()
assert len(it) == n-2
d.append(n)
assert len(it) == n-1 # grow with append
d[1:] = []
assert len(it) == 0
assert list(it) == []
d.extend(xrange(20))
assert len(it) == 0
def test_mutation_seqiter_reversed(self):
from UserList import UserList
n = 5
d = UserList(range(n))
it = reversed(d)
it.next()
it.next()
assert len(it) == n-2
d.append(n)
assert len(it) == n-2 # ignore append
d[1:] = []
assert len(it) == 0
assert list(it) == []
d.extend(xrange(20))
assert len(it) == 0
def test_mutation_seqiter(self):
from UserList import UserList
n = 5
d = UserList(range(n))
it = iter(d)
it.next()
it.next()
assert len(it) == n-2
d.append(n)
assert len(it) == n-1 # grow with append
d[1:] = []
assert len(it) == 0
assert list(it) == []
d.extend(xrange(20))
assert len(it) == 0
def append (self, item):
"""L.append (...) -> None
Appends a ListItem to the end of the ListItemCollection
Raises a TypeError, if the passed argument does not inherit
from the ListItem class.
"""
if not isinstance (item, ListItem):
raise TypeError ("item must inherit from ListItem")
UserList.append (self, item)
self._length += 1
if item.collection != self:
item.collection = self
if self.list_changed:
self.list_changed (self)
def register():
userName = input("请输入用户名：")
password = input("请输入密码：")
C_password = input("请在此输入密码：")
userList = UserList()
if len(userName) == 0 or len(password) == 0 or password != C_password:
print("注册失败")
else:
newUser = User(userName, password)
searchUser = userList.getUserByUserName(newUser.userName)
if searchUser:
print("用户名存在")
else:
userList.append(newUser)
print("注册成功，去登录吧")
print(newUser)
def append(self, item):
"""L.append (...) -> None
Appends a ListItem to the end of the ListItemCollection
Raises a TypeError, if the passed argument does not inherit
from the ListItem class.
"""
if not isinstance(item, ListItem):
raise TypeError("item must inherit from ListItem")
UserList.append(self, item)
self._length += 1
if item.collection != self:
item.collection = self
if self.list_changed:
self.list_changed(self)
def test_cmp(self):
self.assertEqual(cmp(-1, 1), -1)
self.assertEqual(cmp(1, -1), 1)
self.assertEqual(cmp(1, 1), 0)
# verify that circular objects are handled
a = []; a.append(a)
b = []; b.append(b)
from UserList import UserList
c = UserList(); c.append(c)
self.assertEqual(cmp(a, b), 0)
self.assertEqual(cmp(b, c), 0)
self.assertEqual(cmp(c, a), 0)
self.assertEqual(cmp(a, c), 0)
# okay, now break the cycles
a.pop(); b.pop(); c.pop()
self.assertRaises(TypeError, cmp)
def test_cmp(self):
self.assertEqual(cmp(-1, 1), -1)
self.assertEqual(cmp(1, -1), 1)
self.assertEqual(cmp(1, 1), 0)
# verify that circular objects are not handled
a = []; a.append(a)
b = []; b.append(b)
from UserList import UserList
c = UserList(); c.append(c)
self.assertRaises(RuntimeError, cmp, a, b)
self.assertRaises(RuntimeError, cmp, b, c)
self.assertRaises(RuntimeError, cmp, c, a)
self.assertRaises(RuntimeError, cmp, a, c)
# okay, now break the cycles
a.pop(); b.pop(); c.pop()
self.assertRaises(TypeError, cmp)
def testSequenceNestedArrayConversion(self):
"""Test conversion of sequences to array-of-array arguments."""
from Python.Test import ArrayConversionTest
from Python.Test import Spam
from UserList import UserList
items = UserList()
for i in range(10):
subs = UserList()
for n in range(10):
subs.append(Spam(str(i)))
items.append(subs)
result = ArrayConversionTest.EchoRangeAA(items)
self.failUnless(len(result) == 10)
self.failUnless(len(result[0]) == 10)
self.failUnless(result[0][0].__class__ == Spam)
def testSequenceNestedArrayConversion(self):
"""Test conversion of sequences to array-of-array arguments."""
from Python.Test import ArrayConversionTest
from Python.Test import Spam
from UserList import UserList
items = UserList()
for i in range(10):
subs = UserList()
for n in range(10):
subs.append(Spam(str(i)))
items.append(subs)
result = ArrayConversionTest.EchoRangeAA(items)
self.failUnless(len(result) == 10)
self.failUnless(len(result[0]) == 10)
self.failUnless(result[0][0].__class__ == Spam)
def test_cmp_cyclic(self):
if not self.sane_lookup:
skip("underlying Python implementation has insane dict lookup")
if not self.safe_runtimerror:
skip("underlying Python may raise random exceptions on stack ovf")
a = []
a.append(a)
b = []
b.append(b)
from UserList import UserList
c = UserList()
c.append(c)
raises(RuntimeError, cmp, a, b)
raises(RuntimeError, cmp, b, c)
raises(RuntimeError, cmp, c, a)
raises(RuntimeError, cmp, a, c)
# okay, now break the cycles
a.pop()
b.pop()
c.pop()
def test_cmp_cyclic(self):
if not self.sane_lookup:
skip("underlying Python implementation has insane dict lookup")
if not self.safe_runtimerror:
skip("underlying Python may raise random exceptions on stack ovf")
a = []
a.append(a)
b = []
b.append(b)
from UserList import UserList
c = UserList()
c.append(c)
raises(RuntimeError, cmp, a, b)
raises(RuntimeError, cmp, b, c)
raises(RuntimeError, cmp, c, a)
raises(RuntimeError, cmp, a, c)
# okay, now break the cycles
a.pop()
b.pop()
c.pop()
def simple_search(self, query, max_length=MAX_RESULT_LENGTH, **kwargs):
"""
Smart searchs query in books (in title and authors).
Supports args: query, tag, lang, max_length.
"""
query_ex = dict(kwargs)
query_ex['title'] = query
query_ex['author'] = query
# search in title and in author
books = UserList(self.__book_search(max_length, **query_ex))
if len(books) < max_length:
# search only in title
del query_ex['author']
books_a = self.__book_search(max_length, **query_ex)
books_id_set = set([b.id for b in books])
# merge results
added_book_num = len(books)
for book in books_a:
if not book.id in books_id_set:
books.append(book)
added_book_num += 1
if added_book_num == max_length:
break
del query_ex['title']
if len(books) < MIN_LEN_RESULT:
query_ex['author'] = query
authors = UserList(self.__author_search(1, **query_ex))
if authors:
# TODO add filtering by language and tag here
authors_books = authors[0].book_set.all()
books.extend(authors_books)
del query_ex['author']
query_ex['query'] = query
books.suggestion = self.__get_suggetions(**query_ex)
return books
def test_cmp(self):
self.assertEqual(cmp(-1, 1), -1)
self.assertEqual(cmp(1, -1), 1)
self.assertEqual(cmp(1, 1), 0)
# verify that circular objects are not handled
a = []
a.append(a)
b = []
b.append(b)
from UserList import UserList
c = UserList()
c.append(c)
self.assertRaises(RuntimeError, cmp, a, b)
self.assertRaises(RuntimeError, cmp, b, c)
self.assertRaises(RuntimeError, cmp, c, a)
self.assertRaises(RuntimeError, cmp, a, c)
# okay, now break the cycles
a.pop()
b.pop()
c.pop()
self.assertRaises(TypeError, cmp)
def get(self):
properties = self.model.properties()
property_labels = [properties[name].verbose_name or name.capitalize()
for name
in self.model.visible_properties]
entities = self.model.get_ordered_list()
entity_lists = []
for entity in entities:
entity_values = UserList()
for property_name in self.model.visible_properties:
if hasattr(entity, 'formatted_' + property_name):
entity_values.append(getattr(entity, 'formatted_' +
property_name))
else:
entity_values.append(getattr(entity, property_name))
entity_values.id = entity.id
entity_lists.append(entity_values)
self.render_to_response('admin/entity_list.html',
model=self.model,
entities=entity_lists,
property_labels=property_labels)
class Schema(UserDict):
def __init__(self, spec):
self.data = {}
self.fields = UserList()
self.field_order = UserList()
for item in spec:
field = Schema_Field(item)
self.data[field.name] = field
self.fields.append(field)
self.field_order.append(field.name)
self.quoted_schema = self._get_quoted_schema()
def get_index(self, field):
return self.field_order.index(field)
def _get_quoted_schema(self):
return ','.join(map(lambda x: "'%s'" % x, self.field_order))
def obj_to_data_values(self, obj):
row_value_list = []
for field in self.fields:
val = field.get_value(obj)
if type(val) == type('') or type(val) == type(u''):
try:
row_value_list.append(u"'{}'".format(
val.replace("'", "%27")))
except UnicodeEncodeError, msg:
print msg
print "val: %s" % val
# row_value_list.append (u"")
sys.exit(1)
if type(val) == type(1) or type(val) == type(1.5):
row_value_list.append(unicode(val))
quoted_values = u','.join(row_value_list)
return quoted_values
def get_blocks_diff(a,b):
d=difflib.Differ()
res_r=[]
cb_r=[]
res_l=[]
cb_l=[]
change_l=False
change_r=False
result=list(d.compare(a.splitlines(), b.splitlines()))
#from pprint import pprint
#pprint(result)
for i in result:
data=i[2:]
if i[:2]=='? ':
continue
if i[:2]==' ':
if not change_l and not change_r:
cb_r.append(data)
cb_l.append(data)
elif not change_l and change_r:
res_r.append(cb_r)
cb_r=UserList([data])
cb_l.append(data)
elif change_l and not change_r:
res_l.append(cb_l)
cb_l=UserList([data])
cb_r.append(data)
elif change_l and change_r:
res_r.append(cb_r)
cb_r=UserList([data])
res_l.append(cb_l)
cb_l=UserList([data])
change_r=False
change_l=False
elif i[:2]=='- ':
if not change_l:
res_l.append(cb_l)
cb_l=UserList([data])
elif change_l:
cb_l.append(data)
cb_l.added=True
change_l=True
#print "1"
elif i[:2]=='+ ':
if not change_r:
res_r.append(cb_r)
cb_r=UserList([data])
elif change_r:
cb_r.append(data)
cb_r.added=True
change_r=True
if len(cb_r)>0: res_r.append(cb_r)
if len(cb_l)>0: res_l.append(cb_l)
return res_l, res_r
def append(self, value):
UserList.append(self, value)
self._update()
def append(self, item):
UserList.append(self, item)
self._up_to_date = False
def append(self, item):
validateInformation(item)
UserList.append(self, item)
def append(self, item):
res=ftpparse.ftpparse([item])[0]
if res:
list_.append(self, res)
self._fname_dict[res[ftpparse.NAME]]=res
def SlowFunction(start):
reals = UserList()
for x in range(start, 30000):
r = x / float(x + 1)
reals.append(r)
return reals
def SlowMethod(self, start):
reals = UserList()
for x in range(start, 30000):
r = x / float(x + 1)
reals.append(r)
return reals
def append(self, item):
#print "------- %s::append() -------" % self._attributes[SELF][NAME]
UserList.append(self, item)
if isinstance(item, GenClass):
item._setParent(self)
# Check every path through every method of UserList
from UserList import UserList
from test_support import TestFailed
# Use check instead of assert so -O doesn't render the
# test useless.
# XXX: could use the verify function in test_support instead
def check(predicate, msg):
if not predicate:
raise TestFailed(msg + " failed")
l0 = []
l1 = [0]
l2 = [0, 1]
# Test constructors
u = UserList()
u0 = UserList(l0)
u1 = UserList(l1)
u2 = UserList(l2)
uu = UserList(u)
uu0 = UserList(u0)
uu1 = UserList(u1)
uu2 = UserList(u2)
v = UserList(tuple(u))
class OtherList:
def __init__(self, initlist):
self.__data = initlist
def __len__(self):
return len(self.__data)
def __getitem__(self, i):
return self.__data[i]
v0 = UserList(OtherList(u0))
def append(self, item):
validateInformation(item)
UserList.append(self, item)
print 'chr'
if chr(32) != ' ': raise TestFailed, 'chr(32)'
if chr(65) != 'A': raise TestFailed, 'chr(65)'
if chr(97) != 'a': raise TestFailed, 'chr(97)'
# cmp
print 'cmp'
if cmp(-1, 1) != -1: raise TestFailed, 'cmp(-1, 1)'
if cmp(1, -1) != 1: raise TestFailed, 'cmp(1, -1)'
if cmp(1, 1) != 0: raise TestFailed, 'cmp(1, 1)'
# verify that circular objects are handled
a = []; a.append(a)
b = []; b.append(b)
from UserList import UserList
c = UserList(); c.append(c)
if cmp(a, b) != 0: raise TestFailed, "cmp(%s, %s)" % (a, b)
if cmp(b, c) != 0: raise TestFailed, "cmp(%s, %s)" % (b, c)
if cmp(c, a) != 0: raise TestFailed, "cmp(%s, %s)" % (c, a)
if cmp(a, c) != 0: raise TestFailed, "cmp(%s, %s)" % (a, c)
# okay, now break the cycles
a.pop(); b.pop(); c.pop()
print 'coerce'
if fcmp(coerce(1, 1.1), (1.0, 1.1)): raise TestFailed, 'coerce(1, 1.1)'
if coerce(1, 1L) != (1L, 1L): raise TestFailed, 'coerce(1, 1L)'
if fcmp(coerce(1L, 1.1), (1.0, 1.1)): raise TestFailed, 'coerce(1L, 1.1)'
print 'compile'
compile('print 1\n', '', 'exec')
def append(self, item):
UserList.append(self, item)
self.unique = False
def append(self, item):
UserList.append(self, item)
self.unique = False
del uu2[:1] assert uu2 == [] # Test __add__, __radd__, __mul__ and __rmul__ assert u1 + [] == [] + u1 == u1 assert u1 + [1] == u2 assert [-1] + u1 == [-1, 0] assert u2 == u2*1 == 1*u2 assert u2+u2 == u2*2 == 2*u2 assert u2+u2+u2 == u2*3 == 3*u2 # Test append u = u1[:] u.append(1) assert u == u2 # Test insert u = u2[:] u.insert(0, -1) assert u == [-1, 0, 1] # Test pop u = [-1] + u2 u.pop() assert u == [-1, 0] u.pop(0) assert u == [0]
def append(self, value):
UserList.append(self, value)
self._update()
def test_recursion(self):
# Check comparison for recursive objects
from UserList import UserList
a = UserList(); a.append(a)
b = UserList(); b.append(b)
self.assert_(a == b)
self.assert_(not a != b)
a.append(1)
self.assert_(a == a[0])
self.assert_(not a != a[0])
self.assert_(a != b)
self.assert_(not a == b)
b.append(0)
self.assert_(a != b)
self.assert_(not a == b)
a[1] = -1
self.assert_(a != b)
self.assert_(not a == b)
a = UserList()
b = UserList()
a.append(b)
b.append(a)
self.assert_(a == b)
self.assert_(not a != b)
b.append(17)
self.assert_(a != b)
self.assert_(not a == b)
a.append(17)
self.assert_(a == b)
self.assert_(not a != b)
def test_append(self):
u = UserList((0, ))
u.append(1)
self.assertEqual(u, [0, 1])
def append(self, item):
res = ftpparse.ftpparse([item])[0]
if res:
list_.append(self, res)
self._fname_dict[res[ftpparse.NAME]] = res
def append(self, item):
UserList.append(self, item)
self._changed()
def append(self, item):
UserList.append(self, item)
self.notify()
def append(self, object):
self.__register_field(object)
list.append(self, object)
def append(self, item): UserList.append(self, item) self._changed()
# Tests for rich comparisons
