Example #1
0
 def testSevenFour(self):
     count = MeasureCount.makeSimpleCount(self.eighths, 7)
     self.assertEqual(count.timeSig(), (7, 4))
     count = MeasureCount.makeSimpleCount(self.triplets, 7)
     self.assertEqual(count.timeSig(), (7, 4))
     count = MeasureCount.makeSimpleCount(self.sixteenths, 7)
     self.assertEqual(count.timeSig(), (7, 4))
Example #2
0
 def testSevenFour(self):
     count = MeasureCount.makeSimpleCount(self.eighths, 7)
     self.assertEqual(count.timeSig(), (7, 4))
     count = MeasureCount.makeSimpleCount(self.triplets, 7)
     self.assertEqual(count.timeSig(), (7, 4))
     count = MeasureCount.makeSimpleCount(self.sixteenths, 7)
     self.assertEqual(count.timeSig(), (7, 4))
Example #3
0
 def testFiveFour(self):
     count = MeasureCount.makeSimpleCount(self.eighths, 5)
     self.assertEqual(count.timeSig(), (5, 4))
     count = MeasureCount.makeSimpleCount(self.triplets, 5)
     self.assertEqual(count.timeSig(), (5, 4))
     count = MeasureCount.makeSimpleCount(self.sixteenths, 5)
     self.assertEqual(count.timeSig(), (5, 4))
Example #4
0
 def testNineEight(self):
     count = MeasureCount.makeSimpleCount(self.eighths, 4)
     count.addBeats(Beat.Beat(self.eighths, 1), 1)
     self.assertEqual(count.timeSig(), (9, 8))
     count = MeasureCount.makeSimpleCount(self.sixteenths, 4)
     count.addBeats(Beat.Beat(self.sixteenths, 2), 1)
     self.assertEqual(count.timeSig(), (9, 8))
Example #5
0
 def testFiveFour(self):
     count = MeasureCount.makeSimpleCount(self.eighths, 5)
     self.assertEqual(count.timeSig(), (5, 4))
     count = MeasureCount.makeSimpleCount(self.triplets, 5)
     self.assertEqual(count.timeSig(), (5, 4))
     count = MeasureCount.makeSimpleCount(self.sixteenths, 5)
     self.assertEqual(count.timeSig(), (5, 4))
Example #6
0
 def testNineEight(self):
     count = MeasureCount.makeSimpleCount(self.eighths, 4)
     count.addBeats(Beat.Beat(self.eighths, 1), 1)
     self.assertEqual(count.timeSig(), (9, 8))
     count = MeasureCount.makeSimpleCount(self.sixteenths, 4)
     count.addBeats(Beat.Beat(self.sixteenths, 2), 1)
     self.assertEqual(count.timeSig(), (9, 8))
Example #7
0
 def testSimpleDefaultWrite(self):
     myCounter = Counter.Counter("e+a")
     count = MeasureCount.makeSimpleCount(myCounter, 4)
     handle = StringIO()
     indenter = fileUtils.Indenter(handle)
     dbfsv1.DefaultMeasureCountStructureV1().write(count, indenter)
     output = handle.getvalue().splitlines()
     self.assertEqual(output,
                      ["START_DEFAULT_MEASURE_COUNT",
                       "  BEAT_START",
                       "    NUM_TICKS 4",
                       "    COUNT |^e+a|",
                       "  BEAT_END",
                       "  BEAT_START",
                       "    NUM_TICKS 4",
                       "    COUNT |^e+a|",
                       "  BEAT_END",
                       "  BEAT_START",
                       "    NUM_TICKS 4",
                       "    COUNT |^e+a|",
                       "  BEAT_END",
                       "  BEAT_START",
                       "    NUM_TICKS 4",
                       "    COUNT |^e+a|",
                       "  BEAT_END",
                       "END_DEFAULT_MEASURE_COUNT"])
