257 lines
8.7 KiB
Python
257 lines
8.7 KiB
Python
# Copyright 2021 (c) Anna Schumaker.
|
|
import unittest
|
|
from gi.repository import GObject
|
|
from gi.repository import Gtk
|
|
from gi.repository import Gst
|
|
from . import scale
|
|
|
|
class FakePlayer(GObject.GObject):
|
|
def __init__(self, position, duration, volume):
|
|
GObject.GObject.__init__(self)
|
|
self.pos = position
|
|
self.dur = duration
|
|
self.vol = volume
|
|
|
|
@GObject.Property
|
|
def position(self): return self.pos
|
|
@position.setter
|
|
def position(self, newval):
|
|
self.pos = newval
|
|
self.emit("position-changed")
|
|
|
|
@GObject.Signal
|
|
def position_changed(self): pass
|
|
|
|
@GObject.Property
|
|
def duration(self): return self.dur
|
|
@GObject.Signal
|
|
def duration_changed(self): pass
|
|
|
|
def seek(self, value): self.seek_val = value
|
|
|
|
@GObject.Property
|
|
def volume(self): return self.vol
|
|
@volume.setter
|
|
def volume(self, volume): self.vol = volume
|
|
|
|
|
|
class TestScalePlus(unittest.TestCase):
|
|
def on_change_value(self, scale, scroll, value):
|
|
self.change_value = (scroll, value)
|
|
|
|
def test_scale_plus_init(self):
|
|
splus = scale.ScalePlus(1, 10, 2, 5)
|
|
adj = splus.get_adjustment()
|
|
|
|
self.assertIsInstance(splus, Gtk.Scale)
|
|
self.assertTrue(splus.get_draw_value())
|
|
self.assertTrue(splus.get_hexpand())
|
|
self.assertEqual(splus.get_value_pos(), Gtk.PositionType.TOP)
|
|
|
|
self.assertEqual(adj.get_value(), 1)
|
|
self.assertEqual(adj.get_lower(), 1)
|
|
self.assertEqual(adj.get_upper(), 10)
|
|
self.assertEqual(adj.get_step_increment(), 2)
|
|
self.assertEqual(adj.get_page_increment(), 5)
|
|
|
|
def test_scale_plus_decrement(self):
|
|
splus = scale.ScalePlus(1, 10, 2, 5)
|
|
splus.set_value(10)
|
|
splus.connect("change-value", self.on_change_value)
|
|
|
|
for i in [ 8, 6, 4, 2, 1 ]:
|
|
self.assertEqual(splus.decrement(), i)
|
|
self.assertEqual(splus.format_value(splus, i), str(i))
|
|
self.assertEqual(self.change_value,
|
|
(Gtk.ScrollType.STEP_BACKWARD, i))
|
|
|
|
self.change_value = None
|
|
self.assertIsNone(splus.decrement())
|
|
self.assertIsNone(self.change_value)
|
|
|
|
def test_scale_plus_increment(self):
|
|
splus = scale.ScalePlus(1, 10, 2, 5)
|
|
splus.connect("change-value", self.on_change_value)
|
|
|
|
for i in [ 3, 5, 7, 9, 10 ]:
|
|
self.assertEqual(splus.increment(), i)
|
|
self.assertEqual(splus.format_value(splus, i), str(i))
|
|
self.assertEqual(self.change_value,
|
|
(Gtk.ScrollType.STEP_FORWARD, i))
|
|
|
|
self.change_value = None
|
|
self.assertIsNone(splus.increment())
|
|
self.assertIsNone(self.change_value)
|
|
|
|
|
|
class TestSeekScale(unittest.TestCase):
|
|
def test_seek_scale_init(self):
|
|
fake = FakePlayer(0, 5 * Gst.SECOND, 1)
|
|
seek = scale.SeekScale(fake)
|
|
adj = seek.get_adjustment()
|
|
|
|
self.assertIsInstance(seek, scale.ScalePlus)
|
|
|
|
self.assertEqual(seek.get_size_request(), (200, -1))
|
|
self.assertEqual(seek.player, fake)
|
|
self.assertEqual(adj.get_value(), 0)
|
|
self.assertEqual(adj.get_lower(), 0)
|
|
self.assertEqual(adj.get_upper(), 5 * Gst.SECOND)
|
|
self.assertEqual(adj.get_step_increment(), 5 * Gst.SECOND)
|
|
self.assertEqual(adj.get_page_increment(), 30 * Gst.SECOND)
|
|
|
|
def test_seek_scale_duration(self):
|
|
fake = FakePlayer(0, 2 * Gst.SECOND, 1)
|
|
seek = scale.SeekScale(fake)
|
|
adj = seek.get_adjustment()
|
|
|
|
self.assertEqual(adj.get_upper(), 2 * Gst.SECOND)
|
|
fake.dur = 3 * Gst.SECOND
|
|
fake.emit("duration-changed")
|
|
self.assertEqual(adj.get_upper(), 3 * Gst.SECOND)
|
|
|
|
def test_seek_scale_position(self):
|
|
fake = FakePlayer(0, 15 * Gst.SECOND, 1)
|
|
seek = scale.SeekScale(fake)
|
|
adj = seek.get_adjustment()
|
|
|
|
fake.position = 3 * Gst.SECOND
|
|
self.assertEqual(seek.player, fake)
|
|
self.assertEqual(adj.get_value(), 3 * Gst.SECOND)
|
|
self.assertEqual(adj.get_lower(), 0)
|
|
|
|
def test_seek_scale_values(self):
|
|
fake = FakePlayer(0, 15 * Gst.SECOND, 1)
|
|
seek = scale.SeekScale(fake)
|
|
|
|
seek.increment()
|
|
self.assertEqual(fake.pos, 5 * Gst.SECOND)
|
|
self.assertEqual(seek.format_value(seek, 5 * Gst.SECOND),
|
|
"00:05 / 00:10")
|
|
|
|
seek.decrement()
|
|
self.assertEqual(fake.pos, 0)
|
|
|
|
|
|
class TestAutoPauseScale(unittest.TestCase):
|
|
def test_autopause_scale_init(self):
|
|
pause = scale.AutoPauseScale()
|
|
adj = pause.get_adjustment()
|
|
|
|
self.assertIsInstance(pause, scale.ScalePlus)
|
|
self.assertEqual(pause.get_digits(), 0)
|
|
self.assertEqual(adj.get_value(), -1)
|
|
self.assertEqual(adj.get_lower(), -1)
|
|
self.assertEqual(adj.get_upper(), 99)
|
|
self.assertEqual(adj.get_step_increment(), 1)
|
|
self.assertEqual(adj.get_page_increment(), 5)
|
|
self.assertTrue(pause.keep_playing)
|
|
|
|
def test_autopause_scale_values(self):
|
|
pause = scale.AutoPauseScale()
|
|
self.assertEqual(pause.format_value(pause, -1), "Keep Playing")
|
|
self.assertEqual(pause.format_value(pause, 0), "This Track")
|
|
self.assertEqual(pause.format_value(pause, 1), "Next Track")
|
|
self.assertEqual(pause.format_value(pause, 2), "2 Tracks")
|
|
|
|
def test_keep_playing(self):
|
|
pause = scale.AutoPauseScale()
|
|
pause.set_value(2)
|
|
|
|
pause.decrement()
|
|
self.assertEqual(pause.get_value(), 1)
|
|
self.assertFalse(pause.about_to_pause())
|
|
self.assertTrue(pause.keep_playing)
|
|
|
|
pause.decrement()
|
|
self.assertEqual(pause.get_value(), 0)
|
|
self.assertTrue(pause.about_to_pause())
|
|
self.assertTrue(pause.keep_playing)
|
|
|
|
pause.decrement()
|
|
self.assertEqual(pause.get_value(), -1)
|
|
self.assertFalse(pause.about_to_pause())
|
|
self.assertFalse(pause.keep_playing)
|
|
|
|
pause.decrement()
|
|
self.assertEqual(pause.get_value(), -1)
|
|
self.assertFalse(pause.about_to_pause())
|
|
self.assertTrue(pause.keep_playing)
|
|
|
|
|
|
class TestVolumeScale(unittest.TestCase):
|
|
def test_volume_scale_init(self):
|
|
fake = FakePlayer(0, 5 * Gst.SECOND, 1.0)
|
|
volume = scale.VolumeScale(fake)
|
|
adj = volume.get_adjustment()
|
|
|
|
self.assertIsInstance(volume, scale.ScalePlus)
|
|
self.assertEqual(volume.player, fake)
|
|
self.assertEqual(adj.get_value(), 1.0)
|
|
self.assertEqual(adj.get_lower(), 0.0)
|
|
self.assertEqual(adj.get_upper(), 1.0)
|
|
self.assertEqual(adj.get_step_increment(), 0.05)
|
|
self.assertEqual(adj.get_page_increment(), 0.25)
|
|
|
|
fake.volume = 0.5
|
|
vol2 = scale.VolumeScale(fake)
|
|
self.assertEqual(vol2.get_value(), 0.5)
|
|
|
|
def test_volume_scale_values(self):
|
|
fake = FakePlayer(0, 15 * Gst.SECOND, 0.5)
|
|
volume = scale.VolumeScale(fake)
|
|
|
|
volume.increment()
|
|
self.assertEqual(fake.volume, 0.55)
|
|
self.assertEqual(volume.format_value(volume, 0.55), "55%")
|
|
|
|
volume.decrement()
|
|
self.assertEqual(fake.volume, 0.50)
|
|
self.assertEqual(volume.format_value(volume, 0.50), "50%")
|
|
|
|
|
|
class TestScaleButton(unittest.TestCase):
|
|
def test_scale_button(self):
|
|
splus = scale.ScalePlus(0, 5, 1, 1)
|
|
sbutt = scale.ScaleButton(splus, "missing-icon")
|
|
|
|
self.assertIsInstance(sbutt, Gtk.Button)
|
|
self.assertEqual(sbutt.get_valign(), Gtk.Align.END)
|
|
self.assertTrue(sbutt.has_css_class("normal-icons"))
|
|
self.assertTrue(sbutt.has_css_class("flat"))
|
|
|
|
|
|
class TestDecrementButton(unittest.TestCase):
|
|
def test_decrement_button(self):
|
|
splus = scale.ScalePlus(0, 5, 1, 1)
|
|
dec = scale.DecrementButton(splus)
|
|
splus.set_value(1)
|
|
|
|
self.assertIsInstance(dec, scale.ScaleButton)
|
|
self.assertEqual(dec.get_icon_name(), "list-remove-symbolic")
|
|
dec.emit("clicked")
|
|
self.assertEqual(splus.get_value(), 0)
|
|
|
|
|
|
class TestIncrementButton(unittest.TestCase):
|
|
def test_increment_button(self):
|
|
splus = scale.ScalePlus(0, 5, 1, 1)
|
|
inc = scale.IncrementButton(splus)
|
|
|
|
self.assertIsInstance(inc, scale.ScaleButton)
|
|
self.assertEqual(inc.get_icon_name(), "list-add-symbolic")
|
|
inc.emit("clicked")
|
|
self.assertEqual(splus.get_value(), 1)
|
|
|
|
|
|
class TestScaleButtonBox(unittest.TestCase):
|
|
def test_scale_button_box(self):
|
|
splus = scale.ScalePlus(0, 5, 1, 1)
|
|
sbox = scale.ScaleButtonBox(splus)
|
|
|
|
self.assertIsInstance(sbox, Gtk.Box)
|
|
self.assertEqual(sbox.get_orientation(), Gtk.Orientation.HORIZONTAL)
|
|
self.assertIsInstance(sbox.get_first_child(), scale.DecrementButton)
|
|
self.assertIsInstance(sbox.get_last_child(), scale.IncrementButton)
|
|
self.assertIsInstance(splus.get_next_sibling(), scale.IncrementButton)
|