Source: tests.js

  1. /**
  2.  * @file Some tests.
  3.  * @version March 26, 2017
  4.  *
  5.  * @author Olivier Pirson --- http://www.opimedia.be/
  6.  * @license GPLv3 --- Copyright (C) 2017 Olivier Pirson
  7.  */
  9. (function () {
  10.     "use strict";
  12.     function add2Matchings() {
  13.         const points = [new Point(10, 10),
  14.                         new Point(50, 200),
  15.                         new Point(100, 150),
  16.                         new Point(150, 250),
  17.                         new Point(200, 170),
  18.                         new Point(300, 150),
  19.                         new Point(400, 100),
  20.                         new Point(410, 290)];
  22.         for (let point of points) {
  23.             globalController.leftController.view.matching.pointAdd(point);
  24.         }
  26.         if (true) {
  27.             for (let i = 0; i < points.length - 1; i += 2) {
  28.                 const leftSegment = new Segment(points[i], points[i + 1]);
  30.                 globalController.leftController.view.matching.segmentAdd(leftSegment);
  32.                 const rightSegment = new Segment(points[i + 1], points[(i + 2)%points.length]);
  34.                 globalController.rightController.view.matching.segmentAdd(rightSegment);
  35.             }
  36.         }
  38.         globalController.globalView.update();
  39.     }
  42.     function testCompare() {
  43.         assert(compare(42, 42) === 0);
  44.         assert(compare(42, 666) === -1);
  45.         assert(compare(-42, 666) === -1);
  46.         assert(compare(666, 42) === 1);
  47.         assert(compare(-666, 42) === -1);
  49.         assert(compare("foo", "foo") === 0);
  50.         assert(compare("foo", "bar") === 1);
  51.         assert(compare("bar", "foo") === -1);
  52.         assert(compare("bar", "FOO") === 1);
  53.     }
  56.     function testGetRandom() {
  57.         for (let i = 0; i < 100; ++i) {
  58.             const x = getRandom(-5, 17);
  60.             assert(-5 <= x, x);
  61.             assert(x < 17, x);
  62.         }
  64.         for (let i = 0; i < 100; ++i) {
  65.             const x = getRandom(42.5, 42.8);
  67.             assert(42.5 <= x, x);
  68.             assert(x < 42.8, x);
  69.         }
  70.     }
  73.     function testPoint() {
  74.         {
  75.             let p = new Point(0, 0);
  77.             assert(p.x === 0, p);
  78.             assert(p.y === 0, p);
  79.             assert(p.distanceTo0Sqr() === 0, p);
  80.             assert(p.distanceTo0() === 0, p);
  83.             p = new Point(42, 0);
  84.             assert(p.x === 42, p);
  85.             assert(p.y === 0, p);
  86.             assert(p.distanceTo0Sqr() === 42*42, p);
  87.             assert(p.distanceTo0() === 42, p);
  89.             p = new Point(0, 42);
  90.             assert(p.x === 0, p);
  91.             assert(p.y === 42, p);
  92.             assert(p.distanceTo0Sqr() === 42*42, p);
  93.             assert(p.distanceTo0() === 42, p);
  95.             p = new Point(-42, 0);
  96.             assert(p.x === -42, p);
  97.             assert(p.y === 0, p);
  98.             assert(p.distanceTo0Sqr() === 42*42, p);
  99.             assert(p.distanceTo0() === 42, p);
  101.             p = new Point(0, -42);
  102.             assert(p.x === 0, p);
  103.             assert(p.y === -42, p);
  104.             assert(p.distanceTo0Sqr() === 42*42, p);
  105.             assert(p.distanceTo0() === 42, p);
  106.         }
  108.         {
  109.             const sqr = 2*42*42;
  110.             const sqrt = Math.sqrt(sqr);
  112.             assert(isFloatEqual(sqrt, 59,39696962), sqrt);
  114.             let p = new Point(42, 42);
  116.             assert(p.x === 42, p);
  117.             assert(p.y === 42, p);
  118.             assert(p.distanceTo0Sqr() === sqr, p);
  119.             assert(p.distanceTo0() === sqrt, p);
  121.             p = new Point(-42, 42);
  122.             assert(p.x === -42, p);
  123.             assert(p.y === 42, p);
  124.             assert(p.distanceTo0Sqr() === sqr, p);
  125.             assert(p.distanceTo0() === sqrt, p);
  127.             p = new Point(-42, -42);
  128.             assert(p.x === -42, p);
  129.             assert(p.y === -42, p);
  130.             assert(p.distanceTo0Sqr() === sqr, p);
  131.             assert(p.distanceTo0() === sqrt, p);
  133.             p = new Point(42, -42);
  134.             assert(p.x === 42, p);
  135.             assert(p.y === -42, p);
  136.             assert(p.distanceTo0Sqr() === sqr, p);
  137.             assert(p.distanceTo0() === sqrt, p);
  138.         }
  140.         {
  141.             const p = new Point(-666, 365);
  143.             assert(p.x === -666, p);
  144.             assert(p.y === 365, p);
  145.             assert(p.distanceTo0Sqr() === 666*666 + 365*365, p);
  146.             assert(p.distanceTo0() === Math.sqrt(666*666 + 365*365), p);
  147.         }
  149.         for (let i = 0; i < 100; ++i) {
  150.             const x = getRandom(-100, 100);
  151.             const y = getRandom(-100, 100);
  152.             const p = new Point(x, y);
  154.             assert(p.x === x, x, p);
  155.             assert(p.y === y, y, p);
  156.             assert(isFloatEqual(p.distanceTo0Sqr(), x*x + y*y), x, y, p);
  157.             assert(isFloatEqual(p.distanceTo0(), Math.sqrt(x*x + y*y)), x, y, p);
  158.         }
  159.     }
  162.     function testSortedArrayBisectionLeft() {
  163.         {
  164.             const a = [];
  166.             assert(sortedArrayBisectionLeft(a, 666) === 0);
  167.         }
  169.         {
  170.             const a = [42];
  172.             assert(sortedArrayBisectionLeft(a, 36) === 0);
  173.             assert(sortedArrayBisectionLeft(a, 42) === 0);
  174.             assert(sortedArrayBisectionLeft(a, 666) === 1);
  175.         }
  177.         {
  178.             const a = [42, 666];
  180.             assert(sortedArrayBisectionLeft(a, 36) === 0);
  181.             assert(sortedArrayBisectionLeft(a, 42) === 0);
  182.             assert(sortedArrayBisectionLeft(a, 666) === 1);
  183.             assert(sortedArrayBisectionLeft(a, 1000) === 2);
  184.         }
  186.         {
  187.             const a = [42, 666, 1000];
  189.             assert(sortedArrayBisectionLeft(a, 36) === 0);
  190.             assert(sortedArrayBisectionLeft(a, 42) === 0);
  191.             assert(sortedArrayBisectionLeft(a, 666) === 1);
  192.             assert(sortedArrayBisectionLeft(a, 1000) === 2);
  193.             assert(sortedArrayBisectionLeft(a, 2000) === 3);
  194.         }
  195.     }
  198.     function testSortedArrayInsert() {
  199.         const a = [];
  201.         sortedArrayInsert(a, 42);
  202.         assert(arrayIsEquals(a, [42]));
  204.         sortedArrayInsert(a, 36);
  205.         assert(arrayIsEquals(a, [36, 42]));
  207.         sortedArrayInsert(a, 666);
  208.         assert(arrayIsEquals(a, [36, 42, 666]));
  210.         sortedArrayInsert(a, 42);
  211.         assert(arrayIsEquals(a, [36, 42, 42, 666]));
  213.         sortedArrayInsert(a, 1000);
  214.         assert(arrayIsEquals(a, [36, 42, 42, 666, 1000]));
  216.         sortedArrayInsert(a, 500);
  217.         assert(arrayIsEquals(a, [36, 42, 42, 500, 666, 1000]));
  219.         sortedArrayInsert(a, 0);
  220.         assert(arrayIsEquals(a, [0, 36, 42, 42, 500, 666, 1000]));
  221.     }
  224.     function runTest(fct, name) {
  225.         console.log("--- BEGIN test", name, "---");
  226.         fct();
  227.         console.log("--- END test", name, "---");
  228.     }
  231.     window.addEventListener("load", function () {
  232.         if (!isAssert()) {
  233.             return;
  234.         }
  236.         console.log("===== BEGIN tests ======");
  238.         runTest(testCompare, "compare");
  239.         runTest(testGetRandom, "getRandom");
  240.         runTest(testSortedArrayBisectionLeft, "sortedArrayBisectionLeft");
  241.         runTest(testSortedArrayInsert, "sortedArrayInsert");
  243.         runTest(testPoint, "class Point");
  245.         console.log("===== END tests ======");
  247.         add2Matchings();
  248.     });
  249. }());