Example #8
0
 def testMultiMeasures(self):
     score = Score()
     settings = ASCIISettings()
     settings.omitEmpty = False
     score.drumKit = DrumKit.DrumKit()
     score.drumKit.addDrum(Drum.Drum("HiHat", "Hh", "x"))
     score.drumKit.addDrum(Drum.Drum("Crash", "Cr", "x"))
     counter = MeasureCount.counterMaker(4, 16)
     score.insertMeasureByIndex(16, counter = counter)
     score.insertMeasureByIndex(16, counter = counter)
     score.insertMeasureByIndex(16, counter = counter)
     score.addNote(NotePosition(0, 0, 0, 0), "x")
     score.addNote(NotePosition(0, 1, 0, 0), "y")
     score.addNote(NotePosition(0, 2, 0, 0), "z")
     output = self.getOutput(score, settings)
     self.assertEqual(output,
                      ['Tabbed with DrumBurp, a drum tab editor from www.whatang.org',
                       '',
                       'Title     : ',
                       'Artist    : ',
                       'BPM       : 120',
                       'Tabbed by : ',
                       'Date      : ' + self.exportDate,
                       '',
                       'Cr - Crash',
                       'Hh - HiHat',
                       '',
                       'Cr|----------------|----------------|----------------|',
                       'Hh|x---------------|y---------------|z---------------|',
                       '   1e+a2e+a3e+a4e+a 1e+a2e+a3e+a4e+a 1e+a2e+a3e+a4e+a ',
                       '',
                       'Tabbed with DrumBurp, a drum tab editor from www.whatang.org'])
Example #9
0
 def testSimpleDefaultWrite(self):
     myCounter = Counter.Counter("e+a")
     count = MeasureCount.makeSimpleCount(myCounter, 4)
     handle = StringIO()
     indenter = fileUtils.Indenter(handle)
     dbfsv1.DefaultMeasureCountStructureV1().write(count, indenter)
     output = handle.getvalue().splitlines()
     self.assertEqual(output,
                      ["START_DEFAULT_MEASURE_COUNT",
                       "  BEAT_START",
                       "    NUM_TICKS 4",
                       "    COUNT |^e+a|",
                       "  BEAT_END",
                       "  BEAT_START",
                       "    NUM_TICKS 4",
                       "    COUNT |^e+a|",
                       "  BEAT_END",
                       "  BEAT_START",
                       "    NUM_TICKS 4",
                       "    COUNT |^e+a|",
                       "  BEAT_END",
                       "  BEAT_START",
                       "    NUM_TICKS 4",
                       "    COUNT |^e+a|",
                       "  BEAT_END",
                       "END_DEFAULT_MEASURE_COUNT"])
Example #10
0
 def testComplexWrite(self):
     counter1 = Counter.Counter("e+a")
     counter2 = Counter.Counter("+a")
     counter3 = Counter.Counter("+")
     counter4 = Counter.Counter("e+a")
     count = MeasureCount.MeasureCount()
     count.addBeats(Beat.Beat(counter1), 1)
     count.addBeats(Beat.Beat(counter2), 1)
     count.addBeats(Beat.Beat(counter3), 1)
     count.addBeats(Beat.Beat(counter4, 2), 1)
     handle = StringIO()
     indenter = fileUtils.Indenter(handle)
     dbfsv1.MeasureCountStructureV1().write(count, indenter)
     output = handle.getvalue().splitlines()
     self.assertEqual(output,
                      ["START_MEASURE_COUNT",
                       "  BEAT_START",
                       "    NUM_TICKS 4",
                       "    COUNT |^e+a|",
                       "  BEAT_END",
                       "  BEAT_START",
                       "    NUM_TICKS 3",
                       "    COUNT |^+a|",
                       "  BEAT_END",
                       "  BEAT_START",
                       "    NUM_TICKS 2",
                       "    COUNT |^+|",
                       "  BEAT_END",
                       "  BEAT_START",
                       "    NUM_TICKS 2",
                       "    COUNT |^e+a|",
                       "  BEAT_END",
                       "END_MEASURE_COUNT"])
