class TVolume(TestCase):
def setUp(self):
self.p = NullPlayer()
self.v = Volume(self.p)
def test_setget(self):
for i in [0.0, 1.2, 0.24, 1.0, 0.9]:
self.v.set_value(i)
self.failUnlessAlmostEqual(self.p.volume, self.v.get_value() ** 3)
def test_add(self):
self.v.set_value(0.5)
self.v += 0.1
self.failUnlessAlmostEqual(self.p.volume, 0.6 ** 3)
def test_sub(self):
self.v.set_value(0.5)
self.v -= 0.1
self.failUnlessAlmostEqual(self.p.volume, 0.4 ** 3)
def test_add_boundry(self):
self.v.set_value(0.95)
self.v += 0.1
self.failUnlessAlmostEqual(self.p.volume, 1.0)
def test_sub_boundry(self):
self.v.set_value(0.05)
self.v -= 0.1
self.failUnlessAlmostEqual(self.p.volume, 0.0)
def tearDown(self):
self.p.destroy()
self.v.destroy()
class TVolume(TestCase):
def setUp(self):
self.p = NullPlayer()
self.v = Volume(self.p)
def test_setget(self):
for i in [0.0, 1.2, 0.24, 1.0, 0.9]:
self.v.set_value(i)
self.failUnlessAlmostEqual(self.p.volume, self.v.get_value() ** 3)
def test_add(self):
self.v.set_value(0.5)
self.v += 0.1
self.failUnlessAlmostEqual(self.p.volume, 0.6 ** 3)
def test_sub(self):
self.v.set_value(0.5)
self.v -= 0.1
self.failUnlessAlmostEqual(self.p.volume, 0.4 ** 3)
def test_add_boundry(self):
self.v.set_value(0.95)
self.v += 0.1
self.failUnlessAlmostEqual(self.p.volume, 1.0)
def test_sub_boundry(self):
self.v.set_value(0.05)
self.v -= 0.1
self.failUnlessAlmostEqual(self.p.volume, 0.0)
def tearDown(self):
self.p.destroy()
self.v.destroy()
def setUp(self):
self.q = PlaylistModel()
self.pl = PlaylistModel()
self.p = NullPlayer()
self.mux = PlaylistMux(self.p, self.q, self.pl)
self.p.setup(self.mux, None, 0)
self.failUnless(self.pl.current is None)
def setUp(self):
config.init()
player = NullPlayer()
song = AudioFile()
song.bookmarks = [(10, "bla")]
song.sanitize(fsnative(u"/"))
player.song = song
self.player = player
def setUp(self):
config.init()
player = NullPlayer()
song = AudioFile()
song.bookmarks = [(10, "bla")]
song.sanitize("/")
player.song = song
self.player = player
def setUp(self):
config.init()
player = NullPlayer()
song = AudioFile()
song.bookmarks = [(10, "bla")]
song.sanitize(fsnative(u"/"))
player.song = song
self.player = player
self.library = SongLibrary()
class TFIFOControl(TestCase):
def setUp(self):
config.init()
self.p = NullPlayer()
self.l = SongFileLibrary()
self.w = gtk.Window()
self.fifo = FIFOControl(self.l, self.w, self.p)
def tearDown(self):
self.p.destroy()
self.l.destroy()
self.w.destroy()
config.quit()
def __send(self, command):
f = open(const.CONTROL, "wb")
f.write(command)
f.close()
while gtk.events_pending():
gtk.main_iteration()
def test_player(self):
self.__send("previous")
self.__send("force_previous")
self.__send("next")
self.__send("pause")
self.__send("play-pause")
self.__send("stop")
self.__send("volume +1000")
self.__send("volume 40")
self.__send("volume -10")
#self.__send("seek -10")
#self.__send("seek +10")
#self.__send("seek 0")
def test_misc(self):
#self.__send("add-directory /dev/null")
self.__send("add-file /dev/null")
#self.__send("dump-playlist /dev/null")
#self.__send("dump_queue /dev/null")
#self.__send("enqueue /dev/null")
self.__send("enqueue-files /dev/null")
#self.__send("filter album=test")
#self.__send("focus")
#self.__send("hide-window")
#self.__send("open-browser 1")
#self.__send("order shuffle")
self.__send("properties")
#self.__send("queue 1")
self.__send("quit")
#self.__send("random album")
#self.__send("refresh")
#self.__send("repeat 0")
#self.__send("set-browser 1")
self.__send("set-rating 0.5")
def setUp(self):
self.p = NullPlayer()
self.w = SongLibrary()
self.s1 = AudioFile(
{"~#playcount": 0, "~#skipcount": 0, "~#lastplayed": 10,
"~filename": "foo", "~#length": 1.5})
self.s2 = AudioFile(
{"~#playcount": 0, "~#skipcount": 0, "~#lastplayed": 10,
"~filename": "foo", "~#length": 1.5})
self.cm = SongTracker(self.w, self.p, self)
self.current = None
def test_main(self):
WaveformScale = self.mod.WaveformScale
player = NullPlayer()
player.info = AudioFile({"~#length": 10})
scale = WaveformScale(player)
scale.compute_redraw_interval()
scale.compute_redraw_area()
with visible(scale):
scale.compute_redraw_interval()
scale.compute_redraw_area()
def setUp(self):
self.p = NullPlayer()
self.dir = mkdtemp()
self.lib = FileLibrary()
self.song = AudioFile({
"~filename": A_PATH,
"title": "bar",
"~#length": 10
})
self.lib.add([self.song])
self.filename = os.path.join(self.dir, "foo")
self.fs = FSInterface(self.filename, self.p, self.lib)
def test_main(self):
WaveformScale = self.mod.WaveformScale
player = NullPlayer()
player.info = AudioFile({"~#length": 10})
scale = WaveformScale(player)
scale.compute_redraw_interval()
scale.compute_redraw_area()
with visible(scale):
scale.compute_redraw_interval()
scale.compute_redraw_area()
class TFSInterface(TestCase):
def setUp(self):
self.p = NullPlayer()
self.fs = FSInterface(self.p)
def do(self):
while Gtk.events_pending():
Gtk.main_iteration()
def test_init(self):
self.do()
self.failIf(os.path.exists(const.CURRENT))
def test_start(self):
self.p.emit('song_started', AudioFile({"woo": "bar", "~#length": 10}))
self.do()
self.failUnless("woo=bar\n" in file(const.CURRENT).read())
def test_song_ended(self):
self.p.emit('song-started', AudioFile({"woo": "bar", "~#length": 10}))
self.do()
self.p.emit('song-ended', {}, False)
self.do()
self.failIf(os.path.exists(const.CURRENT))
def tearDown(self):
self.p.destroy()
try:
os.unlink(const.CURRENT)
except EnvironmentError:
pass
class TSongTracker(TestCase):
def setUp(self):
config.init()
self.p = NullPlayer()
self.w = SongLibrary()
self.s1 = AudioFile(
{"~#playcount": 0, "~#skipcount": 0, "~#lastplayed": 10,
"~filename": "foo", "~#length": 1.5})
self.s2 = AudioFile(
{"~#playcount": 0, "~#skipcount": 0, "~#lastplayed": 10,
"~filename": "foo", "~#length": 1.5})
self.cm = SongTracker(self.w, self.p, self)
self.current = None
def do(self):
while Gtk.events_pending():
Gtk.main_iteration()
def test_destroy(self):
self.cm.destroy()
def test_play(self):
import time
# Allow at least 2 second to elapse to simulate playing
self.p.song = self.s1
self.p.paused = False
time.sleep(2)
self.do()
self.p.emit('song-ended', self.s1, False)
self.do()
t = time.time()
self.assertEquals(self.s1["~#playcount"], 1)
self.assertEquals(self.s1["~#skipcount"], 0)
self.failUnless(t - self.s1["~#lastplayed"] <= 1)
def test_skip(self):
self.p.emit('song-ended', self.s1, True)
self.do()
self.assertEquals(self.s1["~#playcount"], 0)
self.assertEquals(self.s1["~#skipcount"], 1)
self.failUnless(self.s1["~#lastplayed"], 10)
def test_error(self):
self.current = self.p.song = self.s1
self.p._error('Test error')
self.do()
self.assertEquals(self.s1["~#playcount"], 0)
self.assertEquals(self.s1["~#skipcount"], 0)
self.failUnless(self.s1["~#lastplayed"], 10)
def test_restart(self):
self.current = self.s1
self.p.emit('song-ended', self.s1, True)
self.do()
self.assertEquals(self.s1["~#playcount"], 0)
self.assertEquals(self.s1["~#skipcount"], 0)
def tearDown(self):
self.w.destroy()
config.quit()
class TFSInterface(TestCase):
def setUp(self):
self.p = NullPlayer()
self.fs = FSInterface(self.p)
def do(self):
while gtk.events_pending(): gtk.main_iteration()
def test_init(self):
self.do()
self.failIf(os.path.exists(const.CURRENT))
def test_start(self):
self.p.emit('song_started', AudioFile({"woo": "bar", "~#length": 10}))
self.do()
self.failUnless("woo=bar\n" in file(const.CURRENT).read())
def test_song_ended(self):
self.p.emit('song-started', AudioFile({"woo": "bar", "~#length": 10}))
self.do()
self.p.emit('song-ended', {}, False)
self.do()
self.failIf(os.path.exists(const.CURRENT))
def tearDown(self):
self.p.destroy()
try: os.unlink(const.CURRENT)
except EnvironmentError: pass
class TFSInterface(TestCase):
def setUp(self):
self.p = NullPlayer()
self.dir = mkdtemp()
self.filename = os.path.join(self.dir, "foo")
self.fs = FSInterface(self.filename, self.p)
def tearDown(self):
self.p.destroy()
shutil.rmtree(self.dir)
def do(self):
while Gtk.events_pending():
Gtk.main_iteration()
def test_init(self):
self.do()
self.failIf(os.path.exists(self.filename))
def test_start(self):
self.p.emit('song_started', AudioFile({"woo": "bar", "~#length": 10}))
self.do()
with open(self.filename, "rb") as h:
self.failUnless(b"woo=bar\n" in h.read())
def test_song_ended(self):
self.p.emit('song-started', AudioFile({"woo": "bar", "~#length": 10}))
self.do()
self.p.emit('song-ended', {}, False)
self.do()
self.failIf(os.path.exists(self.filename))
class TSongTracker(TestCase):
def setUp(self):
config.init()
self.p = NullPlayer()
self.w = SongLibrary()
self.s1 = AudioFile(
{"~#playcount": 0, "~#skipcount": 0, "~#lastplayed": 10,
"~filename": "foo", "~#length": 1.5})
self.s2 = AudioFile(
{"~#playcount": 0, "~#skipcount": 0, "~#lastplayed": 10,
"~filename": "foo", "~#length": 1.5})
self.cm = SongTracker(self.w, self.p, self)
self.current = None
def do(self):
while Gtk.events_pending():
Gtk.main_iteration()
def test_destroy(self):
self.cm.destroy()
def test_play(self):
import time
# Allow at least 2 second to elapse to simulate playing
self.p.song = self.s1
self.p.paused = False
time.sleep(2)
self.do()
self.p.emit('song-ended', self.s1, False)
self.do()
t = time.time()
self.assertEquals(self.s1["~#playcount"], 1)
self.assertEquals(self.s1["~#skipcount"], 0)
self.failUnless(t - self.s1["~#lastplayed"] <= 1)
def test_skip(self):
self.p.emit('song-ended', self.s1, True)
self.do()
self.assertEquals(self.s1["~#playcount"], 0)
self.assertEquals(self.s1["~#skipcount"], 1)
self.failUnless(self.s1["~#lastplayed"], 10)
def test_error(self):
self.current = self.p.song = self.s1
self.p._error('Test error')
self.do()
self.assertEquals(self.s1["~#playcount"], 0)
self.assertEquals(self.s1["~#skipcount"], 0)
self.failUnless(self.s1["~#lastplayed"], 10)
def test_restart(self):
self.current = self.s1
self.p.emit('song-ended', self.s1, True)
self.do()
self.assertEquals(self.s1["~#playcount"], 0)
self.assertEquals(self.s1["~#skipcount"], 0)
def tearDown(self):
self.w.destroy()
config.quit()
class TFSInterface(TestCase):
def setUp(self):
self.p = NullPlayer()
self.dir = mkdtemp()
self.filename = os.path.join(self.dir, "foo")
self.fs = FSInterface(self.filename, self.p)
def tearDown(self):
self.p.destroy()
shutil.rmtree(self.dir)
def do(self):
while Gtk.events_pending():
Gtk.main_iteration()
def test_init(self):
self.do()
self.failIf(os.path.exists(self.filename))
def test_start(self):
self.p.emit('song_started', AudioFile({"woo": "bar", "~#length": 10}))
self.do()
self.failUnless("woo=bar\n" in file(self.filename).read())
def test_song_ended(self):
self.p.emit('song-started', AudioFile({"woo": "bar", "~#length": 10}))
self.do()
self.p.emit('song-ended', {}, False)
self.do()
self.failIf(os.path.exists(self.filename))
def setUp(self):
self.q = PlaylistModel()
self.pl = PlaylistModel()
self.p = NullPlayer()
self.mux = PlaylistMux(self.p, self.q, self.pl)
self.p.setup(self.mux, None, 0)
self.failUnless(self.pl.current is None)
def test_ctr(self):
from quodlibet.library import SongLibrary
from quodlibet.browsers.empty import EmptyBar
win = LibraryBrowser(EmptyBar, SongLibrary(), NullPlayer())
win.browser.emit("songs-selected", [], False)
win.songlist.get_selection().emit("changed")
win.destroy()
def test_no_gstreamer_rms(self):
player = NullPlayer()
library = Library()
bar = self.mod.WaveformSeekBar(player, library)
message = FakeRMSMessage()
bar._on_bus_message(None, message, 1234)
def test_open(self):
from quodlibet.browsers.tracks import TrackList
from quodlibet.library import SongLibrary
widget = LibraryBrowser.open(TrackList, SongLibrary(), NullPlayer())
self.assertTrue(widget)
self.assertTrue(widget.get_visible())
widget.destroy()
def test_open(self):
from quodlibet.browsers.empty import EmptyBar
from quodlibet.library import SongLibrary
widget = LibraryBrowser.open(EmptyBar, SongLibrary(), NullPlayer())
self.assertTrue(widget)
self.assertTrue(widget.get_visible())
widget.destroy()
def setUp(self):
self.p = NullPlayer()
self.w = SongLibrary()
self.s1 = AudioFile(
{"~#playcount": 0, "~#skipcount": 0, "~#lastplayed": 10,
"~filename": "foo", "~#length": 1.5})
self.s2 = AudioFile(
{"~#playcount": 0, "~#skipcount": 0, "~#lastplayed": 10,
"~filename": "foo", "~#length": 1.5})
self.cm = SongTracker(self.w, self.p, self)
self.current = None
def setUp(self):
config.init()
class App(Application):
browser = None
app = App()
app.player = NullPlayer()
app.library = SongFileLibrary()
app.library.librarian = SongLibrarian()
app.browser = EmptyBar(app.library, True)
app.window = Gtk.OffscreenWindow()
self.fifo = FIFOControl(app)
def init_fake_app():
from quodlibet import app
from quodlibet import browsers
from quodlibet.player.nullbe import NullPlayer
from quodlibet.library.libraries import SongFileLibrary
from quodlibet.library.librarians import SongLibrarian
from quodlibet.qltk.quodlibetwindow import QuodLibetWindow
from quodlibet.util.cover import CoverManager
browsers.init()
app.name = "Quod Libet"
app.id = "quodlibet"
app.player = NullPlayer()
app.library = SongFileLibrary()
app.library.librarian = SongLibrarian()
app.cover_manager = CoverManager()
app.window = QuodLibetWindow(app.library, app.player, headless=True)
def test_save_restore(self):
player = NullPlayer()
lib = SongLibrary()
lib.librarian = None
lib.add([DUMMY_SONG])
try:
os.unlink(QUEUE)
except OSError:
pass
q = PlayQueue(lib, player)
q.get_model().append(row=[DUMMY_SONG])
q.destroy()
q = PlayQueue(lib, player)
model = q.get_model()
assert model.values()[0] is DUMMY_SONG
def setUp(self):
init_fake_app()
fd, self.filename = mkstemp()
os.close(fd)
self.info = SongInfo(SongLibrary(), NullPlayer(), self.filename)
class TPlaylistMux(TestCase):
def setUp(self):
self.q = PlaylistModel()
self.pl = PlaylistModel()
self.p = NullPlayer()
self.mux = PlaylistMux(self.p, self.q, self.pl)
self.p.setup(self.mux, None, 0)
self.failUnless(self.pl.current is None)
quodlibet.config.init()
def test_destroy(self):
self.mux.destroy()
def test_only_pl(self):
self.pl.set(range(10))
do_events()
self.failUnless(self.mux.current is None)
songs = [self.next() for i in range(10)]
self.failUnlessEqual(songs, list(range(10)))
self.next()
self.failUnless(self.mux.current is None)
def test_only_q(self):
self.q.set(range(10))
do_events()
self.failUnless(self.mux.current is None)
songs = [self.next() for i in range(10)]
self.failUnlessEqual(songs, list(range(10)))
self.next()
self.failUnless(self.mux.current is None)
def test_mixed(self):
self.q.set(range(5))
self.pl.set(range(5, 10))
do_events()
self.failUnless(self.mux.current is None)
songs = [self.next() for i in range(10)]
self.failUnlessEqual(songs, list(range(10)))
self.next()
self.failUnless(self.mux.current is None)
def test_newplaylist(self):
self.pl.set(range(5, 10))
do_events()
self.failUnless(self.mux.current is None)
self.mux.go_to(7)
self.failUnlessEqual(self.mux.current, 7)
self.pl.set([3, 5, 12, 11])
do_events()
self.failUnlessEqual(self.mux.current, None)
self.pl.set([19, 8, 12, 3])
do_events()
self.failUnlessEqual(self.mux.current, None)
self.pl.set([3, 7, 9, 11])
do_events()
self.mux.next()
self.failUnlessEqual(self.mux.current, 9)
def test_halfway(self):
self.pl.set(range(10))
do_events()
self.failUnless(self.mux.current is None)
songs = [self.next() for i in range(5)]
self.q.set(range(100, 105))
do_events()
songs.extend([self.next() for i in range(10)])
self.failUnlessEqual(
songs, [0, 1, 2, 3, 4, 100, 101, 102, 103, 104, 5, 6, 7, 8, 9])
self.next()
self.failUnless(self.mux.current is None)
def test_removal(self):
self.pl.set(range(0, 5))
self.q.set(range(10, 15))
do_events()
songs = [self.next() for i in range(3)]
self.q.remove(self.q.find(14))
self.q.remove(self.q.find(13))
songs.extend([self.next() for i in range(5)])
self.failUnlessEqual(songs, [10, 11, 12, 0, 1, 2, 3, 4])
def next(self):
self.mux.next()
song = self.mux.current
self.p.emit('song-started', self.mux.current)
do_events()
return song
def test_goto(self):
self.pl.set(range(10))
self.q.set(range(10, 20))
do_events()
self.failUnless(self.mux.current is None)
self.mux.go_to(5)
self.failUnlessEqual(self.mux.current, 5)
self.mux.go_to(2)
self.failUnlessEqual(self.mux.current, 2)
self.failUnlessEqual(self.next(), 10)
self.mux.go_to(7)
self.failUnlessEqual(self.mux.current, 7)
self.failUnlessEqual(self.next(), 11)
def test_random_queue_666(self):
for i in range(5):
self.mux.go_to(None)
self.pl.set([1])
do_events()
self.failUnless(self.mux.current is None)
self.q.order = OrderShuffle()
self.failUnless(self.next() == 1)
self.q.set([10, 11])
do_events()
value = self.next()
self.failUnless(
value in [10, 11], "got %r, expected 10 or 11" % value)
if value == 10:
next = 11
else:
next = 10
self.failUnlessEqual(self.next(), next)
def test_sourced(self):
self.pl.set(range(10))
self.q.set(range(10))
self.mux.go_to(None)
self.failUnless(self.pl.sourced)
self.q.go_to(1)
self.p.next()
self.failIf(self.pl.sourced)
def test_unqueue(self):
self.q.set(range(100))
self.mux.unqueue(range(100))
self.failIf(len(self.q))
def test_queue(self):
self.mux.enqueue(range(40))
self.failUnlessEqual(list(self.q.itervalues()), list(range(40)))
def test_queue_move_entry(self):
self.q.set(range(10))
self.p.next()
self.assertEqual(self.p.song, 0)
self.q.move_after(self.q[-1].iter, None)
self.p.next()
self.assertEqual(self.p.song, 9)
def test_goto_queue(self):
self.pl.set(range(20, 30))
self.q.set(range(10))
self.mux.go_to(self.q[-1].iter, source=self.q)
self.assertTrue(self.q.sourced)
self.assertEqual(self.mux.current, self.q[-1][0])
def test_queue_disable(self):
self.pl.set(range(10))
self.q.set(range(10))
quodlibet.config.set("memory", "queue_disable", True)
self.next()
self.failUnlessEqual(len(self.pl.get()), len(range(10)))
self.failUnlessEqual(len(self.q.get()), len(range(10)))
self.assertTrue(self.pl.sourced)
quodlibet.config.set("memory", "queue_disable", False)
self.next()
self.failUnlessEqual(len(self.pl.get()), len(range(10)))
self.failUnlessEqual(len(self.q.get()), len(range(10)) - 1)
self.assertTrue(self.q.sourced)
def test_queue_keep_songs(self):
self.q.set(range(10))
quodlibet.config.set("memory", "queue_keep_songs", True)
self.next()
self.failUnlessEqual(len(self.q.get()), len(range(10)))
self.failUnlessEqual(self.q.current, None)
self.mux.go_to(self.q[0].iter, source=self.q)
self.failUnlessEqual(self.q.current, 0)
self.next()
self.failUnlessEqual(len(self.q.get()), len(range(10)))
self.failUnlessEqual(self.q.current, 1)
quodlibet.config.set("memory", "queue_keep_songs", False)
self.next()
self.failUnlessEqual(len(self.q.get()), len(range(10)) - 1)
self.failUnless(self.q.current is None)
def test_queue_disable_and_keep_songs(self):
self.pl.set(range(10))
self.q.set(range(10))
self.mux.go_to(self.q[0].iter, source=self.q)
quodlibet.config.set("memory", "queue_disable", True)
quodlibet.config.set("memory", "queue_keep_songs", True)
self.next()
self.assertTrue(self.pl.sourced)
def tearDown(self):
self.p.destroy()
class TPlaylistMux(TestCase):
def setUp(self):
self.q = PlaylistModel()
self.pl = PlaylistModel()
self.p = NullPlayer()
self.mux = PlaylistMux(self.p, self.q, self.pl)
self.p.setup(self.mux, None, 0)
self.failUnless(self.pl.current is None)
def test_destroy(self):
self.mux.destroy()
def test_only_pl(self):
self.pl.set(range(10))
do_events()
self.failUnless(self.mux.current is None)
songs = [self.next() for i in range(10)]
self.failUnlessEqual(songs, list(range(10)))
self.next()
self.failUnless(self.mux.current is None)
def test_only_q(self):
self.q.set(range(10))
do_events()
self.failUnless(self.mux.current is None)
songs = [self.next() for i in range(10)]
self.failUnlessEqual(songs, list(range(10)))
self.next()
self.failUnless(self.mux.current is None)
def test_mixed(self):
self.q.set(range(5))
self.pl.set(range(5, 10))
do_events()
self.failUnless(self.mux.current is None)
songs = [self.next() for i in range(10)]
self.failUnlessEqual(songs, list(range(10)))
self.next()
self.failUnless(self.mux.current is None)
def test_newplaylist(self):
self.pl.set(range(5, 10))
do_events()
self.failUnless(self.mux.current is None)
self.mux.go_to(7)
self.failUnlessEqual(self.mux.current, 7)
self.pl.set([3, 5, 12, 11])
do_events()
self.failUnlessEqual(self.mux.current, None)
self.pl.set([19, 8, 12, 3])
do_events()
self.failUnlessEqual(self.mux.current, None)
self.pl.set([3, 7, 9, 11])
do_events()
self.mux.next()
self.failUnlessEqual(self.mux.current, 9)
def test_halfway(self):
self.pl.set(range(10))
do_events()
self.failUnless(self.mux.current is None)
songs = [self.next() for i in range(5)]
self.q.set(range(100, 105))
do_events()
songs.extend([self.next() for i in range(10)])
self.failUnlessEqual(
songs, [0, 1, 2, 3, 4, 100, 101, 102, 103, 104, 5, 6, 7, 8, 9])
self.next()
self.failUnless(self.mux.current is None)
def test_removal(self):
self.pl.set(range(0, 5))
self.q.set(range(10, 15))
do_events()
songs = [self.next() for i in range(3)]
self.q.remove(self.q.find(14))
self.q.remove(self.q.find(13))
songs.extend([self.next() for i in range(5)])
self.failUnlessEqual(songs, [10, 11, 12, 0, 1, 2, 3, 4])
def next(self):
self.mux.next()
song = self.mux.current
self.p.emit('song-started', self.mux.current)
do_events()
return song
def test_goto(self):
self.pl.set(range(10))
self.q.set(range(10, 20))
do_events()
self.failUnless(self.mux.current is None)
self.mux.go_to(5)
self.failUnlessEqual(self.mux.current, 5)
self.mux.go_to(2)
self.failUnlessEqual(self.mux.current, 2)
self.failUnlessEqual(self.next(), 10)
self.mux.go_to(7)
self.failUnlessEqual(self.mux.current, 7)
self.failUnlessEqual(self.next(), 11)
def test_random_queue_666(self):
for i in range(5):
self.mux.go_to(None)
self.pl.set([1])
do_events()
self.failUnless(self.mux.current is None)
self.q.order = ORDERS[1](self.pl)
self.failUnless(self.next() == 1)
self.q.set([10, 11])
do_events()
value = self.next()
self.failUnless(
value in [10, 11], "got %r, expected 10 or 11" % value)
if value == 10:
next = 11
else:
next = 10
self.failUnlessEqual(self.next(), next)
def test_sourced(self):
self.pl.set(range(10))
self.q.set(range(10))
self.mux.go_to(None)
self.failUnless(self.pl.sourced)
self.q.go_to(1)
self.p.next()
self.failIf(self.pl.sourced)
def test_unqueue(self):
self.q.set(range(100))
self.mux.unqueue(range(100))
self.failIf(len(self.q))
def test_queue(self):
self.mux.enqueue(range(40))
self.failUnlessEqual(list(self.q.itervalues()), list(range(40)))
def test_queue_move_entry(self):
self.q.set(range(10))
self.p.next()
self.assertEqual(self.p.song, 0)
self.q.move_after(self.q[-1].iter, None)
self.p.next()
self.assertEqual(self.p.song, 9)
def test_goto_queue(self):
self.pl.set(range(20, 30))
self.q.set(range(10))
self.mux.go_to(self.q[-1].iter, source=self.q)
self.assertTrue(self.q.sourced)
self.assertEqual(self.mux.current, self.q[-1][0])
def tearDown(self):
self.p.destroy()
def setUp(self):
quodlibet.config.init()
player = NullPlayer()
self.queue = QueueExpander(Gtk.CheckMenuItem(), SongLibrary(), player)
def setUp(self):
quodlibet.config.init()
self.bar = FileSystem(SongLibrary(), NullPlayer())
def setUp(self):
self.p = NullPlayer()
self.dir = mkdtemp()
self.filename = os.path.join(self.dir, "foo")
self.fs = FSInterface(self.filename, self.p)
def setUp(self):
self.p = NullPlayer()
self.v = Volume(self.p)
def setUp(self):
self.p = NullPlayer()
self.fs = FSInterface(self.p)
def setUp(self):
config.init()
self.p = NullPlayer()
self.l = SongFileLibrary()
self.w = gtk.Window()
self.fifo = FIFOControl(self.l, self.w, self.p)
def setUp(self):
self.p = NullPlayer()
self.dir = mkdtemp()
self.filename = os.path.join(self.dir, "foo")
self.fs = FSInterface(self.filename, self.p)
def test_ctr(self):
AboutQuodLibet(None, NullPlayer()).destroy()
def setUp(self):
self.win = Gtk.Window()
self.keys = init(self.win, NullPlayer())
def test_ctr(self):
win = LibraryBrowser(AlbumList, self.library, NullPlayer())
win.browser.emit("songs-selected", [], False)
win.songlist.get_selection().emit("changed")
win.destroy()
def setUp(self):
self.p = NullPlayer()
self.v = Volume(self.p)
def test_open(self):
self.library.librarian = SongLibrarian()
widget = LibraryBrowser.open(TrackList, self.library, NullPlayer())
self.assertTrue(widget)
self.assertTrue(widget.get_visible())
widget.destroy()
class TFSInterface(TestCase):
def setUp(self):
self.p = NullPlayer()
self.dir = mkdtemp()
self.lib = FileLibrary()
self.song = AudioFile({
"~filename": A_PATH,
"title": "bar",
"~#length": 10
})
self.lib.add([self.song])
self.filename = os.path.join(self.dir, "foo")
self.fs = FSInterface(self.filename, self.p, self.lib)
def tearDown(self):
self.p.destroy()
self.lib.destroy()
shutil.rmtree(self.dir)
def test_init(self):
run_gtk_loop()
self.failIf(os.path.exists(self.filename))
def test_start(self):
self.p.emit('song_started', self.song)
run_gtk_loop()
with open(self.filename, "rb") as h:
self.failUnless(b"title=bar\n" in h.read())
def test_song_ended(self):
self.p.emit('song-started', self.song)
run_gtk_loop()
self.p.emit('song-ended', {}, False)
run_gtk_loop()
self.failIf(os.path.exists(self.filename))
def test_elapsed(self):
self.p.seek(123456)
self.p.emit('song-started', AudioFile({"~#length": 10}))
run_gtk_loop()
with open(self.filename, "rb") as h:
contents = h.read()
assert b"~#elapsed=123.456" in contents
assert b"~elapsed=2:03\n" in contents
def test_current_song_changed(self):
self.p.song = self.song
self.song["title"] = "new!"
self.lib.changed([self.song])
run_gtk_loop()
with open(self.filename, "rb") as h:
contents = h.read()
assert b"title=new!\n" in contents
def setUp(self):
quodlibet.config.init()
self.p = NullPlayer()
self.v = Volume(self.p)
def setUp(self):
config.init()
self.p = NullPlayer()
self.l = SongLibrary()
class TPlaylistMux(TestCase):
def setUp(self):
self.q = PlaylistModel()
self.pl = PlaylistModel()
self.p = NullPlayer()
self.mux = PlaylistMux(self.p, self.q, self.pl)
self.p.setup(self.mux, None, 0)
self.failUnless(self.pl.current is None)
def test_only_pl(self):
self.pl.set(range(10))
do_events()
self.failUnless(self.mux.current is None)
songs = [self.next() for i in range(10)]
self.failUnlessEqual(songs, range(10))
self.next()
self.failUnless(self.mux.current is None)
def test_only_q(self):
self.q.set(range(10))
do_events()
self.failUnless(self.mux.current is None)
songs = [self.next() for i in range(10)]
self.failUnlessEqual(songs, range(10))
self.next()
self.failUnless(self.mux.current is None)
def test_mixed(self):
self.q.set(range(5))
self.pl.set(range(5, 10))
do_events()
self.failUnless(self.mux.current is None)
songs = [self.next() for i in range(10)]
self.failUnlessEqual(songs, range(10))
self.next()
self.failUnless(self.mux.current is None)
def test_newplaylist(self):
self.pl.set(range(5, 10))
do_events()
self.failUnless(self.mux.current is None)
self.mux.go_to(7)
self.failUnlessEqual(self.mux.current, 7)
self.pl.set([3, 5, 12, 11])
do_events()
self.failUnlessEqual(self.mux.current, None)
self.pl.set([19, 8, 12, 3])
do_events()
self.failUnlessEqual(self.mux.current, None)
self.pl.set([3, 7, 9, 11])
do_events()
self.mux.next()
self.failUnlessEqual(self.mux.current, 9)
def test_halfway(self):
self.pl.set(range(10))
do_events()
self.failUnless(self.mux.current is None)
songs = [self.next() for i in range(5)]
self.q.set(range(100, 105))
do_events()
songs.extend([self.next() for i in range(10)])
self.failUnlessEqual(
songs, [0, 1, 2, 3, 4, 100, 101, 102, 103, 104, 5, 6, 7, 8, 9])
self.next()
self.failUnless(self.mux.current is None)
def test_removal(self):
self.pl.set(range(0, 5))
self.q.set(range(10, 15))
do_events()
songs = [self.next() for i in range(3)]
self.q.remove(self.q.find(14))
self.q.remove(self.q.find(13))
songs.extend([self.next() for i in range(5)])
self.failUnlessEqual(songs, [10, 11, 12, 0, 1, 2, 3, 4])
def next(self):
self.mux.next()
song = self.mux.current
self.p.emit('song-started', self.mux.current)
do_events()
return song
def test_goto(self):
self.pl.set(range(10))
self.q.set(range(10, 20))
do_events()
self.failUnless(self.mux.current is None)
self.mux.go_to(5)
self.failUnlessEqual(self.mux.current, 5)
self.mux.go_to(2)
self.failUnlessEqual(self.mux.current, 2)
self.failUnlessEqual(self.next(), 10)
self.mux.go_to(7)
self.failUnlessEqual(self.mux.current, 7)
self.failUnlessEqual(self.next(), 11)
def test_random_queue_666(self):
for i in range(5):
self.mux.go_to(None)
self.pl.set([1])
do_events()
self.failUnless(self.mux.current is None)
self.q.order = ORDERS[1](self.pl)
self.failUnless(self.next() == 1)
self.q.set([10, 11])
do_events()
value = self.next()
self.failUnless(
value in [10, 11], "got %r, expected 10 or 11" % value)
if value == 10:
next = 11
else:
next = 10
self.failUnlessEqual(self.next(), next)
def test_sourced(self):
self.pl.set(range(10))
self.q.set(range(10))
self.mux.go_to(None)
self.failUnless(self.pl.sourced)
self.q.go_to(1)
self.p.next()
self.failIf(self.pl.sourced)
def test_unqueue(self):
self.q.set(range(100))
self.mux.unqueue(range(100))
self.failIf(len(self.q))
def test_queue(self):
self.mux.enqueue(range(40))
self.failUnlessEqual(list(self.q.itervalues()), range(40))
def tearDown(self):
self.p.destroy()
def test_ef(self):
AboutExFalso(None, NullPlayer()).destroy()
def setUp(self):
config.init()
self.p = NullPlayer()
self.v = Volume(self.p)
