def __init__(self, app):
SelectDialogTreeData.__init__(self)
self.all_games_gi = map(app.gdb.get, app.gdb.getGamesIdSortedByName())
self.no_games = [
SelectGameLeaf(None, None, _("(no games)"), None),
]
#
s_by_type = s_oriental = s_special = s_original = s_contrib = s_mahjongg = None
g = []
for data in (
GI.SELECT_GAME_BY_TYPE,
GI.SELECT_ORIENTAL_GAME_BY_TYPE,
GI.SELECT_SPECIAL_GAME_BY_TYPE,
GI.SELECT_ORIGINAL_GAME_BY_TYPE,
GI.SELECT_CONTRIB_GAME_BY_TYPE,
):
gg = []
for name, select_func in data:
if name is None or not filter(select_func, self.all_games_gi):
continue
gg.append(SelectGameNode(None, _(name), select_func))
g.append(gg)
select_mahjongg_game = lambda gi: gi.si.game_type == GI.GT_MAHJONGG
gg = None
if filter(select_mahjongg_game, self.all_games_gi):
gg = SelectGameNode(None, _("Mahjongg Games"),
select_mahjongg_game)
g.append(gg)
if g[0]:
s_by_type = SelectGameNode(None,
_("French games"),
tuple(g[0]),
expanded=1)
if g[1]:
s_oriental = SelectGameNode(None, _("Oriental Games"), tuple(g[1]))
if g[2]:
s_special = SelectGameNode(None, _("Special Games"), tuple(g[2]))
if g[3]:
s_original = SelectGameNode(None, _("Original Games"), tuple(g[3]))
## if g[4]:
## s_contrib = SelectGameNode(None, "Contributed Games", tuple(g[4]))
if g[5]:
s_mahjongg = g[5]
#
s_by_compatibility, gg = None, []
for name, games in GI.GAMES_BY_COMPATIBILITY:
select_func = lambda gi, games=games: gi.id in games
if name is None or not filter(select_func, self.all_games_gi):
continue
gg.append(SelectGameNode(None, name, select_func))
if 1 and gg:
s_by_compatibility = SelectGameNode(None, _("by Compatibility"),
tuple(gg))
#
s_by_pysol_version, gg = None, []
for name, games in GI.GAMES_BY_PYSOL_VERSION:
select_func = lambda gi, games=games: gi.id in games
if name is None or not filter(select_func, self.all_games_gi):
continue
name = _("New games in v. ") + name
gg.append(SelectGameNode(None, name, select_func))
if 1 and gg:
s_by_pysol_version = SelectGameNode(None, _("by PySol version"),
tuple(gg))
s_by_inventors, gg = None, []
for name, games in GI.GAMES_BY_INVENTORS:
select_func = lambda gi, games=games: gi.id in games
if name is None or not filter(select_func, self.all_games_gi):
continue
gg.append(SelectGameNode(None, name, select_func))
if 1 and gg:
s_by_inventors = SelectGameNode(None, _("by Inventors"), tuple(gg))
#
ul_alternate_names = UserList(
list(app.gdb.getGamesTuplesSortedByAlternateName()))
#
self.rootnodes = filter(
None,
(
SelectGameNode(None, _("All Games"), None, expanded=0),
SelectGameNode(None, _("Alternate Names"), ul_alternate_names),
SelectGameNode(None, _("Popular Games"),
lambda gi: gi.si.game_flags & GI.GT_POPULAR),
s_by_type,
s_mahjongg,
s_oriental,
s_special,
SelectGameNode(None, _("Custom Games"),
lambda gi: gi.si.game_type == GI.GT_CUSTOM),
SelectGameNode(None, _('by Skill Level'), (
SelectGameNode(None, _('Luck only'),
lambda gi: gi.skill_level == GI.SL_LUCK),
SelectGameNode(
None, _('Mostly luck'),
lambda gi: gi.skill_level == GI.SL_MOSTLY_LUCK),
SelectGameNode(
None, _('Balanced'),
lambda gi: gi.skill_level == GI.SL_BALANCED),
SelectGameNode(
None, _('Mostly skill'),
lambda gi: gi.skill_level == GI.SL_MOSTLY_SKILL),
SelectGameNode(None, _('Skill only'),
lambda gi: gi.skill_level == GI.SL_SKILL),
)),
SelectGameNode(
None,
_("by Game Feature"),
(
SelectGameNode(None, _("by Number of Cards"), (
SelectGameNode(None, _("32 cards"),
lambda gi: gi.si.ncards == 32),
SelectGameNode(None, _("48 cards"),
lambda gi: gi.si.ncards == 48),
SelectGameNode(None, _("52 cards"),
lambda gi: gi.si.ncards == 52),
SelectGameNode(None, _("64 cards"),
lambda gi: gi.si.ncards == 64),
SelectGameNode(None, _("78 cards"),
lambda gi: gi.si.ncards == 78),
SelectGameNode(None, _("104 cards"),
lambda gi: gi.si.ncards == 104),
SelectGameNode(None, _("144 cards"),
lambda gi: gi.si.ncards == 144),
SelectGameNode(
None, _("Other number"),
lambda gi: gi.si.ncards not in
(32, 48, 52, 64, 78, 104, 144)),
)),
SelectGameNode(None, _("by Number of Decks"), (
SelectGameNode(None, _("1 deck games"),
lambda gi: gi.si.decks == 1),
SelectGameNode(None, _("2 deck games"),
lambda gi: gi.si.decks == 2),
SelectGameNode(None, _("3 deck games"),
lambda gi: gi.si.decks == 3),
SelectGameNode(None, _("4 deck games"),
lambda gi: gi.si.decks == 4),
)),
SelectGameNode(
None,
_("by Number of Redeals"),
(
SelectGameNode(None, _("No redeal"),
lambda gi: gi.si.redeals == 0),
SelectGameNode(None, _("1 redeal"),
lambda gi: gi.si.redeals == 1),
SelectGameNode(None, _("2 redeals"),
lambda gi: gi.si.redeals == 2),
SelectGameNode(None, _("3 redeals"),
lambda gi: gi.si.redeals == 3),
SelectGameNode(None, _("Unlimited redeals"),
lambda gi: gi.si.redeals == -1),
## SelectGameNode(None, "Variable redeals",
## lambda gi: gi.si.redeals == -2),
SelectGameNode(
None, _("Other number of redeals"),
lambda gi: gi.si.redeals not in
(-1, 0, 1, 2, 3)),
)),
s_by_compatibility,
)),
s_by_pysol_version,
s_by_inventors,
SelectGameNode(None, _("Other Categories"), (
SelectGameNode(
None, _("Games for Children (very easy)"),
lambda gi: gi.si.game_flags & GI.GT_CHILDREN),
SelectGameNode(None, _("Games with Scoring"),
lambda gi: gi.si.game_flags & GI.GT_SCORE),
SelectGameNode(
None, _("Games with Separate Decks"),
lambda gi: gi.si.game_flags & GI.GT_SEPARATE_DECKS),
SelectGameNode(None, _("Open Games (all cards visible)"),
lambda gi: gi.si.game_flags & GI.GT_OPEN),
SelectGameNode(
None, _("Relaxed Variants"),
lambda gi: gi.si.game_flags & GI.GT_RELAXED),
)),
s_original,
s_contrib,
))
def test_set_string2(self):
a = UserList([1, 2, 3])
inline_tools.inline('a[1] = std::complex<double>(1,1);', ['a'])
assert_equal(sys.getrefcount(a[1]), 2)
assert_equal(a[1], 1 + 1j)
def setUp(self):
self.it = iter(UserList(range(n)))
def test_delitem(self):
u = UserList([0, 1])
del u[1]
del u[0]
self.assertRaises(IndexError, u.__delitem__, 0)
def test_set_char(self):
a = UserList([1, 2, 3])
inline_tools.inline('a[1] = "bubba";', ['a'])
assert_equal(sys.getrefcount(a[1]), 2)
assert_equal(a[1], 'bubba')
def test_imul(self):
u = UserList((0, 1))
u *= 3
self.assertEqual(u, [0, 1, 0, 1, 0, 1])
def test_getitem(self):
u = UserList([0, 1, 2])
for i in xrange(len(u)):
self.assertEqual(u[i], i)
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)'
try: coerce(0.5, long("12345" * 1000))
except OverflowError: pass
else: raise TestFailed, 'coerce(0.5, long("12345" * 1000))'
def test_contains(self):
u = UserList([0, 1, 2])
for i in u:
self.assert_(i in u)
for i in min(u)-1, max(u)+1:
self.assert_(i not in u)
# verify softspace is writable
f.softspace = softspace # merely shouldn't blow up
# verify the others aren't
for attr in 'name', 'mode', 'closed':
try:
setattr(f, attr, 'oops')
except TypeError:
pass
else:
raise TestFailed('expected TypeError setting file attr %r' % attr)
f.close()
# verify writelines with instance sequence
l = UserList(['1', '2'])
f = open(TESTFN, 'wb')
f.writelines(l)
f.close()
f = open(TESTFN, 'rb')
buf = f.read()
f.close()
verify(buf == '12')
# verify readinto
a = array('c', 'x' * 10)
f = open(TESTFN, 'rb')
n = f.readinto(a)
f.close()
verify(buf == a.tostring()[:n])
def setUp(self):
self.list = UserList()
def test_iadd(self):
super(UserListTest, self).test_iadd()
u = [0, 1]
u += UserList([0, 1])
self.assertEqual(u, [0, 1, 0, 1])
# Use check instead of assert so -O doesn't render the
# test useless.
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
i = obj.mcall("inc",args);
result[1] = i;
obj.set_attr("val",5);
i = obj.attr("val");
result[2] = i;
return_val = result;
"""
print('initial, inc(2), set(5)/get:', weave.inline(code,['obj']))
#----------------------------------------------------------------------------
# indexing of values.
#----------------------------------------------------------------------------
from UserList import UserList
obj = UserList([1,[1,2],"hello"])
code = """
int i;
// find obj length and access each of its items
//std::cout << "UserList items: ";
//for(i = 0; i < obj.length(); i++)
// std::cout << obj[i].str() << " ";
//std::cout << std::endl;
// assign new values to each of its items
for(i = 0; i < obj.length(); i++)
obj[i] = "goodbye";
"""
weave.inline(code,['obj'])
print("obj with new values:", obj)
def test_sort(self):
u = UserList([1, 0])
u.sort()
self.assertEqual(u, [0, 1])
def test_add_specials(self):
u = UserList("spam")
u2 = u + "eggs"
self.assertEqual(u2, list("spameggs"))
def test_slice(self):
u = UserList("spam")
u[:2] = "h"
self.assertEqual(u, list("ham"))
def test_radd_specials(self):
u = UserList("eggs")
u2 = "spam" + u
self.assertEqual(u2, list("spameggs"))
u2 = u.__radd__(UserList("spam"))
self.assertEqual(u2, list("spameggs"))
def test_constructors(self):
l0 = []
l1 = [0]
l2 = [0, 1]
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))
vv = UserList("this is also a sequence")
def test_append(self):
u = UserList((0, ))
u.append(1)
self.assertEqual(u, [0, 1])
def test_setitem(self):
u = UserList([0, 1])
u[0] = 0
u[1] = 100
self.assertEqual(u, [0, 100])
self.assertRaises(IndexError, u.__setitem__, 2, 200)
def test_insert(self):
u = UserList((0, 1))
u.insert(0, -1)
self.assertEqual(u, [-1, 0, 1])
def test_set_double(self):
a = UserList([1, 2, 3])
inline_tools.inline("a[1] = 123.0;", ['a'])
assert_equal(sys.getrefcount(a[1]), 2)
assert_equal(a[1], 123.0)
def test_pop(self):
u = UserList((-1, 0, 1))
u.pop()
self.assertEqual(u, [-1, 0])
u.pop(0)
self.assertEqual(u, [0])
def test_set_string1(self):
a = UserList([1, 2, 3])
inline_tools.inline('a[1] = std::string("sissy");', ['a'])
assert_equal(sys.getrefcount(a[1]), 2)
assert_equal(a[1], 'sissy')
def test_remove(self):
u = UserList((0, 1))
u.remove(1)
self.assertEqual(u, [0])
def testWritelinesIntegersUserList(self):
# verify writelines with integers in UserList
l = UserList([1, 2, 3])
self.assertRaises(TypeError, self.f.writelines, l)
def test_count(self):
u = UserList((0, 1))*3
self.assertEqual(u.count(0), 3)
self.assertEqual(u.count(1), 3)
self.assertEqual(u.count(2), 0)
def setUp(self):
self.it = reversed(UserList(range(n)))
def test_precomputed(self):
for func, data, elem, expected in self.precomputedCases:
self.assertEqual(func(data, elem), expected)
self.assertEqual(func(UserList(data), elem), expected)