Example #11
0
 def testStaffs(self):
     score = Score()
     settings = ASCIISettings()
     settings.omitEmpty = False
     score.drumKit = DrumKit.DrumKit()
     score.drumKit.addDrum(Drum.Drum("HiHat", "Hh", "x"))
     score.drumKit.addDrum(Drum.Drum("Crash", "Cr", "x"))
     counter = MeasureCount.counterMaker(4, 16)
     score.insertMeasureByIndex(16, counter=counter)
     score.insertMeasureByIndex(16, counter=counter)
     score.insertMeasureByIndex(16, counter=counter)
     score.addNote(NotePosition(0, 0, 0, 0), "x")
     score.addNote(NotePosition(0, 1, 0, 0), "y")
     score.addNote(NotePosition(0, 2, 0, 0), "z")
     score.formatScore(40)
     output = self.getOutput(score, settings)
     self.assertEqual(output, [
         'Tabbed with DrumBurp, a drum tab editor from www.whatang.org', '',
         'Title     : ', 'Artist    : ', 'BPM       : 120', 'Tabbed by : ',
         'Date      : ' + self.exportDate, '', 'Cr - Crash', 'Hh - HiHat',
         '', 'Cr|----------------|----------------|',
         'Hh|x---------------|y---------------|',
         '   1e+a2e+a3e+a4e+a 1e+a2e+a3e+a4e+a ', '',
         'Cr|----------------|', 'Hh|z---------------|',
         '   1e+a2e+a3e+a4e+a ', '',
         'Tabbed with DrumBurp, a drum tab editor from www.whatang.org'
     ])
Example #12
0
 def read(self, scoreIterator):
     tracker = self._BarlineTracker(self)
     self.counter = MeasureCount.MeasureCount()
     with scoreIterator.section("START_BAR", "END_BAR") as section:
         section.readCallback("BARLINE", tracker.processBarline)
         section.readCallback("NOTE", self._readNote)
         section.readSubsection("COUNT_INFO_START", self._readCounter)
         section.readCallback("BEATLENGTH", self._makeOldMeasure)
         section.readPositiveInteger("REPEAT_COUNT", self, "repeatCount")
         section.readString("ALTERNATE", self, "alternateText")
Example #13
0
 def testSimpleWrite(self):
     myCounter = Counter.Counter("e+a")
     count = MeasureCount.makeSimpleCount(myCounter, 4)
     handle = StringIO()
     indenter = fileUtils.Indenter(handle)
     dbfsv0.MeasureCountStructureV0().write(count, indenter)
     output = handle.getvalue().splitlines()
     self.assertEqual(output, [
         "COUNT_INFO_START", "  REPEAT_BEATS 4", "  BEAT_START",
         "    COUNT |^e+a|", "  BEAT_END", "COUNT_INFO_END"
     ])
Example #14
0
 def testBadLine(self):
     data = """COUNT_INFO_START
           REPEAT_BEATS 4
           UNRECOGNISED LINE
           BEAT_START
               COUNT |^e+a|
           BEAT_END
       COUNT_INFO_END"""
     handle = StringIO(data)
     iterator = fileUtils.dbFileIterator(handle)
     count = MeasureCount.MeasureCount()
     self.assertRaises(DBErrors.UnrecognisedLine, count.read, iterator)
Example #15
0
 def testNegativeBeatCount(self):
     data = """COUNT_INFO_START
           REPEAT_BEATS -1
           UNRECOGNISED LINE
           BEAT_START
               COUNT |^e+a|
           BEAT_END
       COUNT_INFO_END"""
     handle = StringIO(data)
     iterator = fileUtils.dbFileIterator(handle)
     count = MeasureCount.MeasureCount()
     self.assertRaises(DBErrors.InvalidPositiveInteger, count.read, iterator)
Example #16
0
 def testReadSimpleDefault(self):
     data = """DEFAULT_COUNT_INFO_START
                   REPEAT_BEATS 4
                   BEAT_START
                       COUNT |^e+a|
                   BEAT_END
               COUNT_INFO_END"""
     handle = StringIO(data)
     iterator = fileUtils.dbFileIterator(handle)
     count = MeasureCount.MeasureCount()
     count.read(iterator, True)
     self.assert_(count.isSimpleCount())
     self.assertEqual(len(count), 16)
Example #17
0
 def testSimpleWrite(self):
     myCounter = Counter.Counter("e+a")
     count = MeasureCount.makeSimpleCount(myCounter, 4)
     handle = StringIO()
     indenter = fileUtils.Indenter(handle)
     dbfsv0.MeasureCountStructureV0().write(count, indenter)
     output = handle.getvalue().splitlines()
     self.assertEqual(output,
                      ["COUNT_INFO_START",
                       "  REPEAT_BEATS 4",
                       "  BEAT_START",
                       "    COUNT |^e+a|",
                       "  BEAT_END",
                       "COUNT_INFO_END"])
