class TPlaylistModel(TestCase):
def setUp(self):
self.pl = PlaylistModel()
self.pl.set(range(10))
do_events()
self.failUnless(self.pl.current is None)
def test_current_recover(self):
self.pl.set(range(10))
self.pl.next()
self.failUnlessEqual(self.pl.current, 0)
self.pl.set(range(20, 30))
self.failUnless(self.pl.current is None)
self.pl.current_iter = self.pl.current_iter
self.failUnless(self.pl.current is None)
self.pl.set(range(10))
self.failUnlessEqual(self.pl.current, 0)
def test_current_recover_unknown(self):
self.pl.set([1, 2, 3, 4])
self.assertIs(self.pl.go_to(5), None)
self.pl.set([1, 2, 3, 4, 5])
self.assertEqual(self.pl.current, 5)
self.assertIsNot(self.pl.go_to(4), None)
self.assertEqual(self.pl.current, 4)
def test_isempty(self):
self.failIf(self.pl.is_empty())
self.pl.clear()
self.failUnless(self.pl.is_empty())
def test_get(self):
self.assertEqual(self.pl.get(), list(range(10)))
self.pl.set(range(12))
Gtk.main_iteration_do(False)
self.assertEqual(self.pl.get(), list(range(12)))
def test_next(self):
self.pl.next()
self.failUnlessEqual(self.pl.current, 0)
self.pl.next()
self.failUnlessEqual(self.pl.current, 1)
self.pl.go_to(9)
self.failUnlessEqual(self.pl.current, 9)
self.pl.next()
self.failUnless(self.pl.current is None)
def test_find(self):
self.failUnlessEqual(self.pl[self.pl.find(8)][0], 8)
def test_find_not_there(self):
self.failUnless(self.pl.find(22) is None)
def test_find_all(self):
to_find = [1, 4, 5, 8, 9]
iters = self.pl.find_all(to_find)
for i, v in zip(iters, to_find):
self.failUnlessEqual(self.pl[i][0], v)
def test_find_all_duplicates(self):
# ignore duplicates in parameters
self.assertTrue(len(self.pl.find_all([1, 1])), 1)
# but find duplicates
self.pl.set([1, 1])
self.assertTrue(len(self.pl.find_all([1])), 2)
def test_find_all_some_missing(self):
to_find = [1, 4, 18, 5, 8, 9, -1]
iters = self.pl.find_all(to_find)
to_find.remove(18)
to_find.remove(-1)
for i, v in zip(iters, to_find):
self.failUnlessEqual(self.pl[i][0], v)
def test_find_all_empty(self):
to_find = [100, 200, -11]
iters = self.pl.find_all(to_find)
self.failUnlessEqual(iters, [])
def test_contains(self):
self.failUnless(1 in self.pl)
self.failUnless(8 in self.pl)
self.failIf(22 in self.pl)
def test_removal(self):
self.pl.go_to(8)
for i in range(3, 8):
self.pl.remove(self.pl.find(i))
self.pl.next()
self.failUnlessEqual(self.pl.current, 9)
def test_next_repeat(self):
self.pl.repeat = True
self.pl.go_to(3)
for i in range(9):
self.pl.next()
self.assertEqual(self.pl.current, 2)
for i in range(12):
self.pl.next()
self.assertEqual(self.pl.current, 4)
def test_shuffle(self):
self.pl.order = ORDERS[1](self.pl)
for i in range(5):
numbers = [self.pl.current for i in range(10)
if self.pl.next() or True]
self.assertNotEqual(numbers, list(range(10)))
numbers.sort()
self.assertEqual(numbers, list(range(10)))
self.pl.next()
self.assertEqual(self.pl.current, None)
def test_weighted(self):
self.pl.order = ORDERS[2](self.pl)
r0 = AudioFile({'~#rating': 0})
r1 = AudioFile({'~#rating': 1})
r2 = AudioFile({'~#rating': 2})
r3 = AudioFile({'~#rating': 3})
self.pl.set([r0, r1, r2, r3])
Gtk.main_iteration_do(False)
songs = [self.pl.current for i in range(1000)
if self.pl.next() or True]
self.assert_(songs.count(r1) > songs.count(r0))
self.assert_(songs.count(r2) > songs.count(r1))
self.assert_(songs.count(r3) > songs.count(r2))
def test_shuffle_repeat(self):
self.pl.order = ORDERS[1](self.pl)
self.pl.repeat = True
numbers = [self.pl.current for i in range(30)
if self.pl.next() or True]
allnums = list(range(10)) * 3
allnums.sort()
self.assertNotEqual(numbers, allnums)
numbers.sort()
self.assertEqual(numbers, allnums)
def test_onesong(self):
self.pl.go_to(3)
self.pl.order = ORDERS[3](self.pl)
self.failUnlessEqual(self.pl.current, 3)
self.pl.next()
self.failUnlessEqual(self.pl.current, 4)
self.pl.next_ended()
self.failUnlessEqual(self.pl.current, None)
def test_onesong_repeat(self):
self.pl.go_to(3)
self.pl.order = ORDERS[3](self.pl)
self.pl.repeat = True
self.failUnlessEqual(self.pl.current, 3)
self.pl.next()
self.failUnlessEqual(self.pl.current, 4)
self.pl.next_ended()
self.failUnlessEqual(self.pl.current, 4)
def test_previous(self):
self.pl.go_to(2)
self.failUnlessEqual(self.pl.current, 2)
self.pl.previous()
self.failUnlessEqual(self.pl.current, 1)
self.pl.previous()
self.failUnlessEqual(self.pl.current, 0)
self.pl.previous()
self.failUnlessEqual(self.pl.current, 0)
def test_go_to_saves_current(self):
self.pl.go_to(5)
self.failUnlessEqual(self.pl.current, 5)
self.pl.set([5, 10, 15, 20])
Gtk.main_iteration_do(False)
self.pl.next()
self.failUnlessEqual(self.pl.current, 10)
def test_go_to_order(self):
self.pl.order = ORDERS[1](self.pl)
for i in range(5):
self.pl.go_to(5)
self.failUnlessEqual(self.pl.current, 5)
self.pl.go_to(1)
self.failUnlessEqual(self.pl.current, 1)
def test_go_to(self):
class SetOrder(Order):
# most orders don't change iter here,
# so make sure this gets handled right
def set_explicit(self, playlist, iter):
return playlist.iter_next(iter)
def set_implicit(self, playlist, iter):
return playlist.iter_next(playlist.iter_next(iter))
self.pl.order = SetOrder(self.pl)
self.failUnlessEqual(self.pl[self.pl.go_to(5, True)][0], 6)
self.failUnlessEqual(self.pl[self.pl.go_to(5, False)][0], 7)
def test_go_to_none(self):
for i in range(5):
self.pl.go_to(None)
self.failUnlessEqual(self.pl.current, None)
self.pl.next()
self.failUnlessEqual(self.pl.current, 0)
def test_reset(self):
self.pl.go_to(5)
self.failUnlessEqual(self.pl.current, 5)
self.pl.reset()
self.failUnlessEqual(self.pl.current, 0)
def test_reset_order(self):
self.pl.order = ORDERS[0](self.pl)
self.pl.go_to(5)
self.failUnlessEqual(self.pl.current, 5)
self.pl.reset()
self.failUnlessEqual(self.pl.current, 0)
def test_restart(self):
self.pl.go_to(1)
self.pl.set([101, 102, 103, 104])
Gtk.main_iteration_do(False)
self.pl.next()
self.failUnlessEqual(self.pl.current, 101)
def test_next_nosong_536(self):
self.pl.go_to(1)
self.pl.repeat = True
self.pl.order = ORDERS[1](self.pl)
self.pl.set([])
Gtk.main_iteration_do(False)
self.pl.next()
def test_clear_current(self):
self.pl.go_to(1)
self.pl.clear()
self.pl.go_to(None)
def shutDown(self):
self.pl.destroy()
class TPlaylistModel(TestCase):
def setUp(self):
self.pl = PlaylistModel()
self.pl.set(range(10))
do_events()
self.failUnless(self.pl.current is None)
def test_current_recover(self):
self.pl.set(range(10))
self.pl.next()
self.failUnlessEqual(self.pl.current, 0)
self.pl.set(range(20, 30))
self.failUnless(self.pl.current is None)
self.pl.current_iter = self.pl.current_iter
self.failUnless(self.pl.current is None)
self.pl.set(range(10))
self.failUnlessEqual(self.pl.current, 0)
def test_current_recover_unknown(self):
self.pl.set([1, 2, 3, 4])
self.assertIs(self.pl.go_to(5), None)
self.pl.set([1, 2, 3, 4, 5])
self.assertEqual(self.pl.current, 5)
self.assertIsNot(self.pl.go_to(4), None)
self.assertEqual(self.pl.current, 4)
def test_isempty(self):
self.failIf(self.pl.is_empty())
self.pl.clear()
self.failUnless(self.pl.is_empty())
def test_get(self):
self.assertEqual(self.pl.get(), list(range(10)))
self.pl.set(range(12))
Gtk.main_iteration_do(False)
self.assertEqual(self.pl.get(), list(range(12)))
def test_next(self):
self.pl.next()
self.failUnlessEqual(self.pl.current, 0)
self.pl.next()
self.failUnlessEqual(self.pl.current, 1)
self.pl.go_to(9)
self.failUnlessEqual(self.pl.current, 9)
self.pl.next()
self.failUnless(self.pl.current is None)
def test_find(self):
self.failUnlessEqual(self.pl[self.pl.find(8)][0], 8)
def test_find_not_there(self):
self.failUnless(self.pl.find(22) is None)
def test_find_all(self):
to_find = [1, 4, 5, 8, 9]
iters = self.pl.find_all(to_find)
for i, v in zip(iters, to_find):
self.failUnlessEqual(self.pl[i][0], v)
def test_find_all_duplicates(self):
# ignore duplicates in parameters
self.assertTrue(len(self.pl.find_all([1, 1])), 1)
# but find duplicates
self.pl.set([1, 1])
self.assertTrue(len(self.pl.find_all([1])), 2)
def test_find_all_some_missing(self):
to_find = [1, 4, 18, 5, 8, 9, -1]
iters = self.pl.find_all(to_find)
to_find.remove(18)
to_find.remove(-1)
for i, v in zip(iters, to_find):
self.failUnlessEqual(self.pl[i][0], v)
def test_find_all_empty(self):
to_find = [100, 200, -11]
iters = self.pl.find_all(to_find)
self.failUnlessEqual(iters, [])
def test_contains(self):
self.failUnless(1 in self.pl)
self.failUnless(8 in self.pl)
self.failIf(22 in self.pl)
def test_removal(self):
self.pl.go_to(8)
for i in range(3, 8):
self.pl.remove(self.pl.find(i))
self.pl.next()
self.failUnlessEqual(self.pl.current, 9)
def test_next_at_end_finishes(self):
self.pl.go_to(9)
self.pl.next()
self.assertEqual(self.pl.current, None)
def test_shuffle(self):
self.pl.order = OrderShuffle()
for i in range(5):
history = [self.pl.current for _ in range(10)
if self.pl.next() or True]
self.assertNotEqual(history, list(range(10)))
self.assertEqual(sorted(history), list(range(10)))
self.pl.next()
self.assertEqual(self.pl.current, None)
self.pl.order.reset(self.pl)
def test_shuffle_repeat_forever(self):
self.pl.order = RepeatSongForever(OrderShuffle())
old = self.pl.current
for i in range(5):
self.pl.next_ended()
self.assertEqual(self.pl.current, old)
def test_shuffle_repeat(self):
self.pl.order = RepeatListForever(OrderShuffle())
numbers = [self.pl.current for _ in range(30)
if self.pl.next_ended() or True]
allnums = sorted(list(range(10)) * 3)
self.assertNotEqual(numbers, allnums)
numbers.sort()
self.assertEqual(numbers, allnums)
def test_repeat_song_repeats_on_end(self):
self.pl.order = RepeatSongForever(OrderInOrder())
self.pl.go_to(3)
self.failUnlessEqual(self.pl.current, 3)
self.pl.next_ended()
self.failUnlessEqual(self.pl.current, 3)
def test_repeat_song_uses_underlying_on_explicit(self):
self.pl.order = RepeatSongForever(OrderInOrder())
self.pl.go_to(3)
self.pl.next()
self.failUnlessEqual(self.pl.current, 4)
def test_repeat_all_cycles_playlist(self):
self.pl.go_to(3)
self.pl.order = RepeatListForever(OrderInOrder())
self.failUnlessEqual(self.pl.current, 3)
self.pl.next()
self.failUnlessEqual(self.pl.current, 4)
for i in range(9):
self.pl.next_ended()
self.failUnlessEqual(self.pl.current, 3)
def test_previous(self):
self.pl.go_to(2)
self.failUnlessEqual(self.pl.current, 2)
self.pl.previous()
self.failUnlessEqual(self.pl.current, 1)
self.pl.previous()
self.failUnlessEqual(self.pl.current, 0)
self.pl.previous()
self.failUnlessEqual(self.pl.current, 0)
def test_go_to_saves_current(self):
self.pl.go_to(5)
self.failUnlessEqual(self.pl.current, 5)
self.pl.set([5, 10, 15, 20])
Gtk.main_iteration_do(False)
self.pl.next()
self.failUnlessEqual(self.pl.current, 10)
def test_go_to_order(self):
self.pl.order = OrderShuffle()
for i in range(5):
self.pl.go_to(5)
self.failUnlessEqual(self.pl.current, 5)
self.pl.go_to(1)
self.failUnlessEqual(self.pl.current, 1)
def test_go_to(self):
class SetOrder(Order):
# most orders don't change iter here,
# so make sure this gets handled right
def set_explicit(self, playlist, iter):
return playlist.iter_next(iter)
def set_implicit(self, playlist, iter):
return playlist.iter_next(playlist.iter_next(iter))
self.pl.order = SetOrder()
self.failUnlessEqual(self.pl[self.pl.go_to(5, True)][0], 6)
self.failUnlessEqual(self.pl[self.pl.go_to(5, False)][0], 7)
def test_go_to_none(self):
for i in range(5):
self.pl.go_to(None)
self.failUnlessEqual(self.pl.current, None)
self.pl.next()
self.failUnlessEqual(self.pl.current, 0)
def test_reset(self):
self.pl.go_to(5)
self.failUnlessEqual(self.pl.current, 5)
self.pl.reset()
self.failUnlessEqual(self.pl.current, 0)
def test_reset_order(self):
self.pl.order = OrderInOrder()
self.pl.go_to(5)
self.failUnlessEqual(self.pl.current, 5)
self.pl.reset()
self.failUnlessEqual(self.pl.current, 0)
def test_restart(self):
self.pl.go_to(1)
self.pl.set([101, 102, 103, 104])
Gtk.main_iteration_do(False)
self.pl.next()
self.failUnlessEqual(self.pl.current, 101)
def test_next_nosong_536(self):
self.pl.go_to(1)
self.pl.order = OrderShuffle()
self.pl.set([])
Gtk.main_iteration_do(False)
self.pl.next()
def test_clear_current(self):
self.pl.go_to(1)
self.pl.clear()
self.pl.go_to(None)
def shutDown(self):
self.pl.destroy()
class TPlaylistModel(TestCase):
def setUp(self):
self.pl = PlaylistModel()
self.pl.set(range(10))
do_events()
self.failUnless(self.pl.current is None)
def test_current_recover(self):
self.pl.set(range(10))
self.pl.next()
self.failUnlessEqual(self.pl.current, 0)
self.pl.set(range(20, 30))
self.failUnless(self.pl.current is None)
self.pl.current_iter = self.pl.current_iter
self.failUnless(self.pl.current is None)
self.pl.set(range(10))
self.failUnlessEqual(self.pl.current, 0)
def test_current_recover_unknown(self):
self.pl.set([1, 2, 3, 4])
self.assertIs(self.pl.go_to(5), None)
self.pl.set([1, 2, 3, 4, 5])
self.assertEqual(self.pl.current, 5)
self.assertIsNot(self.pl.go_to(4), None)
self.assertEqual(self.pl.current, 4)
def test_isempty(self):
self.failIf(self.pl.is_empty())
self.pl.clear()
self.failUnless(self.pl.is_empty())
def test_get(self):
self.assertEqual(self.pl.get(), list(range(10)))
self.pl.set(range(12))
Gtk.main_iteration_do(False)
self.assertEqual(self.pl.get(), list(range(12)))
def test_next(self):
self.pl.next()
self.failUnlessEqual(self.pl.current, 0)
self.pl.next()
self.failUnlessEqual(self.pl.current, 1)
self.pl.go_to(9)
self.failUnlessEqual(self.pl.current, 9)
self.pl.next()
self.failUnless(self.pl.current is None)
def test_find(self):
self.failUnlessEqual(self.pl[self.pl.find(8)][0], 8)
def test_find_not_there(self):
self.failUnless(self.pl.find(22) is None)
def test_find_all(self):
to_find = [1, 4, 5, 8, 9]
iters = self.pl.find_all(to_find)
for i, v in zip(iters, to_find):
self.failUnlessEqual(self.pl[i][0], v)
def test_find_all_duplicates(self):
# ignore duplicates in parameters
self.assertTrue(len(self.pl.find_all([1, 1])), 1)
# but find duplicates
self.pl.set([1, 1])
self.assertTrue(len(self.pl.find_all([1])), 2)
def test_find_all_some_missing(self):
to_find = [1, 4, 18, 5, 8, 9, -1]
iters = self.pl.find_all(to_find)
to_find.remove(18)
to_find.remove(-1)
for i, v in zip(iters, to_find):
self.failUnlessEqual(self.pl[i][0], v)
def test_find_all_empty(self):
to_find = [100, 200, -11]
iters = self.pl.find_all(to_find)
self.failUnlessEqual(iters, [])
def test_contains(self):
self.failUnless(1 in self.pl)
self.failUnless(8 in self.pl)
self.failIf(22 in self.pl)
def test_removal(self):
self.pl.go_to(8)
for i in range(3, 8):
self.pl.remove(self.pl.find(i))
self.pl.next()
self.failUnlessEqual(self.pl.current, 9)
def test_next_at_end_finishes(self):
self.pl.go_to(9)
self.pl.next()
self.assertEqual(self.pl.current, None)
def test_shuffle(self):
self.pl.order = OrderShuffle()
for i in range(5):
history = [self.pl.current for _ in range(10)
if self.pl.next() or True]
self.assertNotEqual(history, list(range(10)))
self.assertEqual(sorted(history), list(range(10)))
self.pl.next()
self.assertEqual(self.pl.current, None)
self.pl.order.reset(self.pl)
def test_shuffle_repeat_forever(self):
self.pl.order = RepeatSongForever(OrderShuffle())
old = self.pl.current
for i in range(5):
self.pl.next_ended()
self.assertEqual(self.pl.current, old)
def test_shuffle_repeat(self):
self.pl.order = RepeatListForever(OrderShuffle())
numbers = [self.pl.current for _ in range(30)
if self.pl.next_ended() or True]
allnums = sorted(list(range(10)) * 3)
self.assertNotEqual(numbers, allnums)
numbers.sort()
self.assertEqual(numbers, allnums)
def test_repeat_song_repeats_on_end(self):
self.pl.order = RepeatSongForever(OrderInOrder())
self.pl.go_to(3)
self.failUnlessEqual(self.pl.current, 3)
self.pl.next_ended()
self.failUnlessEqual(self.pl.current, 3)
def test_repeat_song_uses_underlying_on_explicit(self):
self.pl.order = RepeatSongForever(OrderInOrder())
self.pl.go_to(3)
self.pl.next()
self.failUnlessEqual(self.pl.current, 4)
def test_repeat_all_cycles_playlist(self):
self.pl.go_to(3)
self.pl.order = RepeatListForever(OrderInOrder())
self.failUnlessEqual(self.pl.current, 3)
self.pl.next()
self.failUnlessEqual(self.pl.current, 4)
for i in range(9):
self.pl.next_ended()
self.failUnlessEqual(self.pl.current, 3)
def test_previous(self):
self.pl.go_to(2)
self.failUnlessEqual(self.pl.current, 2)
self.pl.previous()
self.failUnlessEqual(self.pl.current, 1)
self.pl.previous()
self.failUnlessEqual(self.pl.current, 0)
self.pl.previous()
self.failUnlessEqual(self.pl.current, 0)
def test_go_to_saves_current(self):
self.pl.go_to(5)
self.failUnlessEqual(self.pl.current, 5)
self.pl.set([5, 10, 15, 20])
Gtk.main_iteration_do(False)
self.pl.next()
self.failUnlessEqual(self.pl.current, 10)
def test_go_to_order(self):
self.pl.order = OrderShuffle()
for i in range(5):
self.pl.go_to(5)
self.failUnlessEqual(self.pl.current, 5)
self.pl.go_to(1)
self.failUnlessEqual(self.pl.current, 1)
def test_go_to(self):
class SetOrder(Order):
# most orders don't change iter here,
# so make sure this gets handled right
def set_explicit(self, playlist, iter):
return playlist.iter_next(iter)
def set_implicit(self, playlist, iter):
return playlist.iter_next(playlist.iter_next(iter))
self.pl.order = SetOrder()
self.failUnlessEqual(self.pl[self.pl.go_to(5, True)][0], 6)
self.failUnlessEqual(self.pl[self.pl.go_to(5, False)][0], 7)
def test_go_to_none(self):
for i in range(5):
self.pl.go_to(None)
self.failUnlessEqual(self.pl.current, None)
self.pl.next()
self.failUnlessEqual(self.pl.current, 0)
def test_reset(self):
self.pl.go_to(5)
self.failUnlessEqual(self.pl.current, 5)
self.pl.reset()
self.failUnlessEqual(self.pl.current, 0)
def test_reset_order(self):
self.pl.order = OrderInOrder()
self.pl.go_to(5)
self.failUnlessEqual(self.pl.current, 5)
self.pl.reset()
self.failUnlessEqual(self.pl.current, 0)
def test_restart(self):
self.pl.go_to(1)
self.pl.set([101, 102, 103, 104])
Gtk.main_iteration_do(False)
self.pl.next()
self.failUnlessEqual(self.pl.current, 101)
def test_next_nosong_536(self):
self.pl.go_to(1)
self.pl.order = OrderShuffle()
self.pl.set([])
Gtk.main_iteration_do(False)
self.pl.next()
def test_clear_current(self):
self.pl.go_to(1)
self.pl.clear()
self.pl.go_to(None)
def shutDown(self):
self.pl.destroy()
class TPlaylistModel(TestCase):
def setUp(self):
self.pl = PlaylistModel()
self.pl.set(range(10))
do_events()
self.failUnless(self.pl.current is None)
def test_current_recover(self):
self.pl.set(range(10))
self.pl.next()
self.failUnlessEqual(self.pl.current, 0)
self.pl.set(range(20, 30))
self.failUnless(self.pl.current is None)
self.pl.current_iter = self.pl.current_iter
self.failUnless(self.pl.current is None)
self.pl.set(range(10))
self.failUnlessEqual(self.pl.current, 0)
def test_current_recover_unknown(self):
self.pl.set([1, 2, 3, 4])
self.assertIs(self.pl.go_to(5), None)
self.pl.set([1, 2, 3, 4, 5])
self.assertEqual(self.pl.current, 5)
self.assertIsNot(self.pl.go_to(4), None)
self.assertEqual(self.pl.current, 4)
def test_isempty(self):
self.failIf(self.pl.is_empty())
self.pl.clear()
self.failUnless(self.pl.is_empty())
def test_get(self):
self.assertEqual(self.pl.get(), list(range(10)))
self.pl.set(range(12))
Gtk.main_iteration_do(False)
self.assertEqual(self.pl.get(), list(range(12)))
def test_next(self):
self.pl.next()
self.failUnlessEqual(self.pl.current, 0)
self.pl.next()
self.failUnlessEqual(self.pl.current, 1)
self.pl.go_to(9)
self.failUnlessEqual(self.pl.current, 9)
self.pl.next()
self.failUnless(self.pl.current is None)
def test_find(self):
self.failUnlessEqual(self.pl[self.pl.find(8)][0], 8)
def test_find_not_there(self):
self.failUnless(self.pl.find(22) is None)
def test_find_all(self):
to_find = [1, 4, 5, 8, 9]
iters = self.pl.find_all(to_find)
for i, v in zip(iters, to_find):
self.failUnlessEqual(self.pl[i][0], v)
def test_find_all_duplicates(self):
# ignore duplicates in parameters
self.assertTrue(len(self.pl.find_all([1, 1])), 1)
# but find duplicates
self.pl.set([1, 1])
self.assertTrue(len(self.pl.find_all([1])), 2)
def test_find_all_some_missing(self):
to_find = [1, 4, 18, 5, 8, 9, -1]
iters = self.pl.find_all(to_find)
to_find.remove(18)
to_find.remove(-1)
for i, v in zip(iters, to_find):
self.failUnlessEqual(self.pl[i][0], v)
def test_find_all_empty(self):
to_find = [100, 200, -11]
iters = self.pl.find_all(to_find)
self.failUnlessEqual(iters, [])
def test_contains(self):
self.failUnless(1 in self.pl)
self.failUnless(8 in self.pl)
self.failIf(22 in self.pl)
def test_removal(self):
self.pl.go_to(8)
for i in range(3, 8):
self.pl.remove(self.pl.find(i))
self.pl.next()
self.failUnlessEqual(self.pl.current, 9)
def test_next_repeat(self):
self.pl.repeat = True
self.pl.go_to(3)
for i in range(9):
self.pl.next()
self.assertEqual(self.pl.current, 2)
for i in range(12):
self.pl.next()
self.assertEqual(self.pl.current, 4)
def test_shuffle(self):
self.pl.order = ORDERS[1](self.pl)
for i in range(5):
numbers = [
self.pl.current for i in range(10) if self.pl.next() or True
]
self.assertNotEqual(numbers, list(range(10)))
numbers.sort()
self.assertEqual(numbers, list(range(10)))
self.pl.next()
self.assertEqual(self.pl.current, None)
def test_weighted(self):
self.pl.order = ORDERS[2](self.pl)
r0 = AudioFile({'~#rating': 0})
r1 = AudioFile({'~#rating': 1})
r2 = AudioFile({'~#rating': 2})
r3 = AudioFile({'~#rating': 3})
self.pl.set([r0, r1, r2, r3])
Gtk.main_iteration_do(False)
songs = [
self.pl.current for i in range(1000) if self.pl.next() or True
]
self.assert_(songs.count(r1) > songs.count(r0))
self.assert_(songs.count(r2) > songs.count(r1))
self.assert_(songs.count(r3) > songs.count(r2))
def test_shuffle_repeat(self):
self.pl.order = ORDERS[1](self.pl)
self.pl.repeat = True
numbers = [
self.pl.current for i in range(30) if self.pl.next() or True
]
allnums = list(range(10)) * 3
allnums.sort()
self.assertNotEqual(numbers, allnums)
numbers.sort()
self.assertEqual(numbers, allnums)
def test_onesong(self):
self.pl.go_to(3)
self.pl.order = ORDERS[3](self.pl)
self.failUnlessEqual(self.pl.current, 3)
self.pl.next()
self.failUnlessEqual(self.pl.current, 4)
self.pl.next_ended()
self.failUnlessEqual(self.pl.current, None)
def test_onesong_repeat(self):
self.pl.go_to(3)
self.pl.order = ORDERS[3](self.pl)
self.pl.repeat = True
self.failUnlessEqual(self.pl.current, 3)
self.pl.next()
self.failUnlessEqual(self.pl.current, 4)
self.pl.next_ended()
self.failUnlessEqual(self.pl.current, 4)
def test_previous(self):
self.pl.go_to(2)
self.failUnlessEqual(self.pl.current, 2)
self.pl.previous()
self.failUnlessEqual(self.pl.current, 1)
self.pl.previous()
self.failUnlessEqual(self.pl.current, 0)
self.pl.previous()
self.failUnlessEqual(self.pl.current, 0)
def test_go_to_saves_current(self):
self.pl.go_to(5)
self.failUnlessEqual(self.pl.current, 5)
self.pl.set([5, 10, 15, 20])
Gtk.main_iteration_do(False)
self.pl.next()
self.failUnlessEqual(self.pl.current, 10)
def test_go_to_order(self):
self.pl.order = ORDERS[1](self.pl)
for i in range(5):
self.pl.go_to(5)
self.failUnlessEqual(self.pl.current, 5)
self.pl.go_to(1)
self.failUnlessEqual(self.pl.current, 1)
def test_go_to(self):
class SetOrder(Order):
# most orders don't change iter here,
# so make sure this gets handled right
def set_explicit(self, playlist, iter):
return playlist.iter_next(iter)
def set_implicit(self, playlist, iter):
return playlist.iter_next(playlist.iter_next(iter))
self.pl.order = SetOrder(self.pl)
self.failUnlessEqual(self.pl[self.pl.go_to(5, True)][0], 6)
self.failUnlessEqual(self.pl[self.pl.go_to(5, False)][0], 7)
def test_go_to_none(self):
for i in range(5):
self.pl.go_to(None)
self.failUnlessEqual(self.pl.current, None)
self.pl.next()
self.failUnlessEqual(self.pl.current, 0)
def test_reset(self):
self.pl.go_to(5)
self.failUnlessEqual(self.pl.current, 5)
self.pl.reset()
self.failUnlessEqual(self.pl.current, 0)
def test_reset_order(self):
self.pl.order = ORDERS[0](self.pl)
self.pl.go_to(5)
self.failUnlessEqual(self.pl.current, 5)
self.pl.reset()
self.failUnlessEqual(self.pl.current, 0)
def test_restart(self):
self.pl.go_to(1)
self.pl.set([101, 102, 103, 104])
Gtk.main_iteration_do(False)
self.pl.next()
self.failUnlessEqual(self.pl.current, 101)
def test_next_nosong_536(self):
self.pl.go_to(1)
self.pl.repeat = True
self.pl.order = ORDERS[1](self.pl)
self.pl.set([])
Gtk.main_iteration_do(False)
self.pl.next()
def test_clear_current(self):
self.pl.go_to(1)
self.pl.clear()
self.pl.go_to(None)
def shutDown(self):
self.pl.destroy()