257 lines
8.0 KiB
Python
257 lines
8.0 KiB
Python
# Copyright 2021 (c) Anna Schumaker.
|
|
from . import publisher
|
|
from . import tag
|
|
from . import fake
|
|
import random
|
|
import threading
|
|
import unittest
|
|
|
|
|
|
class TestTag(unittest.TestCase):
|
|
def setUp(self):
|
|
self.changed = None
|
|
|
|
def callback_func(self, tag, track, pos):
|
|
self.changed = (tag, track, pos)
|
|
|
|
def test_tag_init(self):
|
|
t = tag.Tag("test")
|
|
self.assertEqual(t.name, "test")
|
|
self.assertEqual(t.sort, "test")
|
|
self.assertEqual(t.current, -1)
|
|
self.assertEqual(t.runtime, 0)
|
|
self.assertEqual(t.tracks, [ ])
|
|
self.assertFalse(t.loop)
|
|
self.assertFalse(t.random)
|
|
self.assertTrue( t.can_loop())
|
|
self.assertTrue( t.can_random())
|
|
self.assertIsNone(t.widgets)
|
|
self.assertIsInstance(t.lock, type(threading.Lock()))
|
|
self.assertIsInstance(t.TrackAdded, publisher.Publisher)
|
|
self.assertIsInstance(t.TrackRemoved, publisher.Publisher)
|
|
|
|
self.assertEqual(str(t), "test")
|
|
|
|
def test_tag_len(self):
|
|
t = tag.Tag("Test")
|
|
self.assertEqual(len(t), 0)
|
|
t.tracks = [ fake.Track(i) for i in range(5) ]
|
|
self.assertEqual(len(t), 5)
|
|
|
|
def test_tag_lt(self):
|
|
a = tag.Tag("A")
|
|
b = tag.Tag("B")
|
|
c = tag.Tag("C")
|
|
|
|
self.assertTrue( a < b)
|
|
self.assertFalse(b < a)
|
|
self.assertFalse(a < a)
|
|
|
|
a2 = tag.SuperTag(b, "A")
|
|
self.assertTrue(a < a2)
|
|
self.assertTrue(b < a2)
|
|
self.assertTrue(a2 < c)
|
|
|
|
def test_tag_header(self):
|
|
self.assertEqual(tag.Tag("Test").get_header(), "T")
|
|
self.assertEqual(tag.Tag("Test", "sort").get_header(), "S")
|
|
self.assertEqual(tag.Tag("").get_header(), "")
|
|
|
|
def test_tag_state(self):
|
|
t = tag.Tag("test")
|
|
tracks = [ fake.Track(i) for i in range(5) ]
|
|
t.tracks = tracks
|
|
|
|
state = t.__getstate__()
|
|
self.assertEqual(set(state.keys()),
|
|
set([ "name", "sort", "current", "loop", "random", "tracks" ]))
|
|
self.assertEqual(state["name"], "test")
|
|
self.assertEqual(state["sort"], "test")
|
|
self.assertEqual(state["current"], -1)
|
|
self.assertEqual(state["tracks"], [ 0, 1, 2, 3, 4 ])
|
|
self.assertFalse(state["loop"])
|
|
self.assertFalse(state["random"])
|
|
|
|
state["sort"] = "sort"
|
|
state["current"] = 42
|
|
|
|
t.__dict__.clear()
|
|
t.__setstate__(state)
|
|
self.assertEqual(t.name, "test")
|
|
self.assertEqual(t.sort, "sort")
|
|
self.assertEqual(t.current, 42)
|
|
self.assertEqual(t.runtime, 0)
|
|
self.assertEqual(t.tracks, [ 0, 1, 2, 3, 4 ])
|
|
self.assertEqual(t.widgets, None)
|
|
self.assertFalse(t.loop)
|
|
self.assertFalse(t.random)
|
|
self.assertIsInstance(t.lock, type(threading.Lock()))
|
|
self.assertIsInstance(t.TrackAdded, publisher.Publisher)
|
|
self.assertIsInstance(t.TrackRemoved, publisher.Publisher)
|
|
|
|
for track in tracks:
|
|
t.init_track(track)
|
|
self.assertEqual(t.tracks, tracks)
|
|
self.assertEqual(t.runtime, 10)
|
|
|
|
def test_tag_add_track(self):
|
|
t = tag.Tag("test")
|
|
t.TrackAdded.register(self.callback_func)
|
|
|
|
self.assertIsNone(t[0])
|
|
t.add_track(fake.Track(1))
|
|
self.assertEqual(t[0], fake.Track(1))
|
|
self.assertEqual(t.tracks, [ fake.Track(1) ])
|
|
self.assertEqual(self.changed, (t, fake.Track(1), 0))
|
|
self.assertEqual(t.runtime, 1)
|
|
|
|
t.add_track(fake.Track(2))
|
|
self.assertEqual(t[1], fake.Track(2))
|
|
self.assertEqual(t.tracks, [ fake.Track(1), fake.Track(2) ])
|
|
self.assertEqual(self.changed, (t, fake.Track(2), 1))
|
|
self.assertEqual(t.runtime, 3)
|
|
|
|
t.add_track(fake.Track(1))
|
|
self.assertEqual(t.tracks, [ fake.Track(1), fake.Track(2) ])
|
|
self.assertEqual(self.changed, (t, fake.Track(2), 1))
|
|
self.assertEqual(t.runtime, 3)
|
|
|
|
def test_tag_remove_track(self):
|
|
t = tag.Tag("test")
|
|
t.add_track(fake.Track(1))
|
|
t.add_track(fake.Track(2))
|
|
t.TrackRemoved.register(self.callback_func)
|
|
|
|
t.remove_track(fake.Track(1))
|
|
self.assertEqual(t.tracks, [ fake.Track(2) ])
|
|
self.assertEqual(self.changed, (t, fake.Track(1), 0))
|
|
self.assertEqual(t.runtime, 2)
|
|
|
|
t.remove_track(fake.Track(2))
|
|
self.assertEqual(t.tracks, [ ])
|
|
self.assertEqual(self.changed, (t, fake.Track(2), 0))
|
|
self.assertEqual(t.runtime, 0)
|
|
|
|
def test_tag_next(self):
|
|
t = tag.Tag("test")
|
|
t.tracks = [ 1, 2, 3 ]
|
|
|
|
self.assertEqual(t.next(), 1)
|
|
self.assertEqual(t.current, 0)
|
|
|
|
self.assertEqual(t.next(), 2)
|
|
self.assertEqual(t.current, 1)
|
|
|
|
self.assertEqual(t.next(), 3)
|
|
self.assertEqual(t.current, 2)
|
|
|
|
self.assertIsNone(t.next())
|
|
self.assertEqual(t.current, 3)
|
|
|
|
t.loop = True
|
|
self.assertEqual(t.next(), 1)
|
|
self.assertEqual(t.current, 0)
|
|
|
|
def test_tag_random_next(self):
|
|
t = tag.Tag("test")
|
|
t.tracks = [ 0, 1, 2, 3, 4, 5 ]
|
|
t.random = True
|
|
|
|
# Expected randint(): 5, 3, 2, 5, 5, 5
|
|
random.seed(20210318)
|
|
self.assertEqual(t.next(), 4) # -1 + 5
|
|
self.assertEqual(t.next(), 1) # (4 + 3) % 6 = 7 % 6
|
|
self.assertEqual(t.next(), 3) # 1 + 2
|
|
self.assertEqual(t.next(), 2) # (3 + 5) % 6 = 8 % 6
|
|
self.assertEqual(t.next(), 1) # (2 + 5) % 6 = 7 % 6
|
|
self.assertEqual(t.next(), 0) # (1 + 5) % 6 = 0
|
|
|
|
t.tracks = [ ]
|
|
self.assertIsNone(t.next())
|
|
|
|
t.tracks = [ 0 ]
|
|
self.assertEqual(t.next(), 0)
|
|
self.assertEqual(t.next(), 0)
|
|
|
|
t.tracks = [ 0, 1 ]
|
|
t.current = -1
|
|
self.assertEqual(t.next(), 0)
|
|
self.assertEqual(t.next(), 1)
|
|
self.assertEqual(t.next(), 0)
|
|
self.assertEqual(t.next(), 1)
|
|
|
|
def test_tag_track_selected(self):
|
|
t = tag.Tag("test")
|
|
p = tag.Tag("Previous")
|
|
t.tracks = [ fake.Track(0, p), fake.Track(1, p), fake.Track(2, p) ]
|
|
|
|
t.track_selected(fake.Track(2, p))
|
|
self.assertEqual(t.current, 2)
|
|
self.assertIn(fake.Track(2, p), p.tracks)
|
|
|
|
t.track_selected(fake.Track(1, p))
|
|
self.assertEqual(t.current, 1)
|
|
self.assertIn(fake.Track(1, p), p.tracks)
|
|
|
|
t.track_selected(fake.Track(0, p))
|
|
self.assertEqual(t.current, 0)
|
|
self.assertIn(fake.Track(0, p), p.tracks)
|
|
|
|
def test_tag_stacked(self):
|
|
t = tag.Tag("test")
|
|
t.tracks = [ 0, 1, 2 ]
|
|
|
|
t.current = 3
|
|
t.stacked()
|
|
self.assertEqual(t.current, -1)
|
|
|
|
t.current = 1
|
|
t.stacked()
|
|
self.assertEqual(t.current, 1)
|
|
|
|
|
|
class TestSuperTag(unittest.TestCase):
|
|
def test_super_tag(self):
|
|
parent = tag.Tag("parent")
|
|
st = tag.SuperTag(parent, "test", "sort")
|
|
st.tracks = [ fake.Track(i) for i in range(5) ]
|
|
|
|
self.assertIsInstance(st, tag.Tag)
|
|
self.assertEqual(st.parent, parent)
|
|
|
|
state = st.__getstate__()
|
|
self.assertEqual(state["name"], "test")
|
|
self.assertEqual(state["sort"], "sort")
|
|
self.assertEqual(state["current"], -1)
|
|
self.assertEqual(state["tracks"], [ 0, 1, 2, 3, 4 ])
|
|
self.assertEqual(state["parent"], parent)
|
|
|
|
st.__dict__.clear()
|
|
st.__setstate__(state)
|
|
self.assertEqual(st.name, "test")
|
|
self.assertEqual(st.sort, "sort")
|
|
self.assertEqual(st.tracks, [ 0, 1, 2, 3, 4 ])
|
|
self.assertEqual(st.widgets, None)
|
|
self.assertEqual(st.parent, parent)
|
|
self.assertIsInstance(st.lock, type(threading.Lock()))
|
|
|
|
def test_super_tag_lt(self):
|
|
A = tag.Tag("A")
|
|
B = tag.Tag("B")
|
|
C = tag.Tag("C")
|
|
|
|
aa = tag.SuperTag(A, "A")
|
|
ba = tag.SuperTag(B, "A")
|
|
bb = tag.SuperTag(B, "B")
|
|
ca = tag.SuperTag(C, "A")
|
|
|
|
lst = [ A, aa, B, ba, bb, C, ca ]
|
|
for i, t in enumerate(lst):
|
|
for u in lst[i+1:]:
|
|
self.assertTrue(t < u)
|
|
|
|
lst = [ ca, C, bb, ba, B, aa, A ]
|
|
for i, t in enumerate(lst):
|
|
for u in lst[i+1:]:
|
|
self.assertFalse(t < u)
|