trackler 2.1.0.53 → 2.1.0.54

data/tracks/ecmascript/exercises/bob/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/bracket-push/bracket-push.spec.js

@@ -1,35 +1,35 @@
 import bracket from './bracket-push';
 
 describe('bracket push', () => {
-  it('checks for appropriate bracketing in a set of brackets', () => {
+  test('checks for appropriate bracketing in a set of brackets', () => {
     expect(bracket('{}')).toEqual(true);
   });
 
-  xit('returns false for unclosed brackets', () => {
+  xtest('returns false for unclosed brackets', () => {
     expect(bracket('{{')).toEqual(false);
   });
 
-  xit('returns false if brackets are out of order', () => {
+  xtest('returns false if brackets are out of order', () => {
     expect(bracket('}{')).toEqual(false);
   });
 
-  xit('checks bracketing in more than one pair of brackets', () => {
+  xtest('checks bracketing in more than one pair of brackets', () => {
     expect(bracket('{}[]')).toEqual(true);
   });
 
-  xit('checks bracketing in nested brackets', () => {
+  xtest('checks bracketing in nested brackets', () => {
     expect(bracket('{[]}')).toEqual(true);
   });
 
-  xit('rejects brackets that are properly balanced but improperly nested', () => {
+  xtest('rejects brackets that are properly balanced but improperly nested', () => {
     expect(bracket('{[}]')).toEqual(false);
   });
 
-  xit('checks bracket closure with deeper nesting', () => {
+  xtest('checks bracket closure with deeper nesting', () => {
     expect(bracket('{[)][]}')).toEqual(false);
   });
 
-  xit('checks bracket closure in a long string of brackets', () => {
+  xtest('checks bracket closure in a long string of brackets', () => {
     expect(bracket('{[]([()])}')).toEqual(true);
   });
 });

data/tracks/ecmascript/exercises/bracket-push/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/circular-buffer/circular-buffer.spec.js

@@ -3,19 +3,19 @@ import { BufferFullError, BufferEmptyError } from './circular-buffer';
 
 describe('CircularBuffer', () => {
 
-  it('reading an empty buffer throws a BufferEmptyError', () => {
+  test('reading an empty buffer throws a BufferEmptyError', () => {
     const buffer = circularBuffer(1);
     expect(()=>buffer.read()).toThrow(BufferEmptyError);
   });
 
-  xit('write and read back one item', () => {
+  xtest('write and read back one item', () => {
     const buffer = circularBuffer(1);
     buffer.write('1');
     expect(buffer.read()).toBe('1');
     expect(()=>buffer.read()).toThrow(BufferEmptyError);
   });
 
-  xit('write and read back multiple items', () => {
+  xtest('write and read back multiple items', () => {
     const buffer = circularBuffer(2);
     buffer.write('1');
     buffer.write('2');
@@ -24,7 +24,7 @@ describe('CircularBuffer', () => {
     expect(()=>buffer.read()).toThrow(BufferEmptyError);
   });
 
-  xit('clearing a buffer', () => {
+  xtest('clearing a buffer', () => {
     const buffer = circularBuffer(2);
     buffer.write('1');
     buffer.write('2');
@@ -36,7 +36,7 @@ describe('CircularBuffer', () => {
     expect(buffer.read()).toBe('4');
   });
 
-  xit('alternate write and read', () => {
+  xtest('alternate write and read', () => {
     const buffer = circularBuffer(2);
     buffer.write('1');
     expect(buffer.read()).toBe('1');
@@ -44,7 +44,7 @@ describe('CircularBuffer', () => {
     expect(buffer.read()).toBe('2');
   });
 
-  xit('reads back oldest item', () => {
+  xtest('reads back oldest item', () => {
     const buffer = circularBuffer(3);
     buffer.write('1');
     buffer.write('2');
@@ -54,7 +54,7 @@ describe('CircularBuffer', () => {
     expect(buffer.read()).toBe('3');
   });
 
-  xit('writes of undefined or null don\'t occupy buffer', () => {
+  xtest('writes of undefined or null don\'t occupy buffer', () => {
     const buffer = circularBuffer(3);
     buffer.write(null);
     buffer.write(undefined);
@@ -62,14 +62,14 @@ describe('CircularBuffer', () => {
     expect(buffer.read()).toBe('1');
   });
 
-  xit('writing to a full buffer throws a BufferFullError', () => {
+  xtest('writing to a full buffer throws a BufferFullError', () => {
     const buffer = circularBuffer(2);
     buffer.write('1');
     buffer.write('2');
     expect(() => buffer.write('A')).toThrow(BufferFullError);
   });
 
-  xit('forced writes over write oldest item in a full buffer', () => {
+  xtest('forced writes over write oldest item in a full buffer', () => {
     const buffer = circularBuffer(2);
     buffer.write('1');
     buffer.write('2');
@@ -79,7 +79,7 @@ describe('CircularBuffer', () => {
     expect(()=>buffer.read()).toThrow(BufferEmptyError);
   });
 
-  xit('forced writes act like write in a non-full buffer', () => {
+  xtest('forced writes act like write in a non-full buffer', () => {
     const buffer = circularBuffer(2);
     buffer.write('1');
     buffer.forceWrite('2');
@@ -88,7 +88,7 @@ describe('CircularBuffer', () => {
     expect(()=>buffer.read()).toThrow(BufferEmptyError);
   });
 
-  xit('alternate force write and read into full buffer', () => {
+  xtest('alternate force write and read into full buffer', () => {
     const buffer = circularBuffer(5);
     [1,2,3].map(i => buffer.write(i.toString()));
     buffer.read();

data/tracks/ecmascript/exercises/circular-buffer/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/clock/clock.spec.js

@@ -4,145 +4,145 @@ describe('Clock', () => {
 
   describe('Creating a new clock with an initial time', () => {
 
-    it('on the hour', () => {
+    test('on the hour', () => {
       expect(at(8).toString()).toEqual('08:00');
     });
 
-    xit('past the hour', () => {
+    xtest('past the hour', () => {
       expect(at(11, 9).toString()).toEqual('11:09');
     });
 
-    xit('midnight is zero hours', () => {
+    xtest('midnight is zero hours', () => {
       expect(at(24, 0).toString()).toEqual('00:00');
     });
 
-    xit('hour rolls over', () => {
+    xtest('hour rolls over', () => {
       expect(at(25, 0).toString()).toEqual('01:00');
     });
 
-    xit('hour rolls over continuously', () => {
+    xtest('hour rolls over continuously', () => {
       expect(at(100, 0).toString()).toEqual('04:00');
     });
 
-    xit('sixty minutes is next hour', () => {
+    xtest('sixty minutes is next hour', () => {
       expect(at(1, 60).toString()).toEqual('02:00');
     });
 
-    xit('minutes roll over', () => {
+    xtest('minutes roll over', () => {
       expect(at(0, 160).toString()).toEqual('02:40');
     });
 
-    xit('minutes roll over continuously', () => {
+    xtest('minutes roll over continuously', () => {
       expect(at(0, 1723).toString()).toEqual('04:43');
     });
 
-    xit('hour and minutes roll over', () => {
+    xtest('hour and minutes roll over', () => {
       expect(at(25, 160).toString()).toEqual('03:40');
     });
 
-    xit('hour and minutes roll over continuously', () => {
+    xtest('hour and minutes roll over continuously', () => {
       expect(at(201, 3001).toString()).toEqual('11:01');
     });
 
-    xit('hour and minutes roll over to exactly midnight', () => {
+    xtest('hour and minutes roll over to exactly midnight', () => {
       expect(at(72, 8640).toString()).toEqual('00:00');
     });
 
-    xit('negative hour', () => {
+    xtest('negative hour', () => {
       expect(at(-1, 15).toString()).toEqual('23:15');
     });
 
-    xit('negative hour rolls over', () => {
+    xtest('negative hour rolls over', () => {
       expect(at(-25, 0).toString()).toEqual('23:00');
     });
 
-    xit('negative hour rolls over continuously', () => {
+    xtest('negative hour rolls over continuously', () => {
       expect(at(-91, 0).toString()).toEqual('05:00');
     });
 
-    xit('negative minutes', () => {
+    xtest('negative minutes', () => {
       expect(at(1, -40).toString()).toEqual('00:20');
     });
 
-    xit('negative minutes rolls over', () => {
+    xtest('negative minutes rolls over', () => {
       expect(at(1, -160).toString()).toEqual('22:20');
     });
 
-    xit('negative minutes rolls over continuously', () => {
+    xtest('negative minutes rolls over continuously', () => {
       expect(at(1, -4820).toString()).toEqual('16:40');
     });
 
-    xit('negative hour and minutes both roll over', () => {
+    xtest('negative hour and minutes both roll over', () => {
       expect(at(-25, -160).toString()).toEqual('20:20');
     });
 
-    xit('negative hour and minutes both roll over continuously', () => {
+    xtest('negative hour and minutes both roll over continuously', () => {
       expect(at(-121, -5810).toString()).toEqual('22:10');
     });
 
     describe('Adding and subtracting minutes', () => {
 
-      xit('add minutes', () => {
+      xtest('add minutes', () => {
         expect(at(10, 0).plus(3).toString()).toEqual('10:03');
       });
 
-      xit('add no minutes', () => {
+      xtest('add no minutes', () => {
         expect(at(6, 41).plus(0).toString()).toEqual('06:41');
       });
 
-      xit('add to next hour', () => {
+      xtest('add to next hour', () => {
         expect(at(0, 45).plus(40).toString()).toEqual('01:25');
       });
 
-      xit('add more than one hour', () => {
+      xtest('add more than one hour', () => {
         expect(at(10, 0).plus(61).toString()).toEqual('11:01');
       });
 
-      xit('add more than two hours with carry', () => {
+      xtest('add more than two hours with carry', () => {
         expect(at(0, 45).plus(160).toString()).toEqual('03:25');
       });
 
-      xit('add across midnight', () => {
+      xtest('add across midnight', () => {
         expect(at(23, 59).plus(2).toString()).toEqual('00:01');
       });
 
-      xit('add more than one day (1500 min = 25 hrs)', () => {
+      xtest('add more than one day (1500 min = 25 hrs)', () => {
         expect(at(5, 32).plus(1500).toString()).toEqual('06:32');
       });
 
-      xit('add more than two days', () => {
+      xtest('add more than two days', () => {
         expect(at(1, 1).plus(3500).toString()).toEqual('11:21');
       });
 
-      xit('subtract minutes', () => {
+      xtest('subtract minutes', () => {
         expect(at(10, 3).minus(3).toString()).toEqual('10:00');
       });
 
-      xit('subtract to previous hour', () => {
+      xtest('subtract to previous hour', () => {
         expect(at(10, 3).minus(30).toString()).toEqual('09:33');
       });
 
-      xit('subtract more than an hour', () => {
+      xtest('subtract more than an hour', () => {
         expect(at(10, 3).minus(70).toString()).toEqual('08:53');
       });
 
-      xit('subtract across midnight', () => {
+      xtest('subtract across midnight', () => {
         expect(at(0, 3).minus(4).toString()).toEqual('23:59');
       });
 
-      xit('subtract more than two hours', () => {
+      xtest('subtract more than two hours', () => {
         expect(at(0, 0).minus(160).toString()).toEqual('21:20');
       });
 
-      xit('subtract more than two hours with borrow', () => {
+      xtest('subtract more than two hours with borrow', () => {
         expect(at(6, 15).minus(160).toString()).toEqual('03:35');
       });
 
-      xit('subtract more than one day (1500 min = 25 hrs)', () => {
+      xtest('subtract more than one day (1500 min = 25 hrs)', () => {
         expect(at(5, 32).minus(1500).toString()).toEqual('04:32');
       });
 
-      xit('subtract more than two days', () => {
+      xtest('subtract more than two days', () => {
         expect(at(2, 20).minus(3000).toString()).toEqual('00:20');
       });
 
@@ -150,63 +150,63 @@ describe('Clock', () => {
 
     describe('Construct two separate clocks, set times, test if they are equal', () => {
 
-      xit('clocks with same time', () => {
+      xtest('clocks with same time', () => {
         expect(at(15, 37).equals(at(15, 37))).toBeTruthy();
       });
 
-      xit('clocks a minute apart', () => {
+      xtest('clocks a minute apart', () => {
         expect(at(15, 36).equals(at(15, 37))).toBeFalsy();
       });
 
-      xit('clocks an hour apart', () => {
+      xtest('clocks an hour apart', () => {
         expect(at(14, 37).equals(at(15, 37))).toBeFalsy();
       });
 
-      xit('clocks with hour overflow', () => {
+      xtest('clocks with hour overflow', () => {
         expect(at(10, 37).equals(at(34, 37))).toBeTruthy();
       });
 
-      xit('clocks with hour overflow by several days', () => {
+      xtest('clocks with hour overflow by several days', () => {
         expect(at(3, 11).equals(at(99, 11))).toBeTruthy();
       });
 
-      xit('clocks with negative hour', () => {
+      xtest('clocks with negative hour', () => {
         expect(at(22, 40).equals(at(-2, 40))).toBeTruthy();
       });
 
-      xit('clocks with negative hour that wraps', () => {
+      xtest('clocks with negative hour that wraps', () => {
         expect(at(17, 3).equals(at(-31, 3))).toBeTruthy();
       });
 
-      xit('clocks with negative hour that wraps multiple times', () => {
+      xtest('clocks with negative hour that wraps multiple times', () => {
         expect(at(13, 49).equals(at(-83, 49))).toBeTruthy();
       });
 
-      xit('clocks with minute overflow', () => {
+      xtest('clocks with minute overflow', () => {
         expect(at(0, 1).equals(at(0, 1441))).toBeTruthy();
       });
 
-      xit('clocks with minute overflow by several days', () => {
+      xtest('clocks with minute overflow by several days', () => {
         expect(at(2, 2).equals(at(2, 4322))).toBeTruthy();
       });
 
-      xit('clocks with negative minute', () => {
+      xtest('clocks with negative minute', () => {
         expect(at(2, 40).equals(at(3, -20))).toBeTruthy();
       });
 
-      xit('clocks with negative minute that wraps', () => {
+      xtest('clocks with negative minute that wraps', () => {
         expect(at(4, 10).equals(at(5, -1490))).toBeTruthy();
       });
 
-      xit('clocks with negative minute that wraps multiple times', () => {
+      xtest('clocks with negative minute that wraps multiple times', () => {
         expect(at(6, 15).equals(at(6, -4305))).toBeTruthy();
       });
 
-      xit('clocks with negative hours and minutes', () => {
+      xtest('clocks with negative hours and minutes', () => {
         expect(at(7, 32).equals(at(-12, -268))).toBeTruthy();
       });
 
-      xit('clocks with negative hours and minutes that wrap', () => {
+      xtest('clocks with negative hours and minutes that wrap', () => {
         expect(at(18, 7).equals(at(-54, -11513))).toBeTruthy();
       });