trackler 2.1.0.16 → 2.1.0.17

data/tracks/typescript/exercises/grade-school/grade-school.test.ts

@@ -11,14 +11,14 @@ describe('School', () => {
     expect(gradeSchool.studentRoster().size === 0).toEqual(true)
   })
 
-  it('adding a student adds them to the roster for the given grade', () => {
+  xit('adding a student adds them to the roster for the given grade', () => {
     gradeSchool.addStudent('Aimee', 2)
 
     const expectedDb = new Map(Object.entries({ 2 : [ 'Aimee' ] }))
     expect(gradeSchool.studentRoster()).toEqual(expectedDb)
   })
 
-  it('adding more students to the same grade adds them to the roster', () => {
+  xit('adding more students to the same grade adds them to the roster', () => {
     gradeSchool.addStudent('Blair', 2)
     gradeSchool.addStudent('James', 2)
     gradeSchool.addStudent('Paul', 2)
@@ -27,7 +27,7 @@ describe('School', () => {
     expect(gradeSchool.studentRoster()).toEqual(expectedDb)
   })
 
-  it('adding students to different grades adds them to the roster', () => {
+  xit('adding students to different grades adds them to the roster', () => {
     gradeSchool.addStudent('Chelsea', 3)
     gradeSchool.addStudent('Logan', 7)
 
@@ -35,7 +35,7 @@ describe('School', () => {
     expect(gradeSchool.studentRoster()).toEqual(expectedDb)
   })
 
-  it('grade returns the students in that grade in alphabetical order', () => {
+  xit('grade returns the students in that grade in alphabetical order', () => {
     gradeSchool.addStudent('Franklin', 5)
     gradeSchool.addStudent('Bradley', 5)
     gradeSchool.addStudent('Jeff', 1)
@@ -44,11 +44,11 @@ describe('School', () => {
     expect(gradeSchool.studentsInGrade(5)).toEqual(expectedStudents)
   })
 
-  it('grade returns an empty array if there are no students in that grade', () => {
+  xit('grade returns an empty array if there are no students in that grade', () => {
     expect(gradeSchool.studentsInGrade(1)).toEqual([])
   })
 
-  it('the students names in each grade in the roster are sorted', () => {
+  xit('the students names in each grade in the roster are sorted', () => {
     gradeSchool.addStudent('Jennifer', 4)
     gradeSchool.addStudent('Kareem', 6)
     gradeSchool.addStudent('Christopher', 4)
@@ -62,7 +62,7 @@ describe('School', () => {
     expect(gradeSchool.studentRoster()).toEqual(expectedSortedStudents)
   })
 
-  it('roster cannot be modified outside of module', () => {
+  xit('roster cannot be modified outside of module', () => {
     gradeSchool.addStudent('Aimee', 2)
     const roster = gradeSchool.studentRoster()
     const result = roster.get('2') || []
@@ -71,7 +71,7 @@ describe('School', () => {
     expect(gradeSchool.studentRoster()).toEqual(expectedDb)
   })
 
-  it('roster cannot be modified outside of module using studentsInGrade()', () => {
+  xit('roster cannot be modified outside of module using studentsInGrade()', () => {
     gradeSchool.addStudent('Aimee', 2)
     gradeSchool.studentsInGrade(2).push('Oops.')
     const expectedDb = new Map(Object.entries({ 2 : [ 'Aimee' ] }))

data/tracks/typescript/exercises/hamming/hamming.test.ts

@@ -7,31 +7,31 @@ describe('Hamming', () => {
     expect(hamming.compute('A', 'A')).toEqual(0)
   })
 
-  it('complete hamming distance for single nucleotide strand', () => {
+  xit('complete hamming distance for single nucleotide strand', () => {
     expect(hamming.compute('A', 'G')).toEqual(1)
   })
 
-  it('complete hamming distance for small strand', () => {
+  xit('complete hamming distance for small strand', () => {
     expect(hamming.compute('AG', 'CT')).toEqual(2)
   })
 
-  it('small hamming distance', () => {
+  xit('small hamming distance', () => {
     expect(hamming.compute('AT', 'CT')).toEqual(1)
   })
 
-  it('small hamming distance in longer strand', () => {
+  xit('small hamming distance in longer strand', () => {
     expect(hamming.compute('GGACG', 'GGTCG')).toEqual(1)
   })
 
-  it('large hamming distance', () => {
+  xit('large hamming distance', () => {
     expect(hamming.compute('GATACA', 'GCATAA')).toEqual(4)
   })
 
-  it('hamming distance in very long strand', () => {
+  xit('hamming distance in very long strand', () => {
     expect(hamming.compute('GGACGGATTCTG', 'AGGACGGATTCT')).toEqual(9)
   })
 
-  it('throws error when strands are not equal length', () => {
+  xit('throws error when strands are not equal length', () => {
     expect(() => { hamming.compute('GGACGGATTCTG', 'AGGAC') }
     ).toThrowError('DNA strands must be of equal length.' )
   })

data/tracks/typescript/exercises/hello-world/hello-world.test.ts

@@ -7,11 +7,11 @@ describe('Hello World', () => {
     expect(HelloWorld.hello()).toEqual('Hello, World!')
   })
 
-  it('says hello to bob', () => {
+  xit('says hello to bob', () => {
     expect(HelloWorld.hello('Bob')).toEqual('Hello, Bob!')
   })
 
-  it('says hello to sally', () => {
+  xit('says hello to sally', () => {
     expect(HelloWorld.hello('Sally')).toEqual('Hello, Sally!')
   })
 })

data/tracks/typescript/exercises/leap/leap.test.ts

@@ -6,33 +6,33 @@ describe('A leap year', () => {
     expect(isLeapYear(2015)).toBeFalsy()
   })
 
-  it('is introduced every 4 years to adjust about a day', () => {
+  xit('is introduced every 4 years to adjust about a day', () => {
     expect(isLeapYear(2016)).toBeTruthy()
   })
 
-  it('is skipped every 100 years to remove an extra day', () => {
+  xit('is skipped every 100 years to remove an extra day', () => {
     expect(isLeapYear(1900)).toBeFalsy()
   })
 
-  it('is reintroduced every 400 years to adjust another day', () => {
+  xit('is reintroduced every 400 years to adjust another day', () => {
     expect(isLeapYear(2000)).toBeTruthy()
   })
 
   describe('Additional example of a leap year that', () => {
 
-    it('is not a leap year', () => {
+    xit('is not a leap year', () => {
       expect(isLeapYear(1978)).toBeFalsy()
     })
 
-    it('is a common leap year', () => {
+    xit('is a common leap year', () => {
       expect(isLeapYear(1992)).toBeTruthy()
     })
 
-    it('is skipped every 100 years', () => {
+    xit('is skipped every 100 years', () => {
       expect(isLeapYear(2100)).toBeFalsy()
     })
 
-    it('is reintroduced every 400 years', () => {
+    xit('is reintroduced every 400 years', () => {
       expect(isLeapYear(2400)).toBeTruthy()
     })
   })

data/tracks/typescript/exercises/pangram/pangram.test.ts

@@ -7,42 +7,42 @@ describe('Pangram()', () => {
     expect(pangram.isPangram()).toBe(false)
   })
 
-  it('pangram with only lower case', () => {
+  xit('pangram with only lower case', () => {
     const pangram = new Pangram("the quick brown fox jumps over the lazy dog")
     expect(pangram.isPangram()).toBe(true)
   })
 
-  it("missing character 'x'", () => {
+  xit("missing character 'x'", () => {
     const pangram = new Pangram("a quick movement of the enemy will jeopardize five gunboats")
     expect(pangram.isPangram()).toBe(false)
   })
 
-  it("another missing character 'x'", () => {
+  xit("another missing character 'x'", () => {
     const pangram = new Pangram("the quick brown fish jumps over the lazy dog")
     expect(pangram.isPangram()).toBe(false)
   })
 
-  it("pangram with underscores", () => {
+  xit("pangram with underscores", () => {
     const pangram = new Pangram("the_quick_brown_fox_jumps_over_the_lazy_dog")
     expect(pangram.isPangram()).toBe(true)
   })
 
-  it("pangram with numbers", () => {
+  xit("pangram with numbers", () => {
     const pangram = new Pangram("the 1 quick brown fox jumps over the 2 lazy dogs")
     expect(pangram.isPangram()).toBe(true)
   })
 
-  it('missing letters replaced by numbers', () => {
+  xit('missing letters replaced by numbers', () => {
     const pangram = new Pangram("7h3 qu1ck brown fox jumps ov3r 7h3 lazy dog")
     expect(pangram.isPangram()).toBe(false)
   })
 
-  it('pangram with mixed case and punctuation', () => {
+  xit('pangram with mixed case and punctuation', () => {
     const pangram = new Pangram("\"Five quacking Zephyrs jolt my wax bed.\"")
     expect(pangram.isPangram()).toBe(true)
   })
 
-  it('pangram with non-ascii characters', () => {
+  xit('pangram with non-ascii characters', () => {
     const pangram = new Pangram("Victor jagt zwölf Boxkämpfer quer über den großen Sylter Deich.")
     expect(pangram.isPangram()).toBe(true)
   })

data/tracks/typescript/exercises/phone-number/phone-number.test.ts

@@ -7,47 +7,47 @@ describe('PhoneNumber()', () => {
     expect(phone.number()).toEqual('1234567890')
   })
 
-  it('cleans numbers with dots', () => {
+  xit('cleans numbers with dots', () => {
     const phone = new PhoneNumber('123.456.7890')
     expect(phone.number()).toEqual('1234567890')
   })
 
-  it('cleans numbers with multiple spaces', () => {
+  xit('cleans numbers with multiple spaces', () => {
     const phone = new PhoneNumber('123 456   7890   ')
     expect(phone.number()).toEqual('1234567890')
   })
 
-  it('invalid when 9 digits', () => {
+  xit('invalid when 9 digits', () => {
     const phone = new PhoneNumber('123456789')
     expect(phone.number()).toEqual(undefined)
   })
 
-  it('invalid when 11 digits', () => {
+  xit('invalid when 11 digits', () => {
     const phone = new PhoneNumber('21234567890')
     expect(phone.number()).toEqual(undefined)
   })
 
-  it('valid when 11 digits and starting with 1', () => {
+  xit('valid when 11 digits and starting with 1', () => {
     const phone = new PhoneNumber('11234567890')
     expect(phone.number()).toEqual('1234567890')
   })
 
-  it('invalid when 12 digits', () => {
+  xit('invalid when 12 digits', () => {
     const phone = new PhoneNumber('321234567890')
     expect(phone.number()).toEqual(undefined)
   })
 
-  it('invalid with letters', () => {
+  xit('invalid with letters', () => {
     const phone = new PhoneNumber('123-abc-7890')
     expect(phone.number()).toEqual(undefined)
   })
 
-  it('invalid with punctuations', () => {
+  xit('invalid with punctuations', () => {
     const phone = new PhoneNumber('123-@:!-7890')
     expect(phone.number()).toEqual(undefined)
   })
 
-  it('invalid with right number of digits but letters mixed in', () => {
+  xit('invalid with right number of digits but letters mixed in', () => {
     const phone = new PhoneNumber('1a2b3c4d5e6f7g8h9i0j')
     expect(phone.number()).toEqual(undefined)
   })

data/tracks/typescript/exercises/rna-transcription/rna-transcription.test.ts

@@ -7,36 +7,36 @@ describe('Transcriptor', () => {
     expect(transcriptor.toRna('C')).toEqual('G')
   })
 
-  it('transcribes guanine to cytosine', () => {
+  xit('transcribes guanine to cytosine', () => {
     expect(transcriptor.toRna('G')).toEqual('C')
   })
 
-  it('transcribes adenine to uracil', () => {
+  xit('transcribes adenine to uracil', () => {
     expect(transcriptor.toRna('A')).toEqual('U')
   })
 
-  it('transcribes thymine to adenine', () => {
+  xit('transcribes thymine to adenine', () => {
     expect(transcriptor.toRna('T')).toEqual('A')
   })
 
-  it('transcribes all dna nucleotides to their rna complements', () => {
+  xit('transcribes all dna nucleotides to their rna complements', () => {
     expect(transcriptor.toRna('ACGTGGTCTTAA'))
         .toEqual('UGCACCAGAAUU')
   })
 
-  it('correctly handles invalid input', () => {
+  xit('correctly handles invalid input', () => {
     expect(() => transcriptor.toRna('U')).toThrowError(
       'Invalid input DNA.'
     )
   })
 
-  it('correctly handles completely invalid input', () => {
+  xit('correctly handles completely invalid input', () => {
     expect(() => transcriptor.toRna('XXX')).toThrowError(
       'Invalid input DNA.'
     )
   })
 
-  it('correctly handles partially invalid input', () => {
+  xit('correctly handles partially invalid input', () => {
     expect(() => transcriptor.toRna('ACGTXXXCTTAA')).toThrowError(
       'Invalid input DNA.'
     )

data/tracks/typescript/exercises/robot-name/robot-name.test.ts

@@ -11,16 +11,16 @@ describe('Robot', () => {
     expect(robot.name).toMatch(/^[A-Z]{2}\d{3}$/)
   })
 
-  it('name is the same each time', () => {
+  xit('name is the same each time', () => {
     expect(robot.name).toEqual(robot.name)
   })
 
-  it('different robots have different names', () => {
+  xit('different robots have different names', () => {
     const differentRobot = new RobotName()
     expect(differentRobot.name).not.toEqual(robot.name)
   })
 
-  it('is able to reset the name', () => {
+  xit('is able to reset the name', () => {
     const originalName = robot.name
 
     robot.resetName()
@@ -30,7 +30,7 @@ describe('Robot', () => {
     expect(originalName).not.toEqual(newName)
   })
 
-  it('should set a unique name after reset', () => {
+  xit('should set a unique name after reset', () => {
     const NUMBER_OF_ROBOTS = 10000
     const usedNames = new Set()
 
@@ -43,12 +43,12 @@ describe('Robot', () => {
     expect(usedNames.size).toEqual(NUMBER_OF_ROBOTS + 1)
   })
 
-  it('internal name cannot be modified', () => {
+  xit('internal name cannot be modified', () => {
     const modifyInternal = () => robot.name += "a modification"
     expect(modifyInternal).toThrow()
   })
 
-  it('new names should not be sequential', () => {
+  xit('new names should not be sequential', () => {
     const name1 = robot.name
     const name2 = (new RobotName()).name
     const name3 = (new RobotName()).name
@@ -57,7 +57,7 @@ describe('Robot', () => {
     expect(areSequential(name2, name3)).toBe(false)
   })
 
-  it('names from reset should not be sequential', () => {
+  xit('names from reset should not be sequential', () => {
     const name1 = robot.name
     robot.resetName()
     const name2 = robot.name

data/tracks/typescript/exercises/say/say.test.ts

@@ -6,56 +6,56 @@ describe('say', () => {
     expect(say.inEnglish(0)).toBe('zero')
   })
 
-  it('one', () => {
+  xit('one', () => {
     expect(say.inEnglish(1)).toBe('one')
   })
 
-  it('fourteen', () => {
+  xit('fourteen', () => {
     expect(say.inEnglish(14)).toBe('fourteen')
   })
 
-  it('twenty', () => {
+  xit('twenty', () => {
     expect(say.inEnglish(20)).toBe('twenty')
   })
 
-  it('twenty-two', () => {
+  xit('twenty-two', () => {
     expect(say.inEnglish(22)).toBe('twenty-two')
   })
 
-  it('one hundred', () => {
+  xit('one hundred', () => {
     expect(say.inEnglish(100)).toBe('one hundred')
   })
 
-  it('one hundred twenty-three', () => {
+  xit('one hundred twenty-three', () => {
     expect(say.inEnglish(123)).toBe('one hundred twenty-three')
   })
 
-  it('one thousand', () => {
+  xit('one thousand', () => {
     expect(say.inEnglish(1000)).toBe('one thousand')
   })
 
-  it('one thousand two hundred thirty-four', () => {
+  xit('one thousand two hundred thirty-four', () => {
     expect(say.inEnglish(1234)).toBe('one thousand two hundred thirty-four')
   })
 
-  it('one million', () => {
+  xit('one million', () => {
     expect(say.inEnglish(1000000)).toBe('one million')
   })
 
-  it('one million two', () => {
+  xit('one million two', () => {
     expect(say.inEnglish(1000002)).toBe('one million two')
   })
 
-  it('one million two thousand three hundred forty-five', () => {
+  xit('one million two thousand three hundred forty-five', () => {
     expect(say.inEnglish(1002345))
       .toBe('one million two thousand three hundred forty-five')
   })
 
-  it('one billion', () => {
+  xit('one billion', () => {
     expect(say.inEnglish(1000000000)).toBe('one billion')
   })
 
-  it('a really big number', () => {
+  xit('a really big number', () => {
     let expected = 'nine hundred eighty-seven billion '
     expected += 'six hundred fifty-four million '
     expected += 'three hundred twenty-one thousand '
@@ -63,13 +63,13 @@ describe('say', () => {
     expect(say.inEnglish(987654321123)).toBe(expected)
   })
 
-  it('raises an error below zero', () => {
+  xit('raises an error below zero', () => {
     expect(() => {
       say.inEnglish(-1)
     }).toThrowError('Number must be between 0 and 999,999,999,999.')
   })
 
-  it('raises an error above 999,999,999,999', () => {
+  xit('raises an error above 999,999,999,999', () => {
     expect(() => {
       say.inEnglish(1000000000000)
     }).toThrowError('Number must be between 0 and 999,999,999,999.')

data/tracks/typescript/exercises/space-age/space-age.test.ts

@@ -7,48 +7,48 @@ describe('Space Age', () => {
     expect(age.seconds).toEqual(1000000)
   })
 
-  it('age in earth years', () => {
+  xit('age in earth years', () => {
     const age = new SpaceAge(1000000000)
     expect(age.onEarth()).toEqual(31.69)
   })
 
-  it('age in mercury years', () => {
+  xit('age in mercury years', () => {
     const age = new SpaceAge(2134835688)
     expect(age.onEarth()).toEqual(67.65)
     expect(age.onMercury()).toEqual(280.88)
   })
 
-  it('age in venus years', () => {
+  xit('age in venus years', () => {
     const age = new SpaceAge(189839836)
     expect(age.onEarth()).toEqual(6.02)
     expect(age.onVenus()).toEqual(9.78)
   })
 
-  it('age in mars years', () => {
+  xit('age in mars years', () => {
     const age = new SpaceAge(2329871239)
     expect(age.onEarth()).toEqual(73.83)
     expect(age.onMars()).toEqual(39.25)
   })
 
-  it('age in jupiter years', () => {
+  xit('age in jupiter years', () => {
     const age = new SpaceAge(901876382)
     expect(age.onEarth()).toEqual(28.58)
     expect(age.onJupiter()).toEqual(2.41)
   })
 
-  it('age in saturn years', () => {
+  xit('age in saturn years', () => {
     const age = new SpaceAge(3000000000)
     expect(age.onEarth()).toEqual(95.06)
     expect(age.onSaturn()).toEqual(3.23)
   })
 
-  it('age in uranus years', () => {
+  xit('age in uranus years', () => {
     const age = new SpaceAge(3210123456)
     expect(age.onEarth()).toEqual(101.72)
     expect(age.onUranus()).toEqual(1.21)
   })
 
-  it('age in neptune year', () => {
+  xit('age in neptune year', () => {
     const age = new SpaceAge(8210123456)
     expect(age.onEarth()).toEqual(260.16)
     expect(age.onNeptune()).toEqual(1.58)

data/tracks/typescript/exercises/word-count/word-count.test.ts

@@ -8,57 +8,57 @@ describe('words()', () => {
     expect(words.count('word')).toEqual(expectedCounts)
   })
 
-  it('counts one of each', () => {
+  xit('counts one of each', () => {
     const expectedCounts = new Map(Object.entries({ one: 1, of: 1, each: 1 }))
     expect(words.count('one of each')).toEqual(expectedCounts)
   })
 
-  it('counts multiple occurrences', () => {
+  xit('counts multiple occurrences', () => {
     const expectedCounts = new Map(Object.entries({ one : 1, fish: 4, two: 1, red: 1, blue: 1 }))
     expect(words.count('one fish two fish red fish blue fish')).toEqual(expectedCounts)
   })
 
-  it('includes punctuation', () => {
+  xit('includes punctuation', () => {
     const expectedCounts = new Map(Object.entries({ car: 1, ':': 2, carpet: 1, as: 1, java: 1, 'javascript!!&@$%^&': 1 }))
     expect(words.count('car : carpet as java : javascript!!&@$%^&')).toEqual(expectedCounts)
   })
 
-  it('includes numbers', () => {
+  xit('includes numbers', () => {
     const expectedCounts = new Map(Object.entries({ testing: 2, 1: 1, 2: 1 }))
     expect(words.count('1 2 testing testing')).toEqual(expectedCounts)
   })
 
-  it('normalizes to lower case', () => {
+  xit('normalizes to lower case', () => {
     const expectedCounts = new Map(Object.entries({ go: 3 }))
     expect(words.count('go Go GO')).toEqual(expectedCounts)
   })
 
-  it('counts properly international characters', () => {
+  xit('counts properly international characters', () => {
     const expectedCounts = new Map(Object.entries({ '¡hola!': 1, '¿qué': 1, 'tal?': 1, 'привет!': 1 }))
     expect(words.count('¡Hola! ¿Qué tal? Привет!')).toEqual(expectedCounts)
   })
 
-  it('counts multiline', () => {
+  xit('counts multiline', () => {
     const expectedCounts = new Map(Object.entries({ hello: 1, world: 1 }))
     expect(words.count('hello\nworld')).toEqual(expectedCounts)
   })
 
-  it('counts tabs', () => {
+  xit('counts tabs', () => {
     const expectedCounts = new Map(Object.entries({ hello: 1, world: 1 }))
     expect(words.count('hello\tworld')).toEqual(expectedCounts)
   })
 
-  it('counts multiple spaces as one', () => {
+  xit('counts multiple spaces as one', () => {
     const expectedCounts = new Map(Object.entries({ hello: 1, world: 1 }))
     expect(words.count('hello  world')).toEqual(expectedCounts)
   })
 
-  it('does not count leading or trailing whitespace', () => {
+  xit('does not count leading or trailing whitespace', () => {
     const expectedCounts = new Map(Object.entries({ introductory: 1, course: 1 }))
     expect(words.count('\t\tIntroductory Course      ')).toEqual(expectedCounts)
   })
 
-  it('handles properties that exist on Object’s prototype', () => {
+  xit('handles properties that exist on Object’s prototype', () => {
     const expectedCounts = new Map(Object.entries({ reserved: 1, words : 1, like : 1,  constructor: 1, and : 1, tostring: 1,  'ok?': 1}))
     expect(words.count('reserved words like constructor and toString ok?')).toEqual(expectedCounts)
   })