trackler 2.1.0.0 → 2.1.0.1

data/tracks/java/exercises/settings.gradle

@@ -51,6 +51,7 @@ include 'rna-transcription'
 include 'robot-name'
 include 'robot-simulator'
 include 'roman-numerals'
+include 'saddle-points'
 include 'scrabble-score'
 include 'secret-handshake'
 include 'series'

data/tracks/javascript/.travis.yml

@@ -5,8 +5,10 @@ sudo: false
 node_js:
   - 5.7
 
+install:
+  - "npm install -g jasmine"
+
 script:
   - "make test"
   - "./bin/fetch-configlet"
   - "./bin/configlet ."
-

data/tracks/javascript/Makefile

@@ -12,20 +12,14 @@ FILEEXT := "js"
 EXAMPLE := "example.$(FILEEXT)"
 TSTFILE := "$(subst _,-,$(ASSIGNMENT)).spec.$(FILEEXT)"
 
-# development dependencies
-node_modules: package.json
-	@npm prune
-	@npm install
-
-test-assignment: node_modules
+test-assignment:
 	@echo "running tests for: $(ASSIGNMENT)"
 	@cp big-integer.$(FILEEXT) $(OUTDIR)
 	@cp exercises/$(ASSIGNMENT)/$(TSTFILE) $(OUTDIR)
 	@cp exercises/$(ASSIGNMENT)/$(EXAMPLE) $(OUTDIR)/$(subst _,-,$(ASSIGNMENT)).$(FILEEXT)
 	#@sed -i.original 's/\bxit\b/it/g' $(OUTDIR)/*spec.$(FILEEXT)
 	@sed 's/xit/it/g' exercises/$(ASSIGNMENT)/$(TSTFILE) > $(OUTDIR)/$(TSTFILE)
-	@./node_modules/.bin/jasmine-node --captureExceptions $(OUTDIR)/$(TSTFILE)
+	@jasmine --random=true $(OUTDIR)/$(TSTFILE)
 
 test:
 	@for assignment in $(ASSIGNMENTS); do ASSIGNMENT=$$assignment $(MAKE) -s test-assignment || exit 1; done
-

data/tracks/javascript/SETUP.md

@@ -9,10 +9,9 @@ http://exercism.io/languages/javascript
 
 Execute the tests with:
 
-    jasmine-node .
+    jasmine .
 
 In many test suites all but the first test have been skipped.
 
 Once you get a test passing, you can unskip the next one by
 changing `xit` to `it`.
-

data/tracks/javascript/docs/INSTALLATION.md

@@ -15,15 +15,14 @@ If you are using a different distribution or package manager, you can find a com
 
 ## Installing additional tools
 
