class TestSubConverter(unittest.TestCase):
"""SubConverter test suite."""
subWithHeader = ["[INFORMATION]\n", "[TITLE]Subtitle\n", "[AUTHOR]Subtitle author\n",
"[SOURCE]\n","[PRG]SubConvert\n", "[FILEPATH]\n", "[DELAY]0\n", "[CD TRACK]0\n",
"[COMMENT]Converted to subviewer format with SubConvert\n", "[END INFORMATION]\n",
"[SUBTITLE]\n", "[COLF]&HFFFFFF,[STYLE]no,[SIZE]24,[FONT]Tahoma\n",
"00:00:00.00,00:00:01.00\n", "First subtitle\n", "\n",
"00:00:02.00,00:00:03.00\n", "Second\n", "subtitle\n"]
subWithoutHeader = ["0\n", "00:00:00,000 --> 00:00:01,000\n", "First subtitle\n",
"\n", "1\n", "00:00:02,000 --> 00:00:03,000\n", "Second\n", "subtitle\n"]
def setUp(self):
self.subs = SubManager()
self.subs.append(Subtitle(FrameTime(25.0, frames=0), FrameTime(25.0, frames=25), "First subtitle"))
self.subs.append(Subtitle(FrameTime(25.0, frames=50), FrameTime(25.0, frames=75), "Second{gsp_nl}subtitle"))
self.subs.header().add("title", "Subtitle")
self.subs.header().add("author", "Subtitle author")
self.c = SubConverter()
def test_convertReturnsTheSameSubForSubtitleWithHeader(self):
result = self.c.convert(SubViewer, self.subs)
# Comparing bare strings has several benefits: it produces better visual output when
# something goes wrong. Also, SubConvert produces lists that arelogically equal to the
# input but differ somehow (e.g. newlines aren't stored in individual list elements but
# together with subtitle)
self.assertEqual(''.join(self.subWithHeader).strip(), ''.join(result).strip())
def test_convertReturnsTheSameSubForSubtitleWithoutHeader(self):
result = self.c.convert(SubRip, self.subs)
self.assertEqual(''.join(self.subWithoutHeader).strip(), ''.join(result).strip())
def test_convertFromHeaderlessToSubtitleWithHeader(self):
self.subs.header().clear()
result = self.c.convert(SubViewer, self.subs)
# Note: this requires the knowledge of what SubViewer converter default header values are.
# They may change at times...
compSubWithHeader = ["[INFORMATION]\n", "[TITLE]\n", "[AUTHOR]\n",
"[SOURCE]\n","[PRG]SubConvert\n", "[FILEPATH]\n", "[DELAY]0\n", "[CD TRACK]0\n",
"[COMMENT]Converted to subviewer format with SubConvert\n", "[END INFORMATION]\n",
"[SUBTITLE]\n", "[COLF]&HFFFFFF,[STYLE]no,[SIZE]24,[FONT]Tahoma\n",
"00:00:00.00,00:00:01.00\n", "First subtitle\n", "\n",
"00:00:02.00,00:00:03.00\n", "Second\n", "subtitle\n"]
self.assertEqual(''.join(compSubWithHeader).strip(), ''.join(result).strip())
def test_convertSubtitleWithHeaderToHeaderless(self):
result = self.c.convert(SubRip, self.subs)
self.assertEqual(''.join(self.subWithoutHeader).strip(), ''.join(result).strip())
def setUp(self):
self.subs = SubManager()
self.subs.append(Subtitle(FrameTime(25.0, frames=0), FrameTime(25.0, frames=25), "First subtitle"))
self.subs.append(Subtitle(FrameTime(25.0, frames=50), FrameTime(25.0, frames=75), "Second{gsp_nl}subtitle"))
self.subs.header().add("title", "Subtitle")
self.subs.header().add("author", "Subtitle author")
self.c = SubConverter()
def setUp(self):
self._subs = SubManager()
self._subs.append(self.createSubtitle(1, 2))
self._subs.append(self.createSubtitle(25, 26))
self._subs.append(self.createSubtitle(21, 25))
self._subs.append(self.createSubtitle(22, 23))
self._subs.append(self.createSubtitle(25, 28))
self._subs.append(self.createSubtitle(30, 30))
self._testedTimeSync = TimeSync(self._subs)
class TestOffset(unittest.TestCase):
"""Offset Unit Tests"""
def setUp(self):
self._subs = SubManager()
self._subs.append(self.createSubtitle(1, 2))
self._subs.append(self.createSubtitle(25, 26))
self._subs.append(self.createSubtitle(21, 25))
self._subs.append(self.createSubtitle(22, 23))
self._subs.append(self.createSubtitle(25, 28))
self._subs.append(self.createSubtitle(30, 30))
self._testedTimeSync = TimeSync(self._subs)
def createFrameTime(self, secs):
return FrameTime(fps = 25, seconds = secs)
def createSubtitle(self, secStart, secEnd):
start = self.createFrameTime(secStart)
end = self.createFrameTime(secEnd)
text = "Test subtitle, %d - %d" % (secStart, secEnd)
return Subtitle(start, end, text)
def createSyncPoint(self, subNo, secStart, secEnd):
start = self.createFrameTime(secStart)
end = self.createFrameTime(secEnd)
return SyncPoint(subNo, start, end)
def test_syncWithoutSyncPointsChangesNothing(self):
syncList = []
self._testedTimeSync.sync(syncList)
self.assertEqual(self._subs[0].start, self.createFrameTime(1))
self.assertEqual(self._subs[0].end, self.createFrameTime(2))
self.assertEqual(self._subs[3].start, self.createFrameTime(22))
self.assertEqual(self._subs[3].end, self.createFrameTime(23))
def test_syncWithAFirstSyncPoint(self):
syncList = [self.createSyncPoint(0, 5, 7)]
self._testedTimeSync.sync(syncList)
self.assertEqual(self._subs[0].start, self.createFrameTime(5))
self.assertEqual(self._subs[0].end, self.createFrameTime(7))
self.assertNotEqual(self._subs[1].start, self.createFrameTime(25))
self.assertNotEqual(self._subs[1].end, self.createFrameTime(26))
self.assertEqual(self._subs[-1].start, self.createFrameTime(30))
self.assertEqual(self._subs[-1].end, self.createFrameTime(30))
def test_syncWithALastPoint(self):
syncList = [self.createSyncPoint(5, 5, 7)]
self._testedTimeSync.sync(syncList)
self.assertEqual(self._subs[0].start, self.createFrameTime(1))
self.assertEqual(self._subs[0].end, self.createFrameTime(2))
self.assertTrue(self._subs[1].start < self.createFrameTime(5))
self.assertTrue(self._subs[1].end < self.createFrameTime(7))
self.assertEqual(self._subs[-1].start, self.createFrameTime(5))
self.assertEqual(self._subs[-1].end, self.createFrameTime(7))
def test_syncWithASingleSyncPointNotAtStartOrEnd(self):
syncList = [self.createSyncPoint(3, 5, 7)]
self._testedTimeSync.sync(syncList)
self.assertEqual(self._subs[0].start, self.createFrameTime(1))
self.assertEqual(self._subs[0].end, self.createFrameTime(2))
self.assertTrue(self._subs[1].start < self.createFrameTime(25))
self.assertTrue(self._subs[1].end < self.createFrameTime(26))
self.assertTrue(self._subs[1].start > self.createFrameTime(5))
self.assertTrue(self._subs[1].end > self.createFrameTime(7))
self.assertEqual(self._subs[3].start, self.createFrameTime(5))
self.assertEqual(self._subs[3].end, self.createFrameTime(7))
self.assertEqual(self._subs[-1].start, self.createFrameTime(30))
self.assertEqual(self._subs[-1].end, self.createFrameTime(30))
def test_syncWithTwoSyncPointsAtStartAndEnd(self):
syncList = [
self.createSyncPoint(0, 7, 8),
self.createSyncPoint(5, 50, 60)
]
self._testedTimeSync.sync(syncList)
self.assertEqual(self._subs[0].start, self.createFrameTime(7))
self.assertEqual(self._subs[0].end, self.createFrameTime(8))
self.assertTrue(self._subs[2].start > self.createFrameTime(21))
self.assertTrue(self._subs[2].end > self.createFrameTime(25))
self.assertEqual(self._subs[-1].start, self.createFrameTime(50))
self.assertEqual(self._subs[-1].end, self.createFrameTime(60))
def test_syncWithTwoSyncPointNotAtStartOrEnd(self):
syncList = [
self.createSyncPoint(2, 7, 8),
self.createSyncPoint(4, 50, 60)
]
self._testedTimeSync.sync(syncList)
# BEWARE! OGRES!
# If some conditions are not clear, take a look at setUp method. We fill subs with some
# silly values on purpose, sometimes lower than the previous ones. Syncing subtitles should
# preserve these dependencies.
self.assertEqual(self._subs[0].start, self.createFrameTime(1))
self.assertEqual(self._subs[0].end, self.createFrameTime(2))
self.assertTrue(self._subs[1].start > self.createFrameTime(7))
self.assertTrue(self._subs[1].end > self.createFrameTime(8))
self.assertEqual(self._subs[2].start, self.createFrameTime(7))
self.assertEqual(self._subs[2].end, self.createFrameTime(8))
self.assertTrue(self._subs[3].start > self.createFrameTime(7))
self.assertEqual(self._subs[3].end, self.createFrameTime(8)) # see _calculateTime() comments
self.assertTrue(self._subs[3].start < self.createFrameTime(50))
self.assertEqual(self._subs[4].start, self.createFrameTime(50))
self.assertEqual(self._subs[4].end, self.createFrameTime(60))
def test_syncWithNotSortedSyncPoints(self):
syncList = [
self.createSyncPoint(2, 2, 3),
self.createSyncPoint(1, 1, 2),
self.createSyncPoint(5, 5, 6),
self.createSyncPoint(4, 4, 5),
self.createSyncPoint(3, 3, 4),
self.createSyncPoint(0, 0, 1)
]
self._testedTimeSync.sync(syncList)
self.assertEqual(self._subs[0].start, self.createFrameTime(0))
self.assertEqual(self._subs[0].end, self.createFrameTime(1))
self.assertEqual(self._subs[1].start, self.createFrameTime(1))
self.assertEqual(self._subs[1].end, self.createFrameTime(2))
self.assertEqual(self._subs[2].start, self.createFrameTime(2))
self.assertEqual(self._subs[2].end, self.createFrameTime(3))
self.assertEqual(self._subs[3].start, self.createFrameTime(3))
self.assertEqual(self._subs[3].end, self.createFrameTime(4))
self.assertEqual(self._subs[4].start, self.createFrameTime(4))
self.assertEqual(self._subs[4].end, self.createFrameTime(5))
self.assertEqual(self._subs[5].start, self.createFrameTime(5))
self.assertEqual(self._subs[5].end, self.createFrameTime(6))
def setUp(self):
self.m = SubManager()
self.correctSub = SubtitleMock(FrameTime(10, 0), FrameTime(10, 0), "Default Subtitle")
self.subWithNoEnd = SubtitleMock(FrameTime(10, 0), None, "NoEnd Subtitle")
class TestSubManager(unittest.TestCase):
"""SubManager test suite."""
def setUp(self):
self.m = SubManager()
self.correctSub = SubtitleMock(FrameTime(10, 0), FrameTime(10, 0), "Default Subtitle")
self.subWithNoEnd = SubtitleMock(FrameTime(10, 0), None, "NoEnd Subtitle")
def addSubtitles(self, no):
for i in range(abs(no)):
self.m.append(
SubtitleMock(
FrameTime(10, seconds=i),
FrameTime(10, seconds=i),
"Subtitle{gsp_nl}%s" % str(i + 1)
)
)
def test_raiseExceptionWhenFpsIs_0_(self):
with self.assertRaises(ValueError):
self.m.changeFps(0)
def test_raiseExceptionWhenFpsBelow_0_(self):
with self.assertRaises(ValueError):
self.m.changeFps(-1)
def test_changeFpsCorrectly(self):
self.m.changeFps(5)
for sub in self.m:
self.assertEqual(5, sub.fps)
def test_subManagerCorrectlyUsesNegativeSubNumbers(self):
self.addSubtitles(2)
self.assertEqual("Subtitle{gsp_nl}2", self.m[-1].text)
self.assertEqual("Subtitle{gsp_nl}2", self.m[1].text)
# TODO: Make also tests that check returned subtitle times.
def test_subManagerReturnsCorrectLines(self):
self.addSubtitles(2)
self.assertEqual("Subtitle{gsp_nl}1", self.m[0].text)
self.assertEqual("Subtitle{gsp_nl}2", self.m[1].text)
def test_raiseExceptionWhenTryingToInsertSubToNegativeIndex(self):
with self.assertRaises(ValueError):
self.m.insert(-1, self.correctSub)
def test_insertProperlyAddsToEmptyList(self):
self.m.insert(0, self.correctSub)
self.assertEqual(self.correctSub, self.m[0])
def test_insertProperlyAddsToTheBeginning(self):
self.addSubtitles(2)
self.m.insert(0, self.correctSub)
self.assertEqual(self.correctSub, self.m[0])
def test_insertProperlyAddsToTheEnd(self):
self.addSubtitles(2)
self.m.insert(2, self.correctSub)
self.assertEqual(self.correctSub, self.m[2])
def test_insertProperlyAddsToTheEndWhenIndexIsTooHigh(self):
self.addSubtitles(5)
self.m.insert(9, self.correctSub)
self.assertEqual(self.correctSub, self.m[5])
def test_insertProperlyAddsInTheMiddle(self):
self.addSubtitles(4)
self.m.insert(2, self.correctSub)
self.assertEqual(self.correctSub, self.m[2])
def test_insertHandlesChangingSubtitleEndWhenItIsNotSet(self):
self.addSubtitles(3)
self.assertIsNone(self.subWithNoEnd.end)
self.m.insert(1, self.subWithNoEnd)
self.assertIsNotNone(self.m[1].end)
def test_appendCorrectlyAddsTheFirstSub(self):
self.m.append(self.correctSub)
self.assertEqual(self.correctSub, self.m[0])
def test_appendCorrectlyAddsTheSecondSub(self):
self.m.append(self.correctSub)
self.m.append(self.subWithNoEnd)
self.assertEqual(self.subWithNoEnd, self.m[1])
def test_appendCorrectlyChangesEmptyEndTimeOfTheLastSubtitle(self):
self.m.append(self.correctSub)
self.m.append(self.subWithNoEnd)
self.assertIsNotNone(self.subWithNoEnd.end)
def test_appendCorrectlyChangesEndTimeOfPreviousSubtitleWhenANewSubtitlehasBeenAdded(self):
self.m.append(self.correctSub)
self.m.append(self.subWithNoEnd)
self.assertEqual(2.5, self.subWithNoEnd.end.fullSeconds)
nextSub = SubtitleMock(FrameTime(10, seconds=1), FrameTime(10, seconds=1), "")
self.m.append(nextSub)
self.assertEqual(0.85, self.subWithNoEnd.end.fullSeconds)
# TODO: this should check number of mock calls
def test_appendChangesEndTimeMaximumTwoTimes(self):
nextSub = SubtitleMock(FrameTime(10, seconds=1), FrameTime(10, seconds=1), "")
secondNextSub = SubtitleMock(FrameTime(10, seconds=2), FrameTime(10, seconds=2), "")
self.m.append(self.correctSub)
self.m.append(self.subWithNoEnd)
self.m.append(nextSub)
self.m.append(secondNextSub)
self.assertEqual(0.85, self.subWithNoEnd.end.fullSeconds)
def test_appendIsAbleToChangeEndTimeOfTwoSubsAtOnce(self):
self.m.append(self.correctSub)
self.m.append(self.subWithNoEnd)
nextSub = SubtitleMock(FrameTime(10, seconds=1), None, "")
self.m.append(nextSub)
self.assertIsNotNone(self.subWithNoEnd.end)
self.assertIsNotNone(nextSub.end)
