public void Phrygian_mode()
{
var phrygian = ScaleGenerator.Pitches("e", "mMMMmMM");
var expected = new[] { "E", "F", "G", "A", "B", "C", "D" };
Assert.That(phrygian, Is.EqualTo(expected));
}
public void Locrian_mode()
{
var locrian = ScaleGenerator.Pitches("g", "mMMmMMM");
var expected = new[] { "G", "Ab", "Bb", "C", "Db", "Eb", "F" };
Assert.That(locrian, Is.EqualTo(expected));
}
public void Mixolydian_mode()
{
var mixolydian = ScaleGenerator.Pitches("Eb", "MMmMMmM");
var expected = new[] { "Eb", "F", "G", "Ab", "Bb", "C", "Db" };
Assert.That(mixolydian, Is.EqualTo(expected));
}
public void Lydian_mode()
{
var lydian = ScaleGenerator.Pitches("a", "MMMmMMm");
var expected = new[] { "A", "B", "C#", "D#", "E", "F#", "G#" };
Assert.That(lydian, Is.EqualTo(expected));
}
public void Dorian_mode()
{
var dorian = ScaleGenerator.Pitches("d", "MmMMMmM");
var expected = new[] { "D", "E", "F", "G", "A", "B", "C" };
Assert.That(dorian, Is.EqualTo(expected));
}
public void Major_scale()
{
var major = ScaleGenerator.Pitches("C", "MMmMMMm");
var expected = new[] { "C", "D", "E", "F", "G", "A", "B" };
Assert.That(major, Is.EqualTo(expected));
}
public void Minor_scale()
{
var minor = ScaleGenerator.Pitches("f#", "MmMMmMM");
var expected = new[] { "F#", "G#", "A", "B", "C#", "D", "E" };
Assert.That(minor, Is.EqualTo(expected));
}
public void Another_minor_scale()
{
var minor = ScaleGenerator.Pitches("bb", "MmMMmMM");
var expected = new[] { "Bb", "C", "Db", "Eb", "F", "Gb", "Ab" };
Assert.That(minor, Is.EqualTo(expected));
}
public void Enigmatic()
{
var enigmatic = ScaleGenerator.Pitches("G", "mAMMMmm");
var expected = new[] { "G", "G#", "B", "C#", "D#", "F", "F#" };
Assert.That(enigmatic, Is.EqualTo(expected));
}
public void Pentatonic()
{
var pentatonic = ScaleGenerator.Pitches("A", "MMAMA");
var expected = new[] { "A", "B", "C#", "E", "F#" };
Assert.That(pentatonic, Is.EqualTo(expected));
}
public void Hexatonic()
{
var hexatonic = ScaleGenerator.Pitches("Db", "MMMMMM");
var expected = new[] { "Db", "Eb", "F", "G", "A", "B" };
Assert.That(hexatonic, Is.EqualTo(expected));
}
public void Harmonic_minor()
{
var harmonicMinor = ScaleGenerator.Pitches("d", "MmMMmAm");
var expected = new[] { "D", "E", "F", "G", "A", "Bb", "Db" };
Assert.That(harmonicMinor, Is.EqualTo(expected));
}
public void Octatonic()
{
var octatonic = ScaleGenerator.Pitches("C", "MmMmMmMm");
var expected = new[] { "C", "D", "D#", "F", "F#", "G#", "A", "B" };
Assert.That(octatonic, Is.EqualTo(expected));
}
public void Another_major_scale()
{
var major = ScaleGenerator.Pitches("G", "MMmMMMm");
var expected = new[] { "G", "A", "B", "C", "D", "E", "F#" };
Assert.Equal(expected, major);
}
public void Major_scale_with_flats()
{
var expected = new[] { "F", "G", "A", "Bb", "C", "D", "E" };
var actual = ScaleGenerator.Interval("F", "MMmMMMm");
Assert.Equal(expected, actual);
}
public void Lydian_mode()
{
var expected = new[] { "A", "B", "C#", "D#", "E", "F#", "G#" };
Assert.Equal(expected, ScaleGenerator.Interval("a", "MMMmMMm"));
}
public void Mixolydian_mode()
{
var expected = new[] { "Eb", "F", "G", "Ab", "Bb", "C", "Db" };
Assert.Equal(expected, ScaleGenerator.Interval("Eb", "MMmMMmM"));
}
public void Chromatic_scale_with_sharps()
{
var expected = new[] { "C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B" };
Assert.Equal(expected, ScaleGenerator.Chromatic("C"));
}
public void Dorian_mode()
{
var expected = new[] { "D", "E", "F", "G", "A", "B", "C" };
Assert.Equal(expected, ScaleGenerator.Interval("d", "MmMMMmM"));
}
public void Minor_scale_with_flats()
{
var expected = new[] { "Bb", "C", "Db", "Eb", "F", "Gb", "Ab" };
Assert.Equal(expected, ScaleGenerator.Interval("bb", "MmMMmMM"));
}
public void Minor_scale_with_sharps()
{
var expected = new[] { "F#", "G#", "A", "B", "C#", "D", "E" };
Assert.Equal(expected, ScaleGenerator.Interval("f#", "MmMMmMM"));
}
public void Major_scale_with_sharps()
{
var expected = new[] { "G", "A", "B", "C", "D", "E", "F#" };
Assert.Equal(expected, ScaleGenerator.Interval("G", "MMmMMMm"));
}
public void Simple_major_scale()
{
var expected = new[] { "C", "D", "E", "F", "G", "A", "B" };
Assert.Equal(expected, ScaleGenerator.Interval("C", "MMmMMMm"));
}
public void Chromatic_scale_with_flats()
{
var expected = new[] { "F", "Gb", "G", "Ab", "A", "Bb", "B", "C", "Db", "D", "Eb", "E" };
Assert.Equal(expected, ScaleGenerator.Chromatic("F"));
}
public void Enigmatic()
{
var expected = new[] { "G", "G#", "B", "C#", "D#", "F", "F#" };
Assert.Equal(expected, ScaleGenerator.Interval("G", "mAMMMmm"));
}
public void Pentatonic()
{
var expected = new[] { "A", "B", "C#", "E", "F#" };
Assert.Equal(expected, ScaleGenerator.Interval("A", "MMAMA"));
}
public void Hexatonic()
{
var expected = new[] { "Db", "Eb", "F", "G", "A", "B" };
Assert.Equal(expected, ScaleGenerator.Interval("Db", "MMMMMM"));
}
public void Phrygian_mode()
{
var expected = new[] { "E", "F", "G", "A", "B", "C", "D" };
Assert.Equal(expected, ScaleGenerator.Interval("e", "mMMMmMM"));
}
public void Locrian_mode()
{
var expected = new[] { "G", "Ab", "Bb", "C", "Db", "Eb", "F" };
Assert.Equal(expected, ScaleGenerator.Interval("g", "mMMmMMM"));
}
public void Octatonic()
{
var expected = new[] { "C", "D", "D#", "F", "F#", "G#", "A", "B" };
Assert.Equal(expected, ScaleGenerator.Interval("C", "MmMmMmMm"));
}