Example #18
0
 def getSmallestSimpleCount(self):
     if not self.counter.isSimpleCount():
         return None
     numBeats = self.counter.numBeats()
     maxLen = len(self)
     newCount = None
     for unused_, count in Counter.DEFAULT_REGISTRY:
         if len(count) * numBeats >= maxLen:
             continue
         mcount = MeasureCount.makeSimpleCount(count, numBeats)
         newMeasure = self.copyMeasure()
         newMeasure.setBeatCount(mcount)
         if self.numNotes() == newMeasure.numNotes():
             newCount = mcount
     return newCount
Example #19
0
 def getSmallestSimpleCount(self):
     if not self.counter.isSimpleCount():
         return None
     numBeats = self.counter.numBeats()
     maxLen = len(self)
     newCount = None
     for unused_, count in Counter.DEFAULT_REGISTRY:
         if len(count) * numBeats >= maxLen:
             continue
         mcount = MeasureCount.makeSimpleCount(count, numBeats)
         newMeasure = self.copyMeasure()
         newMeasure.setBeatCount(mcount)
         if self.numNotes() == newMeasure.numNotes():
             newCount = mcount
     return newCount
Example #20
0
 def testReadComplex(self):
     data = """COUNT_INFO_START
               BEAT_START
                 COUNT |^e+a|
               BEAT_END
               BEAT_START
                 COUNT |^+a|
               BEAT_END
               BEAT_START
                 COUNT |^+|
               BEAT_END
               BEAT_START
                 NUM_TICKS 2
                 COUNT |^e+a|
               BEAT_END
             COUNT_INFO_END"""
     handle = StringIO(data)
     iterator = fileUtils.dbFileIterator(handle)
     count = MeasureCount.MeasureCount()
     count.read(iterator)
     self.assertFalse(count.isSimpleCount())
     self.assertEqual(len(count), 11)
Example #21
0
 def testMake(self):
     count = MeasureCount.counterMaker(4, 16)
     self.assert_(isinstance(count, MeasureCount.MeasureCount))
     self.assert_(count.isSimpleCount())
     self.assertEqual(len(count), 16)
Example #22
0
 def testMake(self):
     count = MeasureCount.counterMaker(4, 16)
     self.assert_(isinstance(count, MeasureCount.MeasureCount))
     self.assert_(count.isSimpleCount())
     self.assertEqual(len(count), 16)
Example #23
0
 def _readCounter(self, scoreIterator):
     counter = MeasureCount.MeasureCount()
     counter.read(scoreIterator)
     self.setBeatCount(counter)
Example #24
0
 def _makeOldMeasure(self, lineData):
     self.counter = MeasureCount.counterMaker(int(lineData), len(self))
Example #25
0
class TestSimple(unittest.TestCase):
    my_counter = Counter.Counter("e+a")
    count = MeasureCount.makeSimpleCount(my_counter, 4)

    def testLength(self):
        self.assertEqual(len(self.count), 16)

    def testNumBeats(self):
        self.assertEqual(self.count.numBeats(), 4)

    def testIsSimple(self):
        self.assert_(self.count.isSimpleCount())

    def testCount(self):
        self.assertEqual(list(self.count.count()),
                         ["1", "e", "+", "a",
                          "2", "e", "+", "a",
                          "3", "e", "+", "a",
                          "4", "e", "+", "a"])

    def testCountString(self):
        self.assertEqual(self.count.countString(),
                         "1e+a2e+a3e+a4e+a")

    def testGetItem(self):
        beat = self.count[1]
        self.assert_(isinstance(beat, Beat.Beat))
        self.assertEqual(beat.numTicks, 4)
        self.assertEqual(beat.ticksPerBeat, 4)
        self.assertRaises(IndexError, self.count.__getitem__, 4)

    def testIterTimesMs(self):
        times = list(self.count.iterTimesMs(100))
        self.assertEqual(times, [0, 25, 50, 75,
                                 100, 125, 150, 175,
                                 200, 225, 250, 275,
                                 300, 325, 350, 375, 400])

    def testTimeSig(self):
        self.assertEqual(self.count.timeSig(), (4, 4))

    def testIterBeatTicks(self):
        ticks = list(self.count.iterBeatTicks())
        beat = self.count[0]
        self.assertEqual(ticks,
                         [(0, beat, 0), (0, beat, 1),
                          (0, beat, 2), (0, beat, 3),
                          (1, beat, 0), (1, beat, 1),
                          (1, beat, 2), (1, beat, 3),
                          (2, beat, 0), (2, beat, 1),
                          (2, beat, 2), (2, beat, 3),
                          (3, beat, 0), (3, beat, 1),
                          (3, beat, 2), (3, beat, 3)])

    def testIterBeatTickPositions(self):
        ticks = list(self.count.iterBeatTickPositions())
        self.assertEqual(ticks, [0, 4, 8, 12])

    def testIterMidiTicks(self):
        ticks = list(self.count.iterMidiTicks())
        self.assertEqual(ticks, [0, 48, 96, 144,
                                 192, 240, 288, 336,
                                 384, 432, 480, 528,
                                 576, 624, 672, 720, 768])

    def testIterTime(self):
        ticks = list(self.count.iterTime())
        self.assertEqual(ticks,
                         [(0, 0, 4), (0, 1, 4), (0, 2, 4), (0, 3, 4),
                          (1, 0, 4), (1, 1, 4), (1, 2, 4), (1, 3, 4),
                          (2, 0, 4), (2, 1, 4), (2, 2, 4), (2, 3, 4),
                          (3, 0, 4), (3, 1, 4), (3, 2, 4), (3, 3, 4)])