-The next step is to install `jasmine-node` globally so that you can run JavaScript tests:
+The next step is to install [Jasmine](https://jasmine.github.io/) globally so that you can run JavaScript tests:
 
-    npm install jasmine-node -g
+    npm install -g jasmine
 
 Depending on your setup, you may need super user privileges to install an `npm` module globally. This is the case if you've used the official installer linked to above. If `npm` gives you an error saying you don't have access, add `sudo` to the command above:
 
-    sudo npm install jasmine-node -g
+    sudo npm install -g jasmine
 
 If you've used the official installer, your `PATH` should have been automatically configured, but if your shell has trouble locating your globally installed modules—or if you build Node.js from source—update your `PATH` to include the `npm` binaries by adding the following to either `~/.bash_profile` or `~/.zshrc`:
 
     export PATH=/usr/local/share/npm/bin:$PATH
-

data/tracks/javascript/docs/TESTS.md

@@ -1,37 +1,23 @@
-After configuring `exercism` command-line client you can fetch the very next exercise
+With the first few exercises, you will get a skeleton file with the exported modules.
+For later ones, you can find more information about modules in the [node documentation](http://nodejs.org/api/modules.html#modules_module_exports).
 
-    exercism fetch javascript
-
-or you can fetch a specific exercise, passing the exercise name after the language. For example, to fetch the `bob` exercise:
-
-    exercism fetch javascript bob
-
-Now, it's time to run some tests. Move to the folder where that exercise's files are located (a path similar to `<EXERCISM_HOME_DIR>/<TRACK_ID>/<EXERCISE>`) and run the tests with the `jasmine-node` command you should have installed on the *Installing JavaScript* step:
+For running tests, install `jasmine` as described in the [Installing Javascript section](http://exercism.io/languages/javascript/installing).
+Move to the folder where that exercise's files are located (a path similar to <EXERCISM_HOME_DIR>/javascript/<EXERCISE>).
 
     cd ~/exercism/javascript/bob
-    jasmine-node bob_test.spec.js
-
-*Note that `~/exercism` is the default folder for `EXERCISM_HOME_DIR`. Be sure you use your configured folder for it*
-
-## Making Your First Node Module
+    jasmine bob_test.spec.js
 
-To create a module that can be loaded with `var Bob = require('./bob.js');`, put this code in `bob.js`:
+Only the first test will be executed, all the others have been marked pending using `xit` or `xdescribe`.
+As you keep solving the exercise, one by one change all `xit` and `xdescribe` to `it` and `describe` respectively to run all the tests.
+See [Test Driven Development (TDD)](https://en.wikipedia.org/wiki/Test-driven_development) to know more about this approach.
+When all tests pass, you are ready to submit!
 
-    var Bob = function() {};
-
-    Bob.prototype.hey = function(what) {
-      //
-      // Your solution to the exercise goes here
-      //
-    };
-
-    module.exports = Bob;
-
-You can find more information about modules in the [node documentation](http://nodejs.org/api/modules.html#modules_module_exports). To make it easier to get started, there's a "skeleton" bob.js file in the directory
-for the first exercise.
 
 ## Visual Studio on Windows
 
+You can use any editor of your choice to write javascript. Here are just some instructions for using and running tests in `Visual Studio`.
+You are free to skip this section if you are not using `Visual Studio` on `Windows`.
+
 Install [Visual Studio Express 2013 for web](http://www.visualstudio.com/en-us/products/visual-studio-express-vs.aspx). This will include the IDE and web development tools.
 
 To get started, you can download a Visual Studio solution that is already set up to work with JavaScript and the other languages that Visual Studio supports.
@@ -67,6 +53,8 @@ If you do not see any output from running the tests, you are likely not in a Nod
 
 ## Setting Up a Linter
 
+** Note: This section is completely optional **
+
 A linter is like a tester for your code's style and formatting. In some languages there are many acceptable styles, and using a linter allows you to be internally consistent (e.g. Ruby), or adhere to one of many common styles. In other languages there are fewer choices, and a linter allows programmers to look at code from a great variety of sources and still feel at home (e.g. Go). You can read more [here](https://en.wikipedia.org/wiki/Lint_(software)).
 
 The old standard linter for JavaScript is [JSLint](http://jslint.com). However, it is controversially picky. [JSHint](http://jshint.com) is another popular linter. We suggest using [ESLint](http://eslint.org), which is more customizable than either JSLint or JSHint, and is well-run.

data/tracks/javascript/exercises/hamming/example.js

@@ -1,23 +1,19 @@
 function Hamming() {}
 
 Hamming.prototype.compute = function (strand1, strand2) {
-  var len1 = strand1.length;
-  var len2 = strand2.length;
-
-  if (len1 !== len2) {
+  if (strand1.length !== strand2.length) {
     throw new Error('DNA strands must be of equal length.');
   }
 
-  var out = -0;
-  var idx = -1;
-  var end = Math.max(len1, len2);
+  var distance = 0;
 
-  while (++idx < end) {
-    if (strand1[idx] !== strand2[idx]) out++;
+  for (var i = 0; i < strand1.length; i++) {
+    if (strand1[i] !== strand2[i]) {
+      distance++;
+    }
   }
 
-  return out;
+  return distance;
 };
 
 module.exports = Hamming;
-

data/tracks/javascript/exercises/hello-world/HINTS.md

@@ -24,7 +24,7 @@ This is the first test:
 
 Run the test now, with the following command on the command-line:
 
-    jasmine-node .
+    jasmine .
 
 The test fails, which makes sense since you've not written any code yet.
 
@@ -76,7 +76,7 @@ Try changing the function in hello-world.js so that it says
 
 Then run the tests again from the command-line:
 
-    jasmine-node .
+    jasmine .
 
 Notice how it changes the failure message.
 
@@ -89,7 +89,7 @@ Once the test is passing, look at the second test in hello-world.spec.js. It loo
     });
 
 This test starts with `xit` instead of `it`.
-That means that when jasmine-node runs the tests,
+That means that when Jasmine runs the tests,
 the test will be skipped.
 
 Change the test so that it starts with `it`,

data/tracks/javascript/exercises/robot-simulator/example.js

@@ -1,88 +1,87 @@
-'use strict';
+var Robot = (function () {
+  'use strict';
 
-var Robot = function () {
-  this.coordinates = [0, 0];
-  this.bearing = 'north';
-};
-
-Robot.prototype.at = function (xcoord, ycoord) {
-  this.coordinates = [xcoord, ycoord];
-};
-
-Robot.prototype.orient = function (direction) {
-  if (direction != 'north' &&
-      direction != 'south' &&
-      direction != 'east' &&
-      direction != 'west') {
-    throw 'Invalid Robot Bearing'
+  var VALID_DIRECTIONS = ['north', 'east', 'south', 'west']
+  var INSTRUCTION_KEYS = {
+    A: 'advance',
+    L: 'turnLeft',
+    R: 'turnRight'
   }
 
-  this.bearing = direction;
-  return 'The robot is pointed ' + direction;
-};
+  function Robot () {
+    this.coordinates = [0, 0];
+    this.bearing = 'north';
+  };
 
-Robot.prototype.advance = function () {
+  Robot.prototype.at = function (x, y) {
+    this.coordinates = [x, y];
+  };
 
-  if (this.bearing === 'north') {
-    this.coordinates[1] += 1;
-  } else if (this.bearing === 'south') {
-    this.coordinates[1] -= 1;
-  } else if (this.bearing === 'east') {
-    this.coordinates[0] += 1;
-  } else if (this.bearing === 'west') {
-    this.coordinates[0] -= 1;
-  }
-};
+  Robot.prototype.orient = function (direction) {
+    if (VALID_DIRECTIONS.indexOf(direction) === -1) {
+      throw new Error('Invalid Robot Bearing');
+    }
 
-Robot.prototype.turnLeft = function () {
+    this.bearing = direction;
+  };
 
-  if (this.bearing === 'north') {
-    this.orient('west');
-  } else if (this.bearing === 'south') {
-    this.orient('east');
-  } else if (this.bearing === 'east') {
-    this.orient('north');
-  } else if (this.bearing === 'west') {
-    this.orient('south');
-  }
-};
+  Robot.prototype.advance = function () {
+    switch (this.bearing) {
+      case 'north':
+        this.coordinates[1]++;
+        break;
+      case 'east':
+        this.coordinates[0]++;
+        break;
+      case 'south':
+        this.coordinates[1]--;
+        break;
+      case 'west':
+        this.coordinates[0]--;
+        break;
+    };
+  };
 
-Robot.prototype.turnRight = function () {
+  Robot.prototype.turnLeft = function () {
+    var directionPosition = VALID_DIRECTIONS.indexOf(this.bearing);
 
-  if (this.bearing === 'north') {
-    this.orient('east');
-  } else if (this.bearing === 'south') {
-    this.orient('west');
-  } else if (this.bearing === 'east') {
-    this.orient('south');
-  } else if (this.bearing === 'west') {
-    this.orient('north');
-  }
-};
+    if (directionPosition > 0) {
+      this.orient(VALID_DIRECTIONS[--directionPosition]);
+    } else {
+      this.orient(VALID_DIRECTIONS[VALID_DIRECTIONS.length - 1]);
+    }
+  };
+
+  Robot.prototype.turnRight = function () {
+    var directionPosition = VALID_DIRECTIONS.indexOf(this.bearing);
 
-Robot.prototype.instructions = function (s) {
-  var result = [];
-  s.split('').forEach(function (character) {
-    if (character === 'L') {
-      result.push('turnLeft');
-    } else if (character === 'R') {
-      result.push('turnRight');
-    } else if (character === 'A') {
-      result.push('advance');
+    if (directionPosition < (VALID_DIRECTIONS.length - 1)) {
+      this.orient(VALID_DIRECTIONS[++directionPosition]);
+    } else {
+      this.orient(VALID_DIRECTIONS[0]);
     }
-  });
-  return result;
-};
+  };
+
+  Robot.prototype.instructions = function (instructionKeys) {
+    return instructionKeys.split('')
+      .map(function (key) {
+        return INSTRUCTION_KEYS[key];
+      });
+  };
+
+  Robot.prototype.place = function (args) {
+    this.coordinates = [args.x, args.y];
+    this.bearing = args.direction;
+  };
 
-Robot.prototype.place = function (args) {
-  this.coordinates = [args.x, args.y];
-  this.bearing = args.direction;
-};
+  Robot.prototype.evaluate = function (instructionKeys) {
+    this.instructions(instructionKeys)
+      .forEach(function (instruction) {
+        this[instruction]();
+      }, this);
+  };
 
-Robot.prototype.evaluate = function (s) {
-  this.instructions(s).forEach(function (instruction) {
-    this[instruction]();
-  }, this);
-};
+  return Robot
+})()
 
 module.exports = Robot;

data/tracks/perl6/config.json

@@ -49,6 +49,11 @@
       "slug": "raindrops",
       "topics": []
     },
+    {
+      "difficulty": 1,
+      "slug": "clock",
+      "topics": []
+    },
     {
       "difficulty": 1,
       "slug": "scrabble-score",

data/tracks/perl6/exercises/clock/Clock.pm6

@@ -0,0 +1,4 @@
+unit class Clock:ver<1>;
+
+has $.hour;
+has $.minute;

data/tracks/perl6/exercises/clock/Example.pm6

@@ -0,0 +1,12 @@
+unit class Clock:ver<1>;
+
+has Int:D $.hour = 0;
+has Int:D $.minute = 0;
+
+method time is export {
+  sprintf '%02d:%02d', ($!hour + $!minute div 60) % 24, $!minute % 60;
+}
+
+method add-minutes (Int:D $min) is export {
+  $!minute += $min and return self;
+}

data/tracks/perl6/exercises/clock/clock.t

@@ -0,0 +1,534 @@
+#!/usr/bin/env perl6
+use v6;
+use Test;
+use lib my $dir = $?FILE.IO.dirname;
+use JSON::Tiny;
+
+my $exercise = 'Clock';
+my $version = v1;
+my $module = %*ENV<EXERCISM> ?? 'Example' !! $exercise;
+plan 54;
+
+use-ok $module or bail-out;
+require ::($module);
+
+if ::($exercise).^ver !~~ $version {
+  warn "\nExercise version mismatch. Further tests may fail!"
+    ~ "\n$exercise is $(::($exercise).^ver.gist). "
+    ~ "Test is $($version.gist).\n";
+  bail-out 'Example version must match test version.' if %*ENV<EXERCISM>;
+}
+
+subtest 'Class methods', {
+  ok ::($exercise).can($_), $_ for <time add-minutes>;
+}
+
+my $c-data;
+is ::($exercise).new(hour => .<hour>, minute => .<minute>).?time, |.<expected description> for @($c-data<cases>[0]<cases>);
+for @($c-data<cases>[1]<cases>) {
+  my $clock = ::($exercise).new(hour => .<hour>, minute => .<minute>);
+  $clock.?add-minutes(.<add>);
+  is $clock.?time, |.<expected description>;
+}
+is ::($exercise).new(hour => .<clock1><hour>, minute => .<clock1><minute>).?time eq
+   ::($exercise).new(hour => .<clock2><hour>, minute => .<clock2><minute>).?time,
+   |.<expected description> for @($c-data<cases>[2]<cases>);
+todo 'optional test' unless %*ENV<EXERCISM>;
+is ::($exercise).new(:0hour,:0minute).?add-minutes(65).?time, '01:05', 'add-minutes method can be chained';
+
+if %*ENV<EXERCISM> && (my $c-data-file =
+  "$dir/../../x-common/exercises/{$dir.IO.resolve.basename}/canonical-data.json".IO.resolve) ~~ :f
+{ is-deeply $c-data, from-json($c-data-file.slurp), 'canonical-data' } else { skip }
+
+done-testing;
+
+INIT {
+$c-data := from-json q:to/END/;
+
+{
+  "exercise": "clock",
+  "version": "1.0.0",
+  "comments": [
+    "Most languages require constructing a clock with initial values,",
+    "adding a positive or negative number of minutes, and testing equality",
+    "in some language-native way.  Some languages require separate add and",
+    "subtract functions.  Negative and out of range values are generally",
+    "expected to wrap around rather than represent errors."
+  ],
+  "cases": [
+    {
+      "description": "Test creating a new clock with an initial time.",
+      "cases": [
+        {
+          "description": "on the hour",
+          "property": "create",
+          "hour": 8,
+          "minute": 0,
+          "expected": "08:00"
+        },
+        {
+          "description": "past the hour",
+          "property": "create",
+          "hour": 11,
+          "minute": 9,
+          "expected": "11:09"
+        },
+        {
+          "description": "midnight is zero hours",
+          "property": "create",
+          "hour": 24,
+          "minute": 0,
+          "expected": "00:00"
+        },
+        {
+          "description": "hour rolls over",
+          "property": "create",
+          "hour": 25,
+          "minute": 0,
+          "expected": "01:00"
+        },
+        {
+          "description": "hour rolls over continuously",
+          "property": "create",
+          "hour": 100,
+          "minute": 0,
+          "expected": "04:00"
+        },
+        {
+          "description": "sixty minutes is next hour",
+          "property": "create",
+          "hour": 1,
+          "minute": 60,
+          "expected": "02:00"
+        },
+        {
+          "description": "minutes roll over",
+          "property": "create",
+          "hour": 0,
+          "minute": 160,
+          "expected": "02:40"
+        },
+        {
+          "description": "minutes roll over continuously",
+          "property": "create",
+          "hour": 0,
+          "minute": 1723,
+          "expected": "04:43"
+        },
+        {
+          "description": "hour and minutes roll over",
+          "property": "create",
+          "hour": 25,
+          "minute": 160,
+          "expected": "03:40"
+        },
+        {
+          "description": "hour and minutes roll over continuously",
+          "property": "create",
+          "hour": 201,
+          "minute": 3001,
+          "expected": "11:01"
+        },
+        {
+          "description": "hour and minutes roll over to exactly midnight",
+          "property": "create",
+          "hour": 72,
+          "minute": 8640,
+          "expected": "00:00"
+        },
+        {
+          "description": "negative hour",
+          "property": "create",
+          "hour": -1,
+          "minute": 15,
+          "expected": "23:15"
+        },
+        {
+          "description": "negative hour rolls over",
+          "property": "create",
+          "hour": -25,
+          "minute": 0,
+          "expected": "23:00"
+        },
+        {
+          "description": "negative hour rolls over continuously",
+          "property": "create",
+          "hour": -91,
+          "minute": 0,
+          "expected": "05:00"
+        },
+        {
+          "description": "negative minutes",
+          "property": "create",
+          "hour": 1,
+          "minute": -40,
+          "expected": "00:20"
+        },
+        {
+          "description": "negative minutes roll over",
+          "property": "create",
+          "hour": 1,
+          "minute": -160,
+          "expected": "22:20"
+        },
+        {
+          "description": "negative minutes roll over continuously",
+          "property": "create",
+          "hour": 1,
+          "minute": -4820,
+          "expected": "16:40"
+        },
+        {
+          "description": "negative hour and minutes both roll over",
+          "property": "create",
+          "hour": -25,
+          "minute": -160,
+          "expected": "20:20"
+        },
+        {
+          "description": "negative hour and minutes both roll over continuously",
+          "property": "create",
+          "hour": -121,
+          "minute": -5810,
+          "expected": "22:10"
+        }
+      ]
+    },
+    {
+      "description": "Test adding and subtracting minutes.",
+      "cases": [
+        {
+          "description": "add minutes",
+          "property": "add",
+          "hour": 10,
+          "minute": 0,
+          "add": 3,
+          "expected": "10:03"
+        },
+        {
+          "description": "add no minutes",
+          "property": "add",
+          "hour": 6,
+          "minute": 41,
+          "add": 0,
+          "expected": "06:41"
+        },
+        {
+          "description": "add to next hour",
+          "property": "add",
+          "hour": 0,
+          "minute": 45,
+          "add": 40,
+          "expected": "01:25"
+        },
+        {
+          "description": "add more than one hour",
+          "property": "add",
+          "hour": 10,
+          "minute": 0,
+          "add": 61,
+          "expected": "11:01"
+        },
+        {
+          "description": "add more than two hours with carry",
+          "property": "add",
+          "hour": 0,
+          "minute": 45,
+          "add": 160,
+          "expected": "03:25"
+        },
+        {
+          "description": "add across midnight",
+          "property": "add",
+          "hour": 23,
+          "minute": 59,
+          "add": 2,
+          "expected": "00:01"
+        },
+        {
+          "description": "add more than one day (1500 min = 25 hrs)",
+          "property": "add",
+          "hour": 5,
+          "minute": 32,
+          "add": 1500,
+          "expected": "06:32"
+        },
+        {
+          "description": "add more than two days",
+          "property": "add",
+          "hour": 1,
+          "minute": 1,
+          "add": 3500,
+          "expected": "11:21"
+        },
+        {
+          "description": "subtract minutes",
+          "property": "add",
+          "hour": 10,
+          "minute": 3,
+          "add": -3,
+          "expected": "10:00"
+        },
+        {
+          "description": "subtract to previous hour",
+          "property": "add",
+          "hour": 10,
+          "minute": 3,
+          "add": -30,
+          "expected": "09:33"
+        },
+        {
+          "description": "subtract more than an hour",
+          "property": "add",
+          "hour": 10,
+          "minute": 3,
+          "add": -70,
+          "expected": "08:53"
+        },
+        {
+          "description": "subtract across midnight",
+          "property": "add",
+          "hour": 0,
+          "minute": 3,
+          "add": -4,
+          "expected": "23:59"
+        },
+        {
+          "description": "subtract more than two hours",
+          "property": "add",
+          "hour": 0,
+          "minute": 0,
+          "add": -160,
+          "expected": "21:20"
+        },
+        {
+          "description": "subtract more than two hours with borrow",
+          "property": "add",
+          "hour": 6,
+          "minute": 15,
+          "add": -160,
+          "expected": "03:35"
+        },
+        {
+          "description": "subtract more than one day (1500 min = 25 hrs)",
+          "property": "add",
+          "hour": 5,
+          "minute": 32,
+          "add": -1500,
+          "expected": "04:32"
+        },
+        {
+          "description": "subtract more than two days",
+          "property": "add",
+          "hour": 2,
+          "minute": 20,
+          "add": -3000,
+          "expected": "00:20"
+        }
+      ]
+    },
+    {
+      "description": "Construct two separate clocks, set times, test if they are equal.",
+      "cases": [
+        {
+          "description": "clocks with same time",
+          "property": "equal",
+          "clock1": {
+            "hour": 15,
+            "minute": 37
+          },
+          "clock2": {
+            "hour": 15,
+            "minute": 37
+          },
+          "expected": true
+        },
+        {
+          "description": "clocks a minute apart",
+          "property": "equal",
+          "clock1": {
+            "hour": 15,
+            "minute": 36
+          },
+          "clock2": {
+            "hour": 15,
+            "minute": 37
+          },
+          "expected": false
+        },
+        {
+          "description": "clocks an hour apart",
+          "property": "equal",
+          "clock1": {
+            "hour": 14,
+            "minute": 37
+          },
+          "clock2": {
+            "hour": 15,
+            "minute": 37
+          },
+          "expected": false
+        },
+        {
+          "description": "clocks with hour overflow",
+          "property": "equal",
+          "clock1": {
+            "hour": 10,
+            "minute": 37
+          },
+          "clock2": {
+            "hour": 34,
+            "minute": 37
+          },
+          "expected": true
+        },
+        {
+          "description": "clocks with hour overflow by several days",
+          "property": "equal",
+          "clock1": {
+            "hour": 3,
+            "minute": 11
+          },
+          "clock2": {
+            "hour": 99,
+            "minute": 11
+          },
+          "expected": true
+        },
+        {
+          "description": "clocks with negative hour",
+          "property": "equal",
+          "clock1": {
+            "hour": 22,
+            "minute": 40
+          },
+          "clock2": {
+            "hour": -2,
+            "minute": 40
+          },
+          "expected": true
+        },
+        {
+          "description": "clocks with negative hour that wraps",
+          "property": "equal",
+          "clock1": {
+            "hour": 17,
+            "minute": 3
+          },
+          "clock2": {
+            "hour": -31,
+            "minute": 3
+          },
+          "expected": true
+        },
+        {
+          "description": "clocks with negative hour that wraps multiple times",
+          "property": "equal",
+          "clock1": {
+            "hour": 13,
+            "minute": 49
+          },
+          "clock2": {
+            "hour": -83,
+            "minute": 49
+          },
+          "expected": true
+        },
+        {
+          "description": "clocks with minute overflow",
+          "property": "equal",
+          "clock1": {
+            "hour": 0,
+            "minute": 1
+          },
+          "clock2": {
+            "hour": 0,
+            "minute": 1441
+          },
+          "expected": true
+        },
+        {
+          "description": "clocks with minute overflow by several days",
+          "property": "equal",
+          "clock1": {
+            "hour": 2,
+            "minute": 2
+          },
+          "clock2": {
+            "hour": 2,
+            "minute": 4322
+          },
+          "expected": true
+        },
+        {
+          "description": "clocks with negative minute",
+          "property": "equal",
+          "clock1": {
+            "hour": 2,
+            "minute": 40
+          },
+          "clock2": {
+            "hour": 3,
+            "minute": -20
+          },
+          "expected": true
+        },
+        {
+          "description": "clocks with negative minute that wraps",
+          "property": "equal",
+          "clock1": {
+            "hour": 4,
+            "minute": 10
+          },
+          "clock2": {
+            "hour": 5,
+            "minute": -1490
+          },
+          "expected": true
+        },
+        {
+          "description": "clocks with negative minute that wraps multiple times",
+          "property": "equal",
+          "clock1": {
+            "hour": 6,
+            "minute": 15
+          },
+          "clock2": {
+            "hour": 6,
+            "minute": -4305
+          },
+          "expected": true
+        },
+        {
+          "description": "clocks with negative hours and minutes",
+          "property": "equal",
+          "clock1": {
+            "hour": 7,
+            "minute": 32
+          },
+          "clock2": {
+            "hour": -12,
+            "minute": -268
+          },
+          "expected": true
+        },
+        {
+          "description": "clocks with negative hours and minutes that wrap",
+          "property": "equal",
+          "clock1": {
+            "hour": 18,
+            "minute": 7
+          },
+          "clock2": {
+            "hour": -54,
+            "minute": -11513
+          },
+          "expected": true
+        }
+      ]
+    }
+  ]
+}
+
+END
+}