SHARE
TWEET

Untitled

a guest Sep 13th, 2017 62 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. import Foundation
  2. import Quick
  3. import Nimble
  4. @testable import Notes
  5.  
  6. class MajorDiatonicHarmonySpec: QuickSpec {
  7.    
  8.     override func spec() {
  9.        
  10.         describe("Major Diatonic Harmony") {
  11.            
  12.             context("C natural") {
  13.                
  14.                 it("should have the expected chords") {
  15.                     let key = Note(name: .C, intonation: .natural)
  16.                     let chords: [Chord] = DiatonicHarmony.major.chords(inKey: key)
  17.                     let expectedChords: [Chord] = [
  18.                         MajorSeventhChord(key: Note(name: .C, intonation: .natural)),
  19.                         MinorSeventhChord(key: Note(name: .D, intonation: .natural)),
  20.                         MinorSeventhChord(key: Note(name: .E, intonation: .natural)),
  21.                         MajorSeventhChord(key: Note(name: .F, intonation: .natural)),
  22.                         DominantSeventhChord(key: Note(name: .G, intonation: .natural)),
  23.                         MinorSeventhChord(key: Note(name: .A, intonation: .natural)),
  24.                         HalfDiminishedSeventhChord(key: Note(name: .B, intonation: .natural))
  25.                     ]
  26.                    
  27.                     expect(chords.count).to(equal(expectedChords.count))
  28.                    
  29.                     let chordNames = chords.map{$0.fullName()}
  30.                     let expectedChordNames = expectedChords.map{$0.fullName()}
  31.                    
  32.                     expect(chordNames).to(equal(expectedChordNames))
  33.                 }
  34.             }
  35.            
  36.             context("G natural") {
  37.                
  38.                 it("should have the expected chords") {
  39.                     let key = Note(name: .G, intonation: .natural)
  40.                     let chords: [Chord] = DiatonicHarmony.major.chords(inKey: key)
  41.                     let expectedChords: [Chord] = [
  42.                         MajorSeventhChord(key: Note(name: .G, intonation: .natural)),
  43.                         MinorSeventhChord(key: Note(name: .A, intonation: .natural)),
  44.                         MinorSeventhChord(key: Note(name: .B, intonation: .natural)),
  45.                         MajorSeventhChord(key: Note(name: .C, intonation: .natural)),
  46.                         DominantSeventhChord(key: Note(name: .D, intonation: .natural)),
  47.                         MinorSeventhChord(key: Note(name: .E, intonation: .natural)),
  48.                         HalfDiminishedSeventhChord(key: Note(name: .F, intonation: .sharp))
  49.                     ]
  50.                    
  51.                     expect(chords.count).to(equal(expectedChords.count))
  52.                    
  53.                     let chordNames = chords.map{$0.fullName()}
  54.                     let expectedChordNames = expectedChords.map{$0.fullName()}
  55.                    
  56.                     expect(chordNames).to(equal(expectedChordNames))
  57.                 }
  58.             }
  59.            
  60.             context("D natural") {
  61.                
  62.                 it("should have the expected chords") {
  63.                     let key = Note(name: .D, intonation: .natural)
  64.                     let chords: [Chord] = DiatonicHarmony.major.chords(inKey: key)
  65.                     let expectedChords: [Chord] = [
  66.                         MajorSeventhChord(key: Note(name: .D, intonation: .natural)),
  67.                         MinorSeventhChord(key: Note(name: .E, intonation: .natural)),
  68.                         MinorSeventhChord(key: Note(name: .F, intonation: .sharp)),
  69.                         MajorSeventhChord(key: Note(name: .G, intonation: .natural)),
  70.                         DominantSeventhChord(key: Note(name: .A, intonation: .natural)),
  71.                         MinorSeventhChord(key: Note(name: .B, intonation: .natural)),
  72.                         HalfDiminishedSeventhChord(key: Note(name: .C, intonation: .sharp))
  73.                     ]
  74.                    
  75.                     expect(chords.count).to(equal(expectedChords.count))
  76.                    
  77.                     let chordNames = chords.map{$0.fullName()}
  78.                     let expectedChordNames = expectedChords.map{$0.fullName()}
  79.                    
  80.                     expect(chordNames).to(equal(expectedChordNames))
  81.                 }
  82.             }
  83.            
  84.             context("A natural") {
  85.                
  86.                 it("should have the expected chords") {
  87.                     let key = Note(name: .A, intonation: .natural)
  88.                     let chords: [Chord] = DiatonicHarmony.major.chords(inKey: key)
  89.                     let expectedChords: [Chord] = [
  90.                         MajorSeventhChord(key: Note(name: .A, intonation: .natural)),
  91.                         MinorSeventhChord(key: Note(name: .B, intonation: .natural)),
  92.                         MinorSeventhChord(key: Note(name: .C, intonation: .sharp)),
  93.                         MajorSeventhChord(key: Note(name: .D, intonation: .natural)),
  94.                         DominantSeventhChord(key: Note(name: .E, intonation: .natural)),
  95.                         MinorSeventhChord(key: Note(name: .F, intonation: .sharp)),
  96.                         HalfDiminishedSeventhChord(key: Note(name: .G, intonation: .sharp))
  97.                     ]
  98.                    
  99.                     expect(chords.count).to(equal(expectedChords.count))
  100.                    
  101.                     let chordNames = chords.map{$0.fullName()}
  102.                     let expectedChordNames = expectedChords.map{$0.fullName()}
  103.                    
  104.                     expect(chordNames).to(equal(expectedChordNames))
  105.                 }
  106.             }
  107.            
  108.             context("E natural") {
  109.                
  110.                 it("should have the expected chords") {
  111.                     let key = Note(name: .E, intonation: .natural)
  112.                     let chords: [Chord] = DiatonicHarmony.major.chords(inKey: key)
  113.                     let expectedChords: [Chord] = [
  114.                         MajorSeventhChord(key: Note(name: .E, intonation: .natural)),
  115.                         MinorSeventhChord(key: Note(name: .F, intonation: .sharp)),
  116.                         MinorSeventhChord(key: Note(name: .G, intonation: .sharp)),
  117.                         MajorSeventhChord(key: Note(name: .A, intonation: .natural)),
  118.                         DominantSeventhChord(key: Note(name: .B, intonation: .natural)),
  119.                         MinorSeventhChord(key: Note(name: .C, intonation: .sharp)),
  120.                         HalfDiminishedSeventhChord(key: Note(name: .D, intonation: .sharp))
  121.                     ]
  122.                    
  123.                     expect(chords.count).to(equal(expectedChords.count))
  124.                    
  125.                     let chordNames = chords.map{$0.fullName()}
  126.                     let expectedChordNames = expectedChords.map{$0.fullName()}
  127.                    
  128.                     expect(chordNames).to(equal(expectedChordNames))
  129.                 }
  130.             }
  131.            
  132.             context("B natural") {
  133.                
  134.                 it("should have the expected chords") {
  135.                     let key = Note(name: .B, intonation: .natural)
  136.                     let chords: [Chord] = DiatonicHarmony.major.chords(inKey: key)
  137.                     let expectedChords: [Chord] = [
  138.                         MajorSeventhChord(key: Note(name: .B, intonation: .natural)),
  139.                         MinorSeventhChord(key: Note(name: .C, intonation: .sharp)),
  140.                         MinorSeventhChord(key: Note(name: .D, intonation: .sharp)),
  141.                         MajorSeventhChord(key: Note(name: .E, intonation: .natural)),
  142.                         DominantSeventhChord(key: Note(name: .F, intonation: .sharp)),
  143.                         MinorSeventhChord(key: Note(name: .G, intonation: .sharp)),
  144.                         HalfDiminishedSeventhChord(key: Note(name: .A, intonation: .sharp))
  145.                     ]
  146.                    
  147.                     expect(chords.count).to(equal(expectedChords.count))
  148.                    
  149.                     let chordNames = chords.map{$0.fullName()}
  150.                     let expectedChordNames = expectedChords.map{$0.fullName()}
  151.                    
  152.                     expect(chordNames).to(equal(expectedChordNames))
  153.                 }
  154.             }
  155.            
  156.             context("F sharp") {
  157.                
  158.                 it("should have the expected chords") {
  159.                     let key = Note(name: .F, intonation: .sharp)
  160.                     let chords: [Chord] = DiatonicHarmony.major.chords(inKey: key)
  161.                     let expectedChords: [Chord] = [
  162.                         MajorSeventhChord(key: Note(name: .F, intonation: .sharp)),
  163.                         MinorSeventhChord(key: Note(name: .G, intonation: .sharp)),
  164.                         MinorSeventhChord(key: Note(name: .A, intonation: .sharp)),
  165.                         MajorSeventhChord(key: Note(name: .B, intonation: .natural)),
  166.                         DominantSeventhChord(key: Note(name: .C, intonation: .sharp)),
  167.                         MinorSeventhChord(key: Note(name: .D, intonation: .sharp)),
  168.                         HalfDiminishedSeventhChord(key: Note(name: .E, intonation: .sharp))
  169.                     ]
  170.                    
  171.                     expect(chords.count).to(equal(expectedChords.count))
  172.                    
  173.                     let chordNames = chords.map{$0.fullName()}
  174.                     let expectedChordNames = expectedChords.map{$0.fullName()}
  175.                    
  176.                     expect(chordNames).to(equal(expectedChordNames))
  177.                 }
  178.             }
  179.            
  180.             context("G flat") {
  181.                
  182.                 it("should have the expected chords") {
  183.                     let key = Note(name: .G, intonation: .flat)
  184.                     let chords: [Chord] = DiatonicHarmony.major.chords(inKey: key)
  185.                     let expectedChords: [Chord] = [
  186.                         MajorSeventhChord(key: Note(name: .G, intonation: .flat)),
  187.                         MinorSeventhChord(key: Note(name: .A, intonation: .flat)),
  188.                         MinorSeventhChord(key: Note(name: .B, intonation: .flat)),
  189.                         MajorSeventhChord(key: Note(name: .C, intonation: .flat)),
  190.                         DominantSeventhChord(key: Note(name: .D, intonation: .flat)),
  191.                         MinorSeventhChord(key: Note(name: .E, intonation: .flat)),
  192.                         HalfDiminishedSeventhChord(key: Note(name: .F, intonation: .natural))
  193.                     ]
  194.                    
  195.                     expect(chords.count).to(equal(expectedChords.count))
  196.                    
  197.                     let chordNames = chords.map{$0.fullName()}
  198.                     let expectedChordNames = expectedChords.map{$0.fullName()}
  199.                    
  200.                     expect(chordNames).to(equal(expectedChordNames))
  201.                 }
  202.             }
  203.            
  204.             context("D flat") {
  205.                
  206.                 it("should have the expected chords") {
  207.                     let key = Note(name: .D, intonation: .flat)
  208.                     let chords: [Chord] = DiatonicHarmony.major.chords(inKey: key)
  209.                     let expectedChords: [Chord] = [
  210.                         MajorSeventhChord(key: Note(name: .D, intonation: .flat)),
  211.                         MinorSeventhChord(key: Note(name: .E, intonation: .flat)),
  212.                         MinorSeventhChord(key: Note(name: .F, intonation: .natural)),
  213.                         MajorSeventhChord(key: Note(name: .G, intonation: .flat)),
  214.                         DominantSeventhChord(key: Note(name: .A, intonation: .flat)),
  215.                         MinorSeventhChord(key: Note(name: .B, intonation: .flat)),
  216.                         HalfDiminishedSeventhChord(key: Note(name: .C, intonation: .natural))
  217.                     ]
  218.                    
  219.                     expect(chords.count).to(equal(expectedChords.count))
  220.                    
  221.                     let chordNames = chords.map{$0.fullName()}
  222.                     let expectedChordNames = expectedChords.map{$0.fullName()}
  223.                    
  224.                     expect(chordNames).to(equal(expectedChordNames))
  225.                 }
  226.             }
  227.            
  228.            
  229.            
  230.             context("A flat") {
  231.                
  232.                 it("should have the expected chords") {
  233.                     let key = Note(name: .A, intonation: .flat)
  234.                     let chords: [Chord] = DiatonicHarmony.major.chords(inKey: key)
  235.                     let expectedChords: [Chord] = [
  236.                         MajorSeventhChord(key: Note(name: .A, intonation: .flat)),
  237.                         MinorSeventhChord(key: Note(name: .B, intonation: .flat)),
  238.                         MinorSeventhChord(key: Note(name: .C, intonation: .natural)),
  239.                         MajorSeventhChord(key: Note(name: .D, intonation: .flat)),
  240.                         DominantSeventhChord(key: Note(name: .E, intonation: .flat)),
  241.                         MinorSeventhChord(key: Note(name: .F, intonation: .natural)),
  242.                         HalfDiminishedSeventhChord(key: Note(name: .G, intonation: .natural))
  243.                     ]
  244.                    
  245.                     expect(chords.count).to(equal(expectedChords.count))
  246.                    
  247.                     let chordNames = chords.map{$0.fullName()}
  248.                     let expectedChordNames = expectedChords.map{$0.fullName()}
  249.                    
  250.                     expect(chordNames).to(equal(expectedChordNames))
  251.                 }
  252.             }
  253.            
  254.             context("E flat") {
  255.                
  256.                 it("should have the expected chords") {
  257.                     let key = Note(name: .E, intonation: .flat)
  258.                     let chords: [Chord] = DiatonicHarmony.major.chords(inKey: key)
  259.                     let expectedChords: [Chord] = [
  260.                         MajorSeventhChord(key: Note(name: .E, intonation: .flat)),
  261.                         MinorSeventhChord(key: Note(name: .F, intonation: .natural)),
  262.                         MinorSeventhChord(key: Note(name: .G, intonation: .natural)),
  263.                         MajorSeventhChord(key: Note(name: .A, intonation: .flat)),
  264.                         DominantSeventhChord(key: Note(name: .B, intonation: .flat)),
  265.                         MinorSeventhChord(key: Note(name: .C, intonation: .natural)),
  266.                         HalfDiminishedSeventhChord(key: Note(name: .D, intonation: .natural))
  267.                     ]
  268.                    
  269.                     expect(chords.count).to(equal(expectedChords.count))
  270.                    
  271.                     let chordNames = chords.map{$0.fullName()}
  272.                     let expectedChordNames = expectedChords.map{$0.fullName()}
  273.                    
  274.                     expect(chordNames).to(equal(expectedChordNames))
  275.                 }
  276.             }
  277.            
  278.            
  279.            
  280.             context("B flat") {
  281.                 it("should have the expected chords") {
  282.                     let key = Note(name: .B, intonation: .flat)
  283.                     let chords: [Chord] = DiatonicHarmony.major.chords(inKey: key)
  284.                     let expectedChords: [Chord] = [
  285.                         MajorSeventhChord(key: Note(name: .B, intonation: .flat)),
  286.                         MinorSeventhChord(key: Note(name: .C, intonation: .natural)),
  287.                         MinorSeventhChord(key: Note(name: .D, intonation: .natural)),
  288.                         MajorSeventhChord(key: Note(name: .E, intonation: .flat)),
  289.                         DominantSeventhChord(key: Note(name: .F, intonation: .natural)),
  290.                         MinorSeventhChord(key: Note(name: .G, intonation: .natural)),
  291.                         HalfDiminishedSeventhChord(key: Note(name: .A, intonation: .natural))
  292.                     ]
  293.                    
  294.                     expect(chords.count).to(equal(expectedChords.count))
  295.                    
  296.                     let chordNames = chords.map{$0.fullName()}
  297.                     let expectedChordNames = expectedChords.map{$0.fullName()}
  298.                    
  299.                     expect(chordNames).to(equal(expectedChordNames))
  300.                 }
  301.             }
  302.            
  303.            
  304.            
  305.             context("F natural") {
  306.                 it("should have the expected chords") {
  307.                     let key = Note(name: .F, intonation: .natural)
  308.                     let chords: [Chord] = DiatonicHarmony.major.chords(inKey: key)
  309.                     let expectedChords: [Chord] = [
  310.                         MajorSeventhChord(key: Note(name: .F, intonation: .natural)),
  311.                         MinorSeventhChord(key: Note(name: .G, intonation: .natural)),
  312.                         MinorSeventhChord(key: Note(name: .A, intonation: .natural)),
  313.                         MajorSeventhChord(key: Note(name: .B, intonation: .flat)),
  314.                         DominantSeventhChord(key: Note(name: .C, intonation: .natural)),
  315.                         MinorSeventhChord(key: Note(name: .D, intonation: .natural)),
  316.                         HalfDiminishedSeventhChord(key: Note(name: .E, intonation: .natural))
  317.                     ]
  318.                    
  319.                     expect(chords.count).to(equal(expectedChords.count))
  320.                    
  321.                     let chordNames = chords.map{$0.fullName()}
  322.                     let expectedChordNames = expectedChords.map{$0.fullName()}
  323.                    
  324.                     expect(chordNames).to(equal(expectedChordNames))
  325.                 }
  326.             }
  327.            
  328.            
  329.            
  330.         }
  331.     }
  332.    
  333. }
RAW Paste Data
Top