Example #26
0
 def testSeventeenSixteen(self):
     count = MeasureCount.makeSimpleCount(self.sixteenths, 4)
     count.addBeats(Beat.Beat(self.sixteenths, 1), 1)
     self.assertEqual(count.timeSig(), (17, 16))
Example #27
0
class TestComplex(unittest.TestCase):
    counter1 = Counter.Counter(Counter.BEAT_COUNT + "e+a")
    counter2 = Counter.Counter(Counter.BEAT_COUNT + "+a")
    counter3 = Counter.Counter(Counter.BEAT_COUNT + "+")
    counter4 = Counter.Counter(Counter.BEAT_COUNT + "e+a")
    count = MeasureCount.MeasureCount()
    count.addBeats(Beat.Beat(counter1), 1)
    count.addBeats(Beat.Beat(counter2), 1)
    count.addBeats(Beat.Beat(counter3), 1)
    count.addBeats(Beat.Beat(counter4, 2), 1)

    def testLength(self):
        self.assertEqual(len(self.count), 11)

    def testNumBeats(self):
        self.assertEqual(self.count.numBeats(), 4)

    def testIsSimple(self):
        self.assertFalse(self.count.isSimpleCount())

    def testCount(self):
        self.assertEqual(list(self.count.count()),
                         ["1", "e", "+", "a",
                          "2", "+", "a",
                          "3", "+",
                          "4", "e", ])

    def testCountString(self):
        self.assertEqual(self.count.countString(),
                         "1e+a2+a3+4e")

    def testGetItem(self):
        beat = self.count[1]
        self.assert_(isinstance(beat, Beat.Beat))
        self.assertEqual(beat.numTicks, 3)
        self.assertEqual(beat.ticksPerBeat, 3)
        self.assertRaises(IndexError, self.count.__getitem__, 4)

    def testIterTimesMs(self):
        times = list(self.count.iterTimesMs(120))
        self.assertEqual(times, [0, 30, 60, 90,
                                 120, 160, 200,
                                 240, 300,
                                 360, 390, 420])

    def testTimeSig(self):
        self.assertEqual(self.count.timeSig(), (7, 8))

    def testIterBeatTicks(self):
        ticks = list(self.count.iterBeatTicks())
        beat1 = self.count[0]
        beat2 = self.count[1]
        beat3 = self.count[2]
        beat4 = self.count[3]
        self.assertEqual(ticks,
                         [(0, beat1, 0), (0, beat1, 1),
                          (0, beat1, 2), (0, beat1, 3),
                          (1, beat2, 0), (1, beat2, 1),
                          (1, beat2, 2),
                          (2, beat3, 0), (2, beat3, 1),
                          (3, beat4, 0), (3, beat4, 1)])

    def testIterBeatTickPositions(self):
        ticks = list(self.count.iterBeatTickPositions())
        self.assertEqual(ticks, [0, 4, 7, 9])

    def testIterMidiTicks(self):
        ticks = list(self.count.iterMidiTicks())
        self.assertEqual(ticks, [0, 24, 48, 72,
                                 96, 128, 160,
                                 192, 240,
                                 288, 312, 336])

    def testIterTime(self):
        ticks = list(self.count.iterTime())
        self.assertEqual(ticks,
                         [(0, 0, 4), (0, 1, 4), (0, 2, 4), (0, 3, 4),
                          (1, 0, 3), (1, 1, 3), (1, 2, 3),
                          (2, 0, 2), (2, 1, 2),
                          (3, 0, 4), (3, 1, 4)])

    def testWrite(self):
        handle = StringIO()
        indenter = fileUtils.Indenter(handle)
        self.count.write(indenter)
        output = handle.getvalue().splitlines()
        self.assertEqual(output,
                         ["COUNT_INFO_START",
                          "  BEAT_START",
                          "    COUNT |^e+a|",
                          "  BEAT_END",
                          "  BEAT_START",
                          "    COUNT |^+a|",
                          "  BEAT_END",
                          "  BEAT_START",
                          "    COUNT |^+|",
                          "  BEAT_END",
                          "  BEAT_START",
                          "    NUM_TICKS 2",
                          "    COUNT |^e+a|",
                          "  BEAT_END",
                          "COUNT_INFO_END"])
