def testinsertEnd(self):
a = PCSet(self.l)
b = PSet(self.l)
a.insert(6, 10)
b.insert(6, 99)
self.assertEqual(a.pitches, self.l + [10])
self.assertEqual(b.pitches, self.l + [99])
class EqualityTest(TestCase):
"""Equality checks between PCSets, PSets, and built ins"""
def setUp(self):
self.l = [0, 1, 2, 4, 5, 10 ,1 ,0]
self.s = set(self.l)
self.pcset = PCSet(self.l)
self.pset = PSet(self.l)
self.pset.ordered(False)
def testeqPPCSets(self):
self.assertTrue(self.pcset == self.pcset)
self.assertTrue(self.pset == self.pset)
self.assertTrue(self.pcset == self.pset)
def testeqPPCSet_list(self):
self.assertTrue(self.pcset == self.l and self.pset == self.l)
def testeqPPCSet_set(self):
self.assertTrue(self.pcset == self.s and self.pset == self.s)
def testeqPPCSet_int(self):
a = PCSet(3)
b = PSet(3)
self.assertTrue(a == 3 and b == 3)
def testinsertNegative(self):
a = PCSet(self.l, multiset=True)
b = PSet(self.l, multiset=True)
a.insert(-2, 2)
b.insert(-3, 12)
self.assertEqual(a.pitches, [1, 4, 23, 2, 5, -9])
self.assertEqual(b.pitches, [1, 4, 12, 23, 5, -9])
def testinsertMiddle(self):
a = PCSet(self.l)
b = PSet(self.l)
a.insert(3, 15)
b.insert(4, 8)
self.assertEqual(a.pitches, [1, 4, 23, 15, 5, -9])
self.assertEqual(b.pitches, [1, 4, 23, 5, 8, -9])
class ReprTest(TestCase):
"""PCSet and PSet repr's vary based on ordered and multiset settings"""
def setUp(self):
self.l = [0, 1, -7, 16, 1, 0]
self.pcset = PCSet(self.l)
self.pset = PSet(self.l)
def testreprO(self):
self.pcset.ordered(True)
self.pset.ordered(True)
self.pcset.multiset(False)
self.pset.multiset(False)
self.assertEqual(self.pcset.__repr__(), '[0, 1, 5, 4]')
self.assertEqual(self.pset.__repr__(), '[0, 1, -7, 16]')
def testreprO_Multi(self):
pcset = PCSet(self.l, ordered=True, multiset=True)
pset = PSet(self.l, ordered=True, multiset=True)
self.assertEqual(pcset.__repr__(), '[0, 1, 5, 4, 1, 0]')
self.assertEqual(pset.__repr__(), '[0, 1, -7, 16, 1, 0]')
def testreprUO(self):
self.pcset.ordered(False)
self.pset.ordered(False)
self.pcset.multiset(False)
self.pset.multiset(False)
self.assertEqual(self.pcset.__repr__(), '[0, 1, 4, 5]')
self.assertEqual(self.pset.__repr__(), '[-7, 0, 1, 16]')
def testreprUO_Multi(self):
pcset = PCSet(self.l, ordered=False, multiset=True)
pset = PSet(self.l, ordered=False, multiset=True)
self.assertEqual(pcset.__repr__(), '[0, 0, 1, 1, 4, 5]')
self.assertEqual(pset.__repr__(), '[-7, 0, 0, 1, 1, 16]')
def testinsertBegin(self):
a = PCSet(self.l)
b = PSet(self.l)
a.insert(0, 10)
b.insert(0, 11)
self.assertEqual(a.pitches, [10] + self.l)
self.assertEqual(b.pitches, [11] + self.l)
def testinsertAfter(self):
a = PCSet(self.l)
b = PSet(self.l)
a.insert(100, 1)
b.insert(100, 0)
self.assertEqual(a.pitches, self.l + [1])
self.assertEqual(b.pitches, self.l + [0])
class SettingsTest(TestCase):
"""PCSet and PSet instances have various methods to change settings"""
def setUp(self):
self.l = [0, 4, 9, 11]
self.pcset = PCSet(self.l)
self.pset = PSet(self.l)
def testMod(self):
self.pcset.mod(7)
self.pset.mod(13)
self.assertEqual(self.pcset._mod, 7)
self.assertEqual(self.pset._mod, 13)
def testModInvalid(self):
for n in [0, 32]:
self.assertRaises(self.pcset.InvalidModulus, self.pcset.mod, n)
def testCanon(self):
a = self.pcset
b = self.pset
a.canon(True, False, False)
b.canon(False, True, True)
self.assertTrue(
a._canon_t == True and a._canon_i == False and a._canon_m == False
)
self.assertTrue(
b._canon_t == False and b._canon_i == True and b._canon_m == True
)
def testDefault_m(self):
self.pcset.default_m(7)
self.assertEqual(self.pcset._default_m, 7)
def testOrdered(self):
self.pcset.ordered(True)
self.pset.ordered(True)
self.assertTrue(
self.pcset._ordered == True and self.pset._ordered == True
)
self.pcset.ordered(False)
self.pset.ordered(False)
self.assertTrue(
self.pcset._ordered == False and self.pset._ordered == False
)
def testMultiset(self):
self.pcset.multiset(True)
self.pset.multiset(True)
self.assertTrue(
self.pcset._multiset == True and self.pset._multiset == True
)
self.pcset.multiset(False)
self.pset.multiset(False)
self.assertTrue(
self.pcset._multiset == False and self.pset._multiset == False
)
class SequenceTest(TestCase):
"""PCSets and PSets behave like sequences with iteration and len()"""
def setUp(self):
self.l = [0, 1, 2, 4]
self.pcset = PCSet(self.l)
self.pset = PSet(self.l)
def testiterTest(self):
pcout = [pc for pc in self.pcset]
pout = [p for p in self.pset]
self.assertTrue(pcout == self.l and pout == self.l)
def testlenTest(self):
self.assertEqual(len(self.pcset), 4)
self.pset.multiset(False)
self.assertEqual(len(self.pset + [0, 2, 5]), 5)
self.pset.multiset(True)
self.assertEqual(len(self.pset + [0, 2, 5]), 7)
class GetItemTest(TestCase):
"""[x:y] PCSets and PSets should return pcs and pitches respectively"""
def setUp(self):
self.l = [0, 1, 2, 5, 7, 9, 35, 4]
self.pcset = PCSet(self.l)
self.pset = PSet(self.l)
def testgetInt(self):
self.assertEqual(self.pcset[6], [9])
self.assertEqual(self.pset[6], [9])
self.pset.ordered(True)
self.assertEqual(self.pset[6], [35])
def testgetRange(self):
self.assertEqual(self.pcset[2:5], [2, 4, 5])
def testgetNegative(self):
self.assertEqual(self.pcset[-1], [11])
def testgetAfter(self):
self.assertRaises(IndexError, self.pcset.__getitem__, 100)
class VarEqualsTnTm(TestCase):
"""operations that return a PCSet or PSet"""
def setUp(self):
self.l = [0, 2, 5, 20, -1]
self.pcset = PCSet(self.l)
self.pset = PSet(self.l)
def testTranspose(self):
a = self.pcset._transpose(5)
self.assertEqual(a.pitches, [5, 7, 10, 25, 4])
self.assertEqual(a.uo_pcs, [1, 4, 5, 7, 10])
self.assertEqual(a.__class__, PCSet)
b = self.pset._transpose(5)
self.assertEqual(b.pitches, [5, 7, 10, 25, 4])
self.assertEqual(b.__class__, PSet)
def testInvert(self):
a = self.pcset._invert()
self.assertEqual(a.pitches, [0, -2, -5, -20, 1])
self.assertEqual(a.uo_pcs, [0, 1, 4, 7, 10])
self.assertEqual(a.__class__, PCSet)
b = self.pset._invert(3)
self.assertEqual(b.pitches, [3, 1, -2, -17, 4])
self.assertEqual(b.__class__, PSet)
def testTranspose_multiply(self):
a = self.pcset._transpose_multiply(1, 11)
b = self.pset._transpose_multiply(5, 5)
c = self.pset._transpose_multiply(0, 5)
d = self.pcset._transpose_multiply(1, 1)
self.assertEqual(a, a._transpose_multiply(0, 1))
self.assertEqual(a.pcs, [1, 11, 8, 5, 2])
self.assertEqual(b.pcs, [5, 3, 6, 9, 0])
self.assertEqual(c.pcs, self.pcset._transpose_multiply())
self.assertEqual(d, self.pcset._transpose(1))
def setUp(self):
self.l = [0, 2, 5, 20, -1]
self.pcset = PCSet(self.l)
self.pset = PSet(self.l)
def setUp(self):
self.a = PSet(0, 4, 7, ordered=True, multiset=True)
def setUp(self):
self.l = [0, 4, 9, 11]
self.pcset = PCSet(self.l)
self.pset = PSet(self.l)
class NeoRTest(TestCase):
"""Test pcs, _pc_sets, _setify, _unique_pcs and related methods"""
def setUp(self):
self.a = PSet(0, 4, 7, ordered=True, multiset=True)
def testMod12Required(self):
a = self.a.copy()
a.mod(11)
self.assertRaises(a.Mod12Only, a.P)
self.assertRaises(a.Mod12Only, a.L)
self.assertRaises(a.Mod12Only, a.R)
def testP(self):
a = self.a
# P() is an involution
self.assertEqual(a.P().P(), a)
self.assertEqual(a.P(), [0, 3, 7])
self.assertEqual((a + [0, 4, 4, 0, 7]).P(), [0, 3, 7, 0, 3, 3, 0, 7])
a.i(8)
# a is Db major. a.P is Db minor
self.assertEqual(a.P(), [8, 5, 1])
def testR(self):
a = self.a
# R() is an involution
self.assertEqual(a.R().R(), a)
self.assertEqual(a.R(), [0, 4, 9])
self.assertEqual((a + [0, 4, 4, 0, 7]).R(), [0, 4, 9, 0, 4, 4, 0, 9])
a.i(1)
# a is F# minor, a.R() is A major
self.assertEqual(a.R(), [1, -3, -8])
def testL(self):
a = self.a
# L() is an involution
self.assertEqual(a.L().L(), a)
self.assertEqual(a.L(), [-1, 4, 7])
self.assertEqual((a + [0, 4, 4, 0, 7]).L(), [-1, 4, 7, -1, 4, 4, -1, 7])
a.i(5)
# a is Bb minor, a.L() is Gb major
self.assertEqual(a.L(), [6, 1, -2])
def testN(self):
self.assertEqual(self.a.N(), self.a.R().L().P())
self.assertEqual(self.a.N().N(), self.a)
def testS(self):
self.assertEqual(self.a.S(), self.a.L().P().R())
self.assertEqual(self.a.S().S(), self.a)
def testH(self):
self.assertEqual(self.a.H(), self.a.P().L().P())
self.assertEqual(self.a.H(), self.a.L().P().L())
self.assertEqual(self.a.H().H(), self.a)
def testNeo(self):
self.assertEqual(list(self.a.neo("PP")), [[0, 3, 7], [0, 4, 7]])
self.assertEqual(list(self.a.neo("prL")),
[[0, 3, 7], [-2, 3, 7], [-2, 2, 7]]
)
self.assertEqual(list(self.a.neo("PP")), list(self.a.neo("PP")))
def testNeoInvalid(self):
self.assertEqual(list(self.a.neo("am")), [])
self.assertEqual(list(self.a.neo("AmPl")), list(self.a.neo("pl")))
def testCycle(self):
self.assertEqual(list(self.a.cycle("pl")), [
[0, 3, 7], [0, 3, 8], [-1, 3, 8], [-1, 4, 8], [-1, 4, 7], [0, 4, 7]
])
self.assertEqual(list(self.a.cycle("pLr")), [
[0, 3, 7], [0, 3, 8], [0, 5, 8], [0, 5, 9], [0, 4, 9], [0, 4, 7]
])
def testCycleInvalid(self):
self.assertEqual(list(self.a.cycle("foo")), [])
self.assertEqual(list(self.a.cycle("fooL")), [[-1, 4, 7], [0, 4, 7]])
def testTransform(self):
# 'z' Added to make sure invalid names are ignored
fs = ['p', 'l', 'r', 'h', 's', 'n', 'z']
opers = ""
while len(opers) < 10:
opers += random.choice(fs)
neos = list(self.a.neo(opers))
if neos:
self.assertEqual(neos[-1], self.a.transform(opers))
def testPaths(self):
self.assertEqual(set(self.a.paths(self.a)), set(['PP', 'LL', 'RR']))
fs = ['p', 'l', 'r', 'z']
opers = ""
for n in range(0, random.randint(0, 10)):
opers += random.choice(fs)
paths = self.a.paths(self.a.transform(opers))
path = random.choice(paths)
self.assertEqual(self.a.transform(opers)._pc_set, self.a.transform(path)._pc_set)
b = self.a.copy()
b.i(random.randint(0, 12))
self.assertTrue(self.a.paths(b))
b.i(random.randint(0, 12))
self.assertTrue(self.a.paths(b))
def testPathsInvalid(self):
b = PSet([0, 3, 4, 7]) # Two thirds present
self.assertRaises(PSet.NotNeoR, self.a.paths, b)
def testcopyPitches(self):
a = PCSet(self.l)
b = PSet(self.l)
c = a.copy()
d = b.copy()
self.assertTrue(c.pitches == self.l and d.pitches == self.l)
def setUp(self):
self.l = [0, 1, 2, 4]
self.pcset = PCSet(self.l)
self.pset = PSet(self.l)
def testclearPSet(self):
a = PSet(self.l)
a.clear()
self.assertTrue(a.pcs == [] and a.pitches == [])
def setUp(self):
self.l = [0, 1, -7, 16, 1, 0]
self.pcset = PCSet(self.l)
self.pset = PSet(self.l)
def testreprO_Multi(self):
pcset = PCSet(self.l, ordered=True, multiset=True)
pset = PSet(self.l, ordered=True, multiset=True)
self.assertEqual(pcset.__repr__(), '[0, 1, 5, 4, 1, 0]')
self.assertEqual(pset.__repr__(), '[0, 1, -7, 16, 1, 0]')
def setUp(self):
self.l = [0, 1, 2, 4, 5, 10 ,1 ,0]
self.s = set(self.l)
self.pcset = PCSet(self.l)
self.pset = PSet(self.l)
self.pset.ordered(False)
def testreprUO_Multi(self):
pcset = PCSet(self.l, ordered=False, multiset=True)
pset = PSet(self.l, ordered=False, multiset=True)
self.assertEqual(pcset.__repr__(), '[0, 0, 1, 1, 4, 5]')
self.assertEqual(pset.__repr__(), '[-7, 0, 0, 1, 1, 16]')
