Python music21.mainTest函数代码示例

                        "tempos": [],
                        "timeSignatureFirst": "4/4",
                        "timeSignatures": [
                            "4/4"
                        ]
                    },
                    "__class__": "music21.metadata.RichMetadata",
                    "__version__": [
                        """
                + str(VERSION[0])
                + """,
                        """
                + str(VERSION[1])
                + """,
                        """
                + str(VERSION[2])
                + """
                    ]
                }
                """
            ),
        )


# ------------------------------------------------------------------------------

if __name__ == "__main__":
    import music21

    music21.mainTest(Test, "noDocTest")

            match = False
            for skip in ['_', '__', 'Test', 'Exception']:
                if part.startswith(skip) or part.endswith(skip):
                    match = True
            if match:
                continue
            name = getattr(sys.modules[self.__module__], part)
            if callable(name) and not isinstance(name, types.FunctionType):
                try:  # see if obj can be made w/ args
                    obj = name()
                except TypeError:
                    continue
                a = copy.copy(obj)
                b = copy.deepcopy(obj)
                self.assertIsNot(a, None)
                self.assertIsNot(b, None)


# -----------------------------------------------------------------------------


_DOC_ORDER = (
    Editorial,
    )

if __name__ == "__main__":
    #import doctest
    #doctest.testmod()
    import music21
    music21.mainTest(Test)

        if fp is None:
            fp = environLocal.getTempFile('.qm')

        for n in obj.flat.notes:
            music = music + n.name + ' '
        music += '\n'

        with open(fp, 'w') as f:
            f.write(music)

        return fp


if __name__ == '__main__':
    import music21
    music21.mainTest()
#     from music21 import common
#
#     converter.registerSubconverter(QMConverter)
#
#     print('\nFILE')
#     print('+++++++++++++++++++++++++')
#
#     parserPath = common.getSourceFilePath() / 'converter'
#     testPath = parserPath / 'quarterMusicTestIn.qm'
#
#     a = converter.parse(testPath)
#
#     a.show('text')
#
#

    def testRuleFrequency(self):        
        import time
        print(time.ctime())
        (num1, num2, num3, num4a, num4b) = ruleFrequency()
        print(time.ctime())
        print(num1)
        print(num2)
        print(num3)
        print(num4a)
        print(num4b)
        self.assertEqual(num4a,  57)
        self.assertEqual(num4b, 104)


if (__name__ == "__main__"):
    #runPiece(267)
#    (totalDict, foundPieceOpus) = findCorrections(correctionType="min6", startPiece=21, endPiece=22)
#    print totalDict
#    if len(foundPieceOpus) > 0:
#        foundPieceOpus.show('lily.png')
    import music21
    music21.mainTest(Test) #TestExternal) #, TestExternal)
    
#    correctedMin6()
#    correctedMaj3()
#    improvedHarmony()

#------------------------------------------------------------------------------
# eof

Interval 6 ⠴
Rest eighth ⠭
Barline final ⠣⠅

Measure 35 Left, Note Grouping 1:
Ascending Chord:
Octave 3 ⠸
B 16th ⠾
Interval 3 ⠬
Rest 16th ⠍
Ascending Chord:
Octave 2 ⠘
B eighth ⠚
Interval 3 ⠬
Interval 5 ⠔
Rest eighth ⠭
Barline final ⠣⠅
====

---end grand segment---
'''
        self.maxDiff = None
        self.assertEqual(x.splitlines(), y.splitlines())

if __name__ == "__main__":
    import music21
    music21.mainTest(Test) #, runTest='testVerdiDebug')

#------------------------------------------------------------------------------
# eof

        except KeyError: # no color match
            raise GraphException('invalid color name: %s' % color)

    elif common.isListLike(color):
        percent = False
        for sub in color:
            if sub < 1:
                percent = True
                break
        if percent:
            if len(color) == 1:
                color = [color[0], color[0], color[0]]
            # convert to 0 100% values as strings with % symbol
            colorStrList = [str(x * 100) + "%" for x in color]
            return webcolors.rgb_percent_to_hex(colorStrList)
        else: # assume integers
            return webcolors.rgb_to_hex(tuple(color))
    raise GraphException('invalid color specification: %s' % color)

class Test(unittest.TestCase):
    def testColors(self):
        self.assertEqual(getColor([0.5, 0.5, 0.5]), '#808080')
        self.assertEqual(getColor(0.5), '#808080')
        self.assertEqual(getColor(255), '#ffffff')
        self.assertEqual(getColor('Steel Blue'), '#4682b4')

if __name__ == "__main__":
    # sys.arg test options will be used in mainTest()
    import music21
    music21.mainTest(Test) #TestExternal, 'noDocTest') #, runTest='testGetPlotsToMakeA')

        self.assertEqual(
            score.metadata.search(
                'qu.d',
                field='title',
                ),
            (True, 'title'),
            )
        self.assertEqual(
            score.metadata.search(
                re.compile('(.*)canon(.*)'),
                ),
            (True, 'movementName'),
            )

    def testRichMetadata02(self):
        from music21 import corpus
        from music21 import metadata

        score = corpus.parse('bwv66.6')
        richMetadata = metadata.RichMetadata()
        richMetadata.merge(score.metadata)
        richMetadata.update(score)
        self.assertEqual(richMetadata.noteCount, 165)
        self.assertEqual(richMetadata.quarterLength, 36.0)

# -----------------------------------------------------------------------------

if __name__ == '__main__':
    import music21
    music21.mainTest(Test, 'noDocTest')

#                                         initialOffset=0.0, 
#                                         flatten=True, 
#                                         classLists=classLists)
#     return listOfTimespanTrees[0]

#---------------------
class Test(unittest.TestCase):
    
    def testFastPopulate(self):
        '''
        tests that the isSorted speed up trick ends up producing identical results.
        '''
        from music21 import corpus
        sf = corpus.parse('bwv66.6').flat
        sfTree = sf.asTree()
        #print(sfTree)

        sf.isSorted = False
        sf._cache = {}
        sfTreeSlow = sf.asTree()
        for i in range(len(sf)):
            fasti = sfTree[i]
            slowi = sfTreeSlow[i]
            self.assertIs(fasti, slowi)

#---------------------

if __name__ == '__main__':
    import music21
    music21.mainTest(Test) #, runTest='testFastPopulate')

            while tss:
                timespan = tss.pop()
                currentTimespansInList = sorted(tss,
                    key=lambda x: (x.offset, x.endTime))
                tsTree.removeTimespan(timespan)
                currentTimespansInTree = [x for x in tsTree]
                self.assertEqual(currentTimespansInTree, 
                                 currentTimespansInList, 
                                 (attempt, currentTimespansInTree, currentTimespansInList))
                if tsTree.rootNode is not None:
                    currentPosition = min(
                        x.offset for x in currentTimespansInList)
                    currentEndTime = max(
                        x.endTime for x in currentTimespansInList)
                    self.assertEqual(tsTree.rootNode.endTimeLow, 
                                     min(x.endTime for x in currentTimespansInList))
                    self.assertEqual(tsTree.rootNode.endTimeHigh,
                                     max(x.endTime for x in currentTimespansInList))
                    self.assertEqual(tsTree.lowestPosition(), currentPosition)
                    self.assertEqual(tsTree.endTime, currentEndTime)

                    for i in range(len(currentTimespansInTree)):
                        self.assertEqual(currentTimespansInList[i], currentTimespansInTree[i])
#------------------------------------------------------------------------------


if __name__ == "__main__":
    import music21
    music21.mainTest(Test) #, runTest='testElementsStoppingAt')

        s2 = stream.Stream()
        s2.append(note.Note('D-2'))
        s2.append(note.Note('F#5'))
        self.assertEqual(getAccidentalCountSum([s1, s2]), {'flat': 1, 'sharp': 1})

    def testGetAccidentalCountSumAdvanced(self):
        s1 = corpus.parse('bach/bwv7.7')
        s2 = corpus.parse('bach/bwv66.6')
        totalNotes = len(s1.flat.notes) + len(s2.flat.notes)
        tally = getAccidentalCountSum([s1, s2], True)
        self.assertEqual(tally, {'sharp': 195, 'natural': 324})
        self.assertEqual(totalNotes, tally['sharp'] + tally['natural'])


class TestSlow(unittest.TestCase):

    def runTest(self):
        pass

    def testAccidentalCountBachChorales(self):
        # the total number of accidentals in the Bach Chorales
        chorales = list( corpus.chorales.Iterator() )
        self.assertEqual(getAccidentalCountSum(chorales, True),
                         {'double-sharp': 4, 'flat': 7886, 'natural': 79869, 'sharp': 14940})


if __name__ == "__main__":
    import music21
    music21.mainTest(Test) # replace 'Test' with 'TestSlow' to test it on all 371 Bach Chorales.

            ap('7---')
        elif 'PageLayout' in elClasses and layoutToBreaks:
            popHyphens()
            ap('77---')
        elif 'LineBreak' in elClasses:
            popHyphens()
            ap('7---')
        elif 'PageBreak' in elClasses:
            popHyphens()
            ap('77---')
        elif 'ColumnBreak' in elClasses:
            popHyphens()
            ap('777---')
        else:
            error(el, ErrorLevel.LOG)

    return ''.join(volpianoTokens)



class Test(unittest.TestCase):
    pass

    def testNoteNames(self):
        pass


if __name__ == '__main__':
    import music21
    music21.mainTest(Test, 'importPlusRelative')

            'cicon',
            field='composer',
            fileExtensions=('.krn',),
        )
        self.assertEqual(len(searchResult), 0)
        searchResult = mdb.search(
            'cicon',
            field='composer',
            fileExtensions=('.xml'),
        )
        self.assertEqual(len(searchResult), 1)

# -----------------------------------------------------------------------------


_DOC_ORDER = (
    MetadataBundle,
    )

__all__ = [
    'MetadataEntry',
    'MetadataBundle',
    ]

if __name__ == '__main__':
    import music21
    music21.mainTest(Test) #, runTest='testFileExtensions')


# -----------------------------------------------------------------------------

    def iterateSequencePairwise(self, sequence):
        prev = None
        for x in sequence:
            cur = x
            if prev is not None:
                yield prev, cur
            prev = cur

    def runNBConvert(self, ipythonNotebookFilePath):
        try:
            from nbconvert import nbconvertapp as nb
        except ImportError:
            environLocal.warn("nbconvert is not installed, run pip3 install nbconvert")
            raise

        outputPath = os.path.splitext(self.sourceToAutogenerated(ipythonNotebookFilePath))[0]

        app = nb.NbConvertApp.instance() # @UndefinedVariable
        app.initialize(argv=['--to', 'rst', '--output', outputPath, ipythonNotebookFilePath])
        app.writer.build_directory = os.path.dirname(ipythonNotebookFilePath)
        app.start()
        return True

if __name__ == '__main__':
    i = IPythonNotebookReSTWriter()
    p5 = i.ipythonNotebookFilePaths[5]
    i.convertOneNotebook(p5)
    import music21
    music21.mainTest('moduleRelative')

    
    def testFastPopulate(self):
        '''
        tests that the isSorted speed up trick ends up producing identical results.
        '''
        from music21 import corpus
        sf = corpus.parse('bwv66.6').flat
        sfTree = sf.asTree()
        #print(sfTree)

        sf.isSorted = False
        sf._cache = {}
        sfTreeSlow = sf.asTree()
        for i in range(len(sf)):
            fasti = sfTree[i]
            slowi = sfTreeSlow[i]
            self.assertIs(fasti, slowi)

#     def xtestExampleScoreAsTimespans(self):
#         from music21 import tree
#         score = tree.makeExampleScore()
#         treeList = tree.fromStream.listOfTreesByClass(score, useTimespans=True)
#         tl0 = treeList[0]

        
#---------------------

if __name__ == '__main__':
    import music21
    music21.mainTest(Test) #, runTest='testExampleScoreAsTimespans')

#     def testWTCImport03(self):
#         score = corpus.parse('bach/bwv862', 1)
#         self.assertEqual(
#             score.metadata.title,
#             'WTC I: Prelude and Fugue in A flat major',
#             )

#     def testWTCImport04(self):
#         score = corpus.parse('bach/bwv888', 1)
#         self.assertEqual(
#             score.metadata.title,
#             'WTC II: Prelude and Fugue in A major',
#             )
#         #s.show()

#     def testWorkReferences(self):
#         s = corpus.getWorkReferences()
#
#         # presenly 19 top level lists
#         self.assertEqual(len(s)>=19, True)
#         self.assertEqual(len(s[0].keys()), 4)

if __name__ == '__main__':
    import music21
    music21.mainTest('noDocTest',Test)


# -----------------------------------------------------------------------------
# eof