Example #28
0
class TestSimple(unittest.TestCase):
    my_counter = Counter.Counter(Counter.BEAT_COUNT + "e+a")
    count = MeasureCount.makeSimpleCount(my_counter, 4)

    def testLength(self):
        self.assertEqual(len(self.count), 16)

    def testNumBeats(self):
        self.assertEqual(self.count.numBeats(), 4)

    def testIsSimple(self):
        self.assert_(self.count.isSimpleCount())

    def testCount(self):
        self.assertEqual(list(self.count.count()),
                         ["1", "e", "+", "a",
                          "2", "e", "+", "a",
                          "3", "e", "+", "a",
                          "4", "e", "+", "a"])

    def testCountString(self):
        self.assertEqual(self.count.countString(),
                         "1e+a2e+a3e+a4e+a")

    def testGetItem(self):
        beat = self.count[1]
        self.assert_(isinstance(beat, Beat.Beat))
        self.assertEqual(beat.numTicks, 4)
        self.assertEqual(beat.ticksPerBeat, 4)
        self.assertRaises(IndexError, self.count.__getitem__, 4)

    def testIterTimesMs(self):
        times = list(self.count.iterTimesMs(100))
        self.assertEqual(times, [0, 25, 50, 75,
                                 100, 125, 150, 175,
                                 200, 225, 250, 275,
                                 300, 325, 350, 375, 400])

    def testTimeSig(self):
        self.assertEqual(self.count.timeSig(), (4, 4))

    def testIterBeatTicks(self):
        ticks = list(self.count.iterBeatTicks())
        beat = self.count[0]
        self.assertEqual(ticks,
                         [(0, beat, 0), (0, beat, 1),
                          (0, beat, 2), (0, beat, 3),
                          (1, beat, 0), (1, beat, 1),
                          (1, beat, 2), (1, beat, 3),
                          (2, beat, 0), (2, beat, 1),
                          (2, beat, 2), (2, beat, 3),
                          (3, beat, 0), (3, beat, 1),
                          (3, beat, 2), (3, beat, 3)])

    def testIterBeatTickPositions(self):
        ticks = list(self.count.iterBeatTickPositions())
        self.assertEqual(ticks, [0, 4, 8, 12])

    def testIterMidiTicks(self):
        ticks = list(self.count.iterMidiTicks())
        self.assertEqual(ticks, [0, 24, 48, 72,
                                 96, 120, 144, 168,
                                 192, 216, 240, 264,
                                 288, 312, 336, 360, 384])

    def testIterTime(self):
        ticks = list(self.count.iterTime())
        self.assertEqual(ticks,
                         [(0, 0, 4), (0, 1, 4), (0, 2, 4), (0, 3, 4),
                          (1, 0, 4), (1, 1, 4), (1, 2, 4), (1, 3, 4),
                          (2, 0, 4), (2, 1, 4), (2, 2, 4), (2, 3, 4),
                          (3, 0, 4), (3, 1, 4), (3, 2, 4), (3, 3, 4)])

    def testWrite(self):
        handle = StringIO()
        indenter = fileUtils.Indenter(handle)
        self.count.write(indenter)
        output = handle.getvalue().splitlines()
        self.assertEqual(output,
                         ["COUNT_INFO_START",
                          "  REPEAT_BEATS 4",
                          "  BEAT_START",
                          "    COUNT |^e+a|",
                          "  BEAT_END",
                          "COUNT_INFO_END"])
