trackler 2.1.0.53 → 2.1.0.54

data/tracks/ecmascript/exercises/robot-name/robot-name.spec.js

@@ -7,20 +7,20 @@ describe('Robot', () => {
     robot = new Robot();
   });
 
-  it('has a name', () => {
+  test('has a name', () => {
     expect(robot.name).toMatch(/^[A-Z]{2}\d{3}$/);
   });
 
-  xit('name is the same each time', () => {
+  xtest('name is the same each time', () => {
     expect(robot.name).toEqual(robot.name);
   });
 
-  xit('different robots have different names', () => {
+  xtest('different robots have different names', () => {
     const differentRobot = new Robot();
     expect(differentRobot.name).not.toEqual(robot.name);
   });
 
-  xit('is able to reset the name', () => {
+  xtest('is able to reset the name', () => {
     const originalName = robot.name;
 
     robot.reset();
@@ -30,7 +30,7 @@ describe('Robot', () => {
     expect(originalName).not.toEqual(newName);
   });
 
-  xit('should set a unique name after reset', () => {
+  xtest('should set a unique name after reset', () => {
     const NUMBER_OF_ROBOTS = 10000;
     const usedNames = new Set();
 
@@ -43,13 +43,13 @@ describe('Robot', () => {
     expect(usedNames.size).toEqual(NUMBER_OF_ROBOTS + 1);
   });
 
-  xit('internal name cannot be modified', () => {
+  xtest('internal name cannot be modified', () => {
     const modifyInternal = () => robot.name += "a modification";
     expect(modifyInternal).toThrow();
   });
 
 
-  xit('new names should not be sequential', () => {
+  xtest('new names should not be sequential', () => {
     const name1 = robot.name;
     const name2 = (new Robot()).name;
     const name3 = (new Robot()).name;
@@ -58,7 +58,7 @@ describe('Robot', () => {
     expect(areSequential(name2, name3)).toBe(false);
   });
 
-  xit('names from reset should not be sequential', () => {
+  xtest('names from reset should not be sequential', () => {
     const name1 = robot.name;
     robot.reset();
     const name2 = robot.name;
@@ -68,9 +68,9 @@ describe('Robot', () => {
     expect(areSequential(name2, name3)).toBe(false);
     expect(areSequential(name3, name3)).toBe(true);
   });
-  
+
   //This test is optional.
-  xit('there can be lots of robots with different names each', () => {
+  xtest('there can be lots of robots with different names each', () => {
     const NUMBER_OF_ROBOTS = 10000;
     const usedNames = new Set();
 

data/tracks/ecmascript/exercises/robot-simulator/package.json

@@ -25,9 +25,14 @@
       "env"
     ],
     "plugins": [
-      ["babel-plugin-transform-builtin-extend", {
-        "globals": ["Error"]
-      }]
+      [
+        "babel-plugin-transform-builtin-extend",
+        {
+          "globals": [
+            "Error"
+          ]
+        }
+      ]
     ]
   },
   "scripts": {

data/tracks/ecmascript/exercises/robot-simulator/robot-simulator.spec.js

@@ -3,7 +3,7 @@ import Robot from './robot-simulator';
 describe('Robot', function() {
   let robot = new Robot();
 
-  it('robot bearing', function() {
+  test('robot bearing', function() {
     const directions = [ 'east', 'west', 'north', 'south' ];
 
     directions.forEach(currentDirection => {
@@ -12,7 +12,7 @@ describe('Robot', function() {
     });
   });
 
-  xit('invalid robot bearing', function() {
+  xtest('invalid robot bearing', function() {
     try {
       robot.orient('crood');
     } catch(exception) {
@@ -20,117 +20,117 @@ describe('Robot', function() {
     }
   });
 
-  xit('turn right from north', function() {
+  xtest('turn right from north', function() {
     robot.orient('north');
     robot.turnRight();
     expect(robot.bearing).toEqual('east');
   });
 
-  xit('turn right from east', function() {
+  xtest('turn right from east', function() {
     robot.orient('east');
     robot.turnRight();
     expect(robot.bearing).toEqual('south');
   });
 
-  xit('turn right from south', function() {
+  xtest('turn right from south', function() {
     robot.orient('south');
     robot.turnRight();
     expect(robot.bearing).toEqual('west');
   });
 
-  xit('turn right from west', function() {
+  xtest('turn right from west', function() {
     robot.orient('west');
     robot.turnRight();
     expect(robot.bearing).toEqual('north');
   });
 
-  xit('turn left from north', function() {
+  xtest('turn left from north', function() {
     robot.orient('north');
     robot.turnLeft();
     expect(robot.bearing).toEqual('west');
   });
 
-  xit('turn left from east', function() {
+  xtest('turn left from east', function() {
     robot.orient('east');
     robot.turnLeft();
     expect(robot.bearing).toEqual('north');
   });
 
-  xit('turn left from south', function() {
+  xtest('turn left from south', function() {
     robot.orient('south');
     robot.turnLeft();
     expect(robot.bearing).toEqual('east');
   });
 
-  xit('turn left from west', function() {
+  xtest('turn left from west', function() {
     robot.orient('west');
     robot.turnLeft();
     expect(robot.bearing).toEqual('south');
   });
 
-  xit('robot coordinates', function() {
+  xtest('robot coordinates', function() {
     robot.at(3, 0);
     expect(robot.coordinates).toEqual([3, 0]);
   });
 
-  xit('other robot coordinates', function() {
+  xtest('other robot coordinates', function() {
     robot.at(-2, 5);
     expect(robot.coordinates).toEqual([-2, 5]);
   });
 
-  xit('advance when facing north', function() {
+  xtest('advance when facing north', function() {
     robot.at(0, 0);
     robot.orient('north');
     robot.advance();
     expect(robot.coordinates).toEqual([0, 1]);
   });
 
-  xit('advance when facing east', function() {
+  xtest('advance when facing east', function() {
     robot.at(0, 0);
     robot.orient('east');
     robot.advance();
     expect(robot.coordinates).toEqual([1, 0]);
   });
 
-  xit('advance when facing south', function() {
+  xtest('advance when facing south', function() {
     robot.at(0, 0);
     robot.orient('south');
     robot.advance();
     expect(robot.coordinates).toEqual([0, -1]);
   });
 
-  xit('advance when facing west', function() {
+  xtest('advance when facing west', function() {
     robot.at(0, 0);
     robot.orient('west');
     robot.advance();
     expect(robot.coordinates).toEqual([-1, 0]);
   });
 
-  xit('instructions for turning left', function() {
+  xtest('instructions for turning left', function() {
     expect(robot.instructions('L')).toEqual([ 'turnLeft' ]);
   });
 
-  xit('instructions for turning right', function() {
+  xtest('instructions for turning right', function() {
     expect(robot.instructions('R')).toEqual([ 'turnRight' ]);
   });
 
-  xit('instructions for advancing', function() {
+  xtest('instructions for advancing', function() {
     expect(robot.instructions('A')).toEqual([ 'advance' ]);
   });
 
-  xit('series of instructions', function() {
+  xtest('series of instructions', function() {
     expect(robot.instructions('RAAL'))
       .toEqual([ 'turnRight', 'advance', 'advance', 'turnLeft' ]);
   });
 
-  xit('instruct robot', function() {
+  xtest('instruct robot', function() {
     robot.place({ x: -2, y: 1, direction: 'east' });
     robot.evaluate('RLAALAL');
     expect(robot.coordinates).toEqual([0, 2]);
     expect(robot.bearing).toEqual('west');
   });
 
-  xit('instruct many robots', function() {
+  xtest('instruct many robots', function() {
     const robot1 = new Robot();
     const robot2 = new Robot();
     const robot3 = new Robot();
@@ -150,5 +150,5 @@ describe('Robot', function() {
     expect(robot3.coordinates).toEqual([11, 5]);
     expect(robot3.bearing).toEqual('north');
   });
-  
+
 });

data/tracks/ecmascript/exercises/roman-numerals/package.json

@@ -25,9 +25,14 @@
       "env"
     ],
     "plugins": [
-      ["babel-plugin-transform-builtin-extend", {
-        "globals": ["Error"]
-      }]
+      [
+        "babel-plugin-transform-builtin-extend",
+        {
+          "globals": [
+            "Error"
+          ]
+        }
+      ]
     ]
   },
   "scripts": {

data/tracks/ecmascript/exercises/roman-numerals/roman-numerals.spec.js

@@ -1,22 +1,22 @@
 import toRoman from './roman-numerals';
 
 describe('toRoman()', () => {
-  it('converts 1', () => expect(toRoman(1)).toEqual('I'));
-  xit('converts 2', () => expect(toRoman(2)).toEqual('II'));
-  xit('converts 3', () => expect(toRoman(3)).toEqual('III'));
-  xit('converts 4', () => expect(toRoman(4)).toEqual('IV'));
-  xit('converts 5', () => expect(toRoman(5)).toEqual('V'));
-  xit('converts 6', () => expect(toRoman(6)).toEqual('VI'));
-  xit('converts 9', () => expect(toRoman(9)).toEqual('IX'));
-  xit('converts 27', () => expect(toRoman(27)).toEqual('XXVII'));
-  xit('converts 48', () => expect(toRoman(48)).toEqual('XLVIII'));
-  xit('converts 59', () => expect(toRoman(59)).toEqual('LIX'));
-  xit('converts 93', () => expect(toRoman(93)).toEqual('XCIII'));
-  xit('converts 141', () => expect(toRoman(141)).toEqual('CXLI'));
-  xit('converts 163', () => expect(toRoman(163)).toEqual('CLXIII'));
-  xit('converts 402', () => expect(toRoman(402)).toEqual('CDII'));
-  xit('converts 575', () => expect(toRoman(575)).toEqual('DLXXV'));
-  xit('converts 911', () => expect(toRoman(911)).toEqual('CMXI'));
-  xit('converts 1024', () => expect(toRoman(1024)).toEqual('MXXIV'));
-  xit('converts 3000', () => expect(toRoman(3000)).toEqual('MMM'));
+  test('converts 1', () => expect(toRoman(1)).toEqual('I'));
+  xtest('converts 2', () => expect(toRoman(2)).toEqual('II'));
+  xtest('converts 3', () => expect(toRoman(3)).toEqual('III'));
+  xtest('converts 4', () => expect(toRoman(4)).toEqual('IV'));
+  xtest('converts 5', () => expect(toRoman(5)).toEqual('V'));
+  xtest('converts 6', () => expect(toRoman(6)).toEqual('VI'));
+  xtest('converts 9', () => expect(toRoman(9)).toEqual('IX'));
+  xtest('converts 27', () => expect(toRoman(27)).toEqual('XXVII'));
+  xtest('converts 48', () => expect(toRoman(48)).toEqual('XLVIII'));
+  xtest('converts 59', () => expect(toRoman(59)).toEqual('LIX'));
+  xtest('converts 93', () => expect(toRoman(93)).toEqual('XCIII'));
+  xtest('converts 141', () => expect(toRoman(141)).toEqual('CXLI'));
+  xtest('converts 163', () => expect(toRoman(163)).toEqual('CLXIII'));
+  xtest('converts 402', () => expect(toRoman(402)).toEqual('CDII'));
+  xtest('converts 575', () => expect(toRoman(575)).toEqual('DLXXV'));
+  xtest('converts 911', () => expect(toRoman(911)).toEqual('CMXI'));
+  xtest('converts 1024', () => expect(toRoman(1024)).toEqual('MXXIV'));
+  xtest('converts 3000', () => expect(toRoman(3000)).toEqual('MMM'));
 });

data/tracks/ecmascript/exercises/saddle-points/package.json

@@ -25,9 +25,14 @@
       "env"
     ],
     "plugins": [
-      ["babel-plugin-transform-builtin-extend", {
-        "globals": ["Error"]
-      }]
+      [
+        "babel-plugin-transform-builtin-extend",
+        {
+          "globals": [
+            "Error"
+          ]
+        }
+      ]
     ]
   },
   "scripts": {

data/tracks/ecmascript/exercises/saddle-points/saddle-points.spec.js

@@ -1,42 +1,42 @@
 import Matrix from './saddle-points';
 
 describe('Matrix', () => {
-  it('extracts a row', () => {
+  test('extracts a row', () => {
     const matrix = new Matrix('1 2\n10 20');
     expect(matrix.rows[0]).toEqual([1,2]);
   });
 
-  xit('extracts other row', () => {
+  xtest('extracts other row', () => {
     const matrix = new Matrix('9 8 7\n19 18 17');
     expect(matrix.rows[1]).toEqual([19, 18, 17]);
   });
 
-  xit('extracts a column', () => {
+  xtest('extracts a column', () => {
     const matrix = new Matrix('1 2 3\n4 5 6\n7 8 9\n 8 7 6');
     expect(matrix.columns[0]).toEqual([1, 4, 7, 8]);
   });
 
-  xit('extracts another column', () => {
+  xtest('extracts another column', () => {
     const matrix = new Matrix('89 1903 3\n18 3 1\n9 4 800');
     expect(matrix.columns[1]).toEqual([1903, 3, 4]);
   });
 
-  xit('no saddle point', () => {
+  xtest('no saddle point', () => {
     const matrix = new Matrix('2 1\n1 2');
     expect(matrix.saddlePoints).toEqual([]);
   });
 
-  xit('a saddle point', () => {
+  xtest('a saddle point', () => {
     const matrix = new Matrix('1 2\n3 4');
     expect(matrix.saddlePoints).toEqual([[0,1]]);
   });
 
-  xit('another saddle point', () => {
+  xtest('another saddle point', () => {
     const matrix = new Matrix('18 3 39 19 91\n38 10 8 77 320\n3 4 8 6 7');
     expect(matrix.saddlePoints).toEqual([[2,2]]);
   });
 
-  xit('multiple saddle points', () => {
+  xtest('multiple saddle points', () => {
     const matrix = new Matrix('4 5 4\n3 5 5\n1 5 4');
     expect(matrix.saddlePoints).toEqual([[0, 1], [1, 1], [2, 1]]);
   });

data/tracks/ecmascript/exercises/say/package.json

@@ -25,9 +25,14 @@
       "env"
     ],
     "plugins": [
-      ["babel-plugin-transform-builtin-extend", {
-        "globals": ["Error"]
-      }]
+      [
+        "babel-plugin-transform-builtin-extend",
+        {
+          "globals": [
+            "Error"
+          ]
+        }
+      ]
     ]
   },
   "scripts": {

data/tracks/ecmascript/exercises/say/say.spec.js

@@ -2,60 +2,60 @@ import Say from './say';
 
 describe('say', () => {
   const say = new Say();
-  it('zero', () => {
+  test('zero', () => {
     expect(say.inEnglish(0)).toBe('zero');
   });
 
-  xit('one', () => {
+  xtest('one', () => {
     expect(say.inEnglish(1)).toBe('one');
   });
 
-  xit('fourteen', () => {
+  xtest('fourteen', () => {
     expect(say.inEnglish(14)).toBe('fourteen');
   });
 
-  xit('twenty', () => {
+  xtest('twenty', () => {
     expect(say.inEnglish(20)).toBe('twenty');
   });
 
-  xit('twenty-two', () => {
+  xtest('twenty-two', () => {
     expect(say.inEnglish(22)).toBe('twenty-two');
   });
 
-  xit('one hundred', () => {
+  xtest('one hundred', () => {
     expect(say.inEnglish(100)).toBe('one hundred');
   });
 
-  xit('one hundred twenty-three', () => {
+  xtest('one hundred twenty-three', () => {
     expect(say.inEnglish(123)).toBe('one hundred twenty-three');
   });
 
-  xit('one thousand', () => {
+  xtest('one thousand', () => {
     expect(say.inEnglish(1000)).toBe('one thousand');
   });
 
-  xit('one thousand two hundred thirty-four', () => {
+  xtest('one thousand two hundred thirty-four', () => {
     expect(say.inEnglish(1234)).toBe('one thousand two hundred thirty-four');
   });
 
-  xit('one million', () => {
+  xtest('one million', () => {
     expect(say.inEnglish(1000000)).toBe('one million');
   });
 
-  xit('one million two', () => {
+  xtest('one million two', () => {
     expect(say.inEnglish(1000002)).toBe('one million two');
   });
 
-  xit('one million two thousand three hundred forty-five', () => {
+  xtest('one million two thousand three hundred forty-five', () => {
     expect(say.inEnglish(1002345))
       .toBe('one million two thousand three hundred forty-five');
   });
 
-  xit('one billion', () => {
+  xtest('one billion', () => {
     expect(say.inEnglish(1000000000)).toBe('one billion');
   });
 
-  xit('a really big number', () => {
+  xtest('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);
   });
 
-  xit('raises an error below zero', () => {
+  xtest('raises an error below zero', () => {
     expect(() => {
       say.inEnglish(-1)
     }).toThrow(new Error('Number must be between 0 and 999,999,999,999.'));
   });
 
-  xit('raises an error above 999,999,999,999', () => {
+  xtest('raises an error above 999,999,999,999', () => {
     expect(() => {
       say.inEnglish(1000000000000)
     }).toThrow(new Error('Number must be between 0 and 999,999,999,999.'));