Example #29
0
class TestComplex(unittest.TestCase):
    counter1 = Counter.Counter("e+a")
    counter2 = Counter.Counter("+a")
    counter3 = Counter.Counter("+")
    counter4 = Counter.Counter("e+a")
    count = MeasureCount.MeasureCount()
    count.addBeats(Beat.Beat(counter1), 1)
    count.addBeats(Beat.Beat(counter2), 1)
    count.addBeats(Beat.Beat(counter3), 1)
    count.addBeats(Beat.Beat(counter4, 2), 1)

    def testLength(self):
        self.assertEqual(len(self.count), 11)

    def testNumBeats(self):
        self.assertEqual(self.count.numBeats(), 4)

    def testIsSimple(self):
        self.assertFalse(self.count.isSimpleCount())

    def testCount(self):
        self.assertEqual(list(self.count.count()),
                         ["1", "e", "+", "a",
                          "2", "+", "a",
                          "3", "+",
                          "4", "e", ])

    def testCountString(self):
        self.assertEqual(self.count.countString(),
                         "1e+a2+a3+4e")

    def testGetItem(self):
        beat = self.count[1]
        self.assert_(isinstance(beat, Beat.Beat))
        self.assertEqual(beat.numTicks, 3)
        self.assertEqual(beat.ticksPerBeat, 3)
        self.assertRaises(IndexError, self.count.__getitem__, 4)

    def testIterTimesMs(self):
        times = list(self.count.iterTimesMs(120))
        self.assertEqual(times, [0, 30, 60, 90,
                                 120, 160, 200,
                                 240, 300,
                                 360, 390, 420])

    def testTimeSig(self):
        self.assertEqual(self.count.timeSig(), (7, 8))

    def testIterBeatTicks(self):
        ticks = list(self.count.iterBeatTicks())
        beat1 = self.count[0]
        beat2 = self.count[1]
        beat3 = self.count[2]
        beat4 = self.count[3]
        self.assertEqual(ticks,
                         [(0, beat1, 0), (0, beat1, 1),
                          (0, beat1, 2), (0, beat1, 3),
                          (1, beat2, 0), (1, beat2, 1),
                          (1, beat2, 2),
                          (2, beat3, 0), (2, beat3, 1),
                          (3, beat4, 0), (3, beat4, 1)])

    def testIterBeatTickPositions(self):
        ticks = list(self.count.iterBeatTickPositions())
        self.assertEqual(ticks, [0, 4, 7, 9])

    def testIterMidiTicks(self):
        ticks = list(self.count.iterMidiTicks())
        self.assertEqual(ticks, [0, 48, 96, 144,
                                 192, 256, 320,
                                 384, 480,
                                 576, 624, 672])

    def testIterTime(self):
        ticks = list(self.count.iterTime())
        self.assertEqual(ticks,
                         [(0, 0, 4), (0, 1, 4), (0, 2, 4), (0, 3, 4),
                          (1, 0, 3), (1, 1, 3), (1, 2, 3),
                          (2, 0, 2), (2, 1, 2),
                          (3, 0, 4), (3, 1, 4)])
Example #30
0
 def setUp(self):
     self.measure = Measure(16)
     counter = self.reg.getCounterByName("16ths")
     mc = MeasureCount.MeasureCount()
     mc.addSimpleBeats(counter, 4)
     self.measure.setBeatCount(mc)
Example #31
0
 def _makeOldMeasure(self, lineData):
     self.counter = MeasureCount.counterMaker(int(lineData),
                                              len(self))
Example #32
0
 def testSeventeenSixteen(self):
     count = MeasureCount.makeSimpleCount(self.sixteenths, 4)
     count.addBeats(Beat.Beat(self.sixteenths, 1), 1)
     self.assertEqual(count.timeSig(), (17, 16))