blockly 12.3.1 → 12.4.0

package/tests/mocha/rect_test.js

@@ -0,0 +1,1668 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {assert} from '../../node_modules/chai/index.js';
+import {
+  sharedTestSetup,
+  sharedTestTeardown,
+} from './test_helpers/setup_teardown.js';
+
+suite('Rect', function () {
+  setup(function () {
+    sharedTestSetup.call(this);
+    this.createCoord = function (x, y) {
+      return new Blockly.utils.Coordinate(x, y);
+    };
+  });
+  teardown(function () {
+    sharedTestTeardown.call(this);
+  });
+
+  suite('Rect()', function () {
+    test('initializes properties correctly', function () {
+      const rect = new Blockly.utils.Rect(1, 2, 3, 4);
+
+      assert.equal(rect.top, 1, 'top should be initialized');
+      assert.equal(rect.bottom, 2, 'bottom should be initialized');
+      assert.equal(rect.left, 3, 'left should be initialized');
+      assert.equal(rect.right, 4, 'right should be initialized');
+    });
+  });
+
+  suite('createFromPoint()', function () {
+    test('initializes properties correctly', function () {
+      const rect = Blockly.utils.Rect.createFromPoint(
+        this.createCoord(1, 2),
+        23,
+        45,
+      );
+
+      assert.equal(rect.top, 2, 'top should be initialized');
+      assert.equal(rect.bottom, 47, 'bottom should be initialized');
+      assert.equal(rect.left, 1, 'left should be initialized');
+      assert.equal(rect.right, 24, 'right should be initialized');
+    });
+  });
+
+  suite('clone()', function () {
+    test('copies properties correctly', function () {
+      const rect = Blockly.utils.Rect.createFromPoint(
+        this.createCoord(1, 2),
+        23,
+        45,
+      );
+
+      const clonedRect = rect.clone();
+
+      assert.equal(clonedRect.top, rect.top, 'top should be cloned');
+      assert.equal(clonedRect.bottom, rect.bottom, 'bottom should be cloned');
+      assert.equal(clonedRect.left, rect.left, 'left should be cloned');
+      assert.equal(clonedRect.right, rect.right, 'right should be cloned');
+    });
+  });
+
+  suite('equals()', function () {
+    test('same object instance should equal itself', function () {
+      const rect = Blockly.utils.Rect.createFromPoint(
+        this.createCoord(1, 2),
+        23,
+        45,
+      );
+
+      const areEqual = Blockly.utils.Rect.equals(rect, rect);
+
+      assert.isTrue(areEqual, 'an instance should equal itself');
+    });
+
+    test('null instances should be equal', function () {
+      const areEqual = Blockly.utils.Rect.equals(null, null);
+
+      assert.isTrue(areEqual, 'null should equal null');
+    });
+
+    test('an object and null should not be equal', function () {
+      const rect = Blockly.utils.Rect.createFromPoint(
+        this.createCoord(1, 2),
+        23,
+        45,
+      );
+
+      const areEqual = Blockly.utils.Rect.equals(rect, null);
+
+      assert.isFalse(areEqual, 'non-null should not equal null');
+    });
+
+    test('null and an object should not be equal', function () {
+      const rect = Blockly.utils.Rect.createFromPoint(
+        this.createCoord(1, 2),
+        23,
+        45,
+      );
+
+      const areEqual = Blockly.utils.Rect.equals(null, rect);
+
+      assert.isFalse(areEqual, 'null should not equal non-null');
+    });
+
+    test('object should equal its clone', function () {
+      const rect = Blockly.utils.Rect.createFromPoint(
+        this.createCoord(1, 2),
+        23,
+        45,
+      );
+
+      const areEqual = Blockly.utils.Rect.equals(rect, rect.clone());
+
+      assert.isTrue(areEqual, 'an instance and its clone should be equal');
+    });
+
+    test('object should equal an exact explicit copy', function () {
+      const rect1 = Blockly.utils.Rect.createFromPoint(
+        this.createCoord(1, 2),
+        23,
+        45,
+      );
+      const rect2 = Blockly.utils.Rect.createFromPoint(
+        this.createCoord(1, 2),
+        23,
+        45,
+      );
+
+      const areEqual = Blockly.utils.Rect.equals(rect1, rect2);
+
+      assert.isTrue(
+        areEqual,
+        'two objects constructed in the same way should be equal',
+      );
+    });
+
+    test('object should not equal object with different x position', function () {
+      const rect1 = Blockly.utils.Rect.createFromPoint(
+        this.createCoord(1, 2),
+        23,
+        45,
+      );
+      const rect2 = Blockly.utils.Rect.createFromPoint(
+        this.createCoord(3, 2),
+        23,
+        45,
+      );
+
+      const areEqual = Blockly.utils.Rect.equals(rect1, rect2);
+
+      assert.isFalse(
+        areEqual,
+        'two objects with different x positions should not be equal',
+      );
+    });
+
+    test('object should not equal object with different y position', function () {
+      const rect1 = Blockly.utils.Rect.createFromPoint(
+        this.createCoord(1, 2),
+        23,
+        45,
+      );
+      const rect2 = Blockly.utils.Rect.createFromPoint(
+        this.createCoord(1, 4),
+        23,
+        45,
+      );
+
+      const areEqual = Blockly.utils.Rect.equals(rect1, rect2);
+
+      assert.isFalse(
+        areEqual,
+        'two objects with different y positions should not be equal',
+      );
+    });
+
+    test('object should not equal object with different x and y positions', function () {
+      const rect1 = Blockly.utils.Rect.createFromPoint(
+        this.createCoord(1, 2),
+        23,
+        45,
+      );
+      const rect2 = Blockly.utils.Rect.createFromPoint(
+        this.createCoord(3, 4),
+        23,
+        45,
+      );
+
+      const areEqual = Blockly.utils.Rect.equals(rect1, rect2);
+
+      assert.isFalse(
+        areEqual,
+        'two objects with different x/y positions should not be equal',
+      );
+    });
+
+    test('object should not equal object with different width', function () {
+      const rect1 = Blockly.utils.Rect.createFromPoint(
+        this.createCoord(1, 2),
+        23,
+        45,
+      );
+      const rect2 = Blockly.utils.Rect.createFromPoint(
+        this.createCoord(1, 2),
+        46,
+        45,
+      );
+
+      const areEqual = Blockly.utils.Rect.equals(rect1, rect2);
+
+      assert.isFalse(
+        areEqual,
+        'two objects with different widths should not be equal',
+      );
+    });
+
+    test('object should not equal object with different height', function () {
+      const rect1 = Blockly.utils.Rect.createFromPoint(
+        this.createCoord(1, 2),
+        23,
+        45,
+      );
+      const rect2 = Blockly.utils.Rect.createFromPoint(
+        this.createCoord(1, 2),
+        23,
+        89,
+      );
+
+      const areEqual = Blockly.utils.Rect.equals(rect1, rect2);
+
+      assert.isFalse(
+        areEqual,
+        'two objects with different heights should not be equal',
+      );
+    });
+
+    test('object should not equal object with all different properties', function () {
+      const rect1 = Blockly.utils.Rect.createFromPoint(
+        this.createCoord(1, 2),
+        23,
+        45,
+      );
+      const rect2 = Blockly.utils.Rect.createFromPoint(
+        this.createCoord(3, 4),
+        46,
+        89,
+      );
+
+      const areEqual = Blockly.utils.Rect.equals(rect1, rect2);
+
+      assert.isFalse(
+        areEqual,
+        'two objects with all different properties should not be equal',
+      );
+    });
+  });
+
+  suite('getHeight()', function () {
+    test('computes zero height for empty rectangle', function () {
+      const rect = Blockly.utils.Rect.createFromPoint(
+        this.createCoord(0, 0),
+        0,
+        0,
+      );
+
+      assert.equal(rect.getHeight(), 0, 'height should be 0');
+    });
+
+    test('computes height of 1 for unit square rectangle', function () {
+      const rect = Blockly.utils.Rect.createFromPoint(
+        this.createCoord(0, 0),
+        1,
+        1,
+      );
+
+      assert.equal(rect.getHeight(), 1, 'height should be 1');
+    });
+
+    test('computes height of 1 for unit square rectangle not at origin', function () {
+      const rect = Blockly.utils.Rect.createFromPoint(
+        this.createCoord(1, 2),
+        1,
+        1,
+      );
+
+      assert.equal(rect.getHeight(), 1, 'height should be 1');
+    });
+
+    test('computes height of 1 for unit square rectangle with negative position', function () {
+      const rect = Blockly.utils.Rect.createFromPoint(
+        this.createCoord(-1, -2),
+        1,
+        1,
+      );
+
+      assert.equal(rect.getHeight(), 1, 'height should be 1');
+    });
+
+    test('computes decimal height for non-square rectangle not at origin', function () {
+      const rect = Blockly.utils.Rect.createFromPoint(
+        this.createCoord(1.1, 2.2),
+        3.3,
+        4.4,
+      );
+
+      assert.approximately(rect.getHeight(), 4.4, 1e-5, 'height should be 4.4');
+    });
+  });
+
+  suite('getWidth()', function () {
+    test('computes zero width for empty rectangle', function () {
+      const rect = Blockly.utils.Rect.createFromPoint(
+        this.createCoord(0, 0),
+        0,
+        0,
+      );
+
+      assert.equal(rect.getWidth(), 0, 'width should be 0');
+    });
+
+    test('computes width of 1 for unit square rectangle', function () {
+      const rect = Blockly.utils.Rect.createFromPoint(
+        this.createCoord(0, 0),
+        1,
+        1,
+      );
+
+      assert.equal(rect.getWidth(), 1, 'width should be 1');
+    });
+
+    test('computes width of 1 for unit square rectangle not at origin', function () {
+      const rect = Blockly.utils.Rect.createFromPoint(
+        this.createCoord(1, 2),
+        1,
+        1,
+      );
+
+      assert.equal(rect.getWidth(), 1, 'width should be 1');
+    });
+
+    test('computes width of 1 for unit square rectangle with negative position', function () {
+      const rect = Blockly.utils.Rect.createFromPoint(
+        this.createCoord(-1, -2),
+        1,
+        1,
+      );
+
+      assert.equal(rect.getWidth(), 1, 'width should be 1');
+    });
+
+    test('computes decimal width for non-square rectangle not at origin', function () {
+      const rect = Blockly.utils.Rect.createFromPoint(
+        this.createCoord(1.1, 2.2),
+        3.3,
+        4.4,
+      );
+
+      assert.approximately(rect.getWidth(), 3.3, 1e-5, 'width should be 3.3');
+    });
+  });
+
+  suite('contains()', function () {
+    suite('point contained within rect', function () {
+      test('origin for zero-sized square', function () {
+        const rect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(0, 0),
+          0,
+          0,
+        );
+
+        const isContained = rect.contains(0, 0);
+
+        assert.isTrue(isContained, 'Rect contains (0, 0)');
+      });
+
+      test('whole number centroid for square at origin', function () {
+        const rect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(0, 0),
+          2,
+          2,
+        );
+
+        const isContained = rect.contains(1, 1);
+
+        assert.isTrue(isContained, 'Rect contains (1, 1)');
+      });
+
+      test('decimal number centroid for square at origin', function () {
+        const rect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(0, 0),
+          1,
+          1,
+        );
+
+        const isContained = rect.contains(0.5, 0.5);
+
+        assert.isTrue(isContained, 'Rect contains (0.5, 0.5)');
+      });
+
+      test('centroid for non-square not at origin', function () {
+        const rect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(1, 2),
+          3,
+          4,
+        );
+
+        const isContained = rect.contains(2.5, 4);
+
+        assert.isTrue(isContained, 'Rect contains (2.5, 4)');
+      });
+
+      test('negative centroid for non-square not at origin', function () {
+        const rect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(-10, -20),
+          3,
+          5,
+        );
+
+        const isContained = rect.contains(-8.5, -17.5);
+
+        assert.isTrue(isContained, 'Rect contains (-8.5, -17.5)');
+      });
+
+      test('NW corner', function () {
+        const rect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(1, 2),
+          3,
+          4,
+        );
+
+        const isContained = rect.contains(1, 2);
+
+        assert.isTrue(isContained, 'Rect contains (1, 2)');
+      });
+
+      test('NE corner', function () {
+        const rect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(1, 2),
+          3,
+          4,
+        );
+
+        const isContained = rect.contains(4, 2);
+
+        assert.isTrue(isContained, 'Rect contains (4, 2)');
+      });
+
+      test('SW corner', function () {
+        const rect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(1, 2),
+          3,
+          4,
+        );
+
+        const isContained = rect.contains(1, 6);
+
+        assert.isTrue(isContained, 'Rect contains (1, 6)');
+      });
+
+      test('SE corner', function () {
+        const rect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(1, 2),
+          3,
+          4,
+        );
+
+        const isContained = rect.contains(4, 6);
+
+        assert.isTrue(isContained, 'Rect contains (4, 6)');
+      });
+
+      test('left edge midpoint', function () {
+        const rect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(1, 2),
+          3,
+          4,
+        );
+
+        const isContained = rect.contains(1, 4);
+
+        assert.isTrue(isContained, 'Rect contains (1, 4)');
+      });
+
+      test('right edge midpoint', function () {
+        const rect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(1, 2),
+          3,
+          4,
+        );
+
+        const isContained = rect.contains(4, 4);
+
+        assert.isTrue(isContained, 'Rect contains (4, 4)');
+      });
+
+      test('top edge midpoint', function () {
+        const rect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(1, 2),
+          3,
+          4,
+        );
+
+        const isContained = rect.contains(2.5, 2);
+
+        assert.isTrue(isContained, 'Rect contains (2.5, 2)');
+      });
+
+      test('bottom edge midpoint', function () {
+        const rect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(1, 2),
+          3,
+          4,
+        );
+
+        const isContained = rect.contains(2.5, 6);
+
+        assert.isTrue(isContained, 'Rect contains (2.5, 6)');
+      });
+    });
+    suite('point not contained within rect', function () {
+      test('non-origin for zero-sized square', function () {
+        const rect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(0, 0),
+          0,
+          0,
+        );
+
+        const isContained = rect.contains(0.1, 0.1);
+
+        assert.isFalse(isContained, 'Rect does not contain (0.1, 0.1)');
+      });
+
+      test('point at midpoint x but above unit square', function () {
+        const rect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(1, 1),
+          2,
+          2,
+        );
+
+        const isContained = rect.contains(2, 0);
+
+        assert.isFalse(isContained, 'Rect does not contain (2, 0)');
+      });
+
+      test('point at midpoint x but below unit square', function () {
+        const rect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(1, 1),
+          2,
+          2,
+        );
+
+        const isContained = rect.contains(2, 4);
+
+        assert.isFalse(isContained, 'Rect does not contain (2, 4)');
+      });
+
+      test('point at midpoint y but left of unit square', function () {
+        const rect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(1, 1),
+          2,
+          2,
+        );
+
+        const isContained = rect.contains(0, 2);
+
+        assert.isFalse(isContained, 'Rect does not contain (0, 2)');
+      });
+
+      test('point at midpoint y but right of unit square', function () {
+        const rect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(1, 1),
+          2,
+          2,
+        );
+
+        const isContained = rect.contains(4, 2);
+
+        assert.isFalse(isContained, 'Rect does not contain (4, 2)');
+      });
+
+      test('positive point far outside positive rectangle', function () {
+        const rect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(1, 2),
+          3,
+          4,
+        );
+
+        const isContained = rect.contains(45, 89);
+
+        assert.isFalse(isContained, 'Rect does not contain (45, 89)');
+      });
+
+      test('negative point far outside positive rectangle', function () {
+        const rect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(1, 2),
+          3,
+          4,
+        );
+
+        const isContained = rect.contains(-45, -89);
+
+        assert.isFalse(isContained, 'Rect does not contain (-45, -89)');
+      });
+
+      test('positive point far outside negative rectangle', function () {
+        const rect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(-10, -20),
+          3,
+          5,
+        );
+
+        const isContained = rect.contains(45, 89);
+
+        assert.isFalse(isContained, 'Rect does not contain (45, 89)');
+      });
+
+      test('negative point far outside negative rectangle', function () {
+        const rect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(-10, -20),
+          3,
+          5,
+        );
+
+        const isContained = rect.contains(-45, -89);
+
+        assert.isFalse(isContained, 'Rect does not contain (-45, -89)');
+      });
+
+      test('Point just outside NW corner', function () {
+        const rect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(1, 2),
+          3,
+          4,
+        );
+
+        const isContained = rect.contains(0.9, 1.9);
+
+        assert.isFalse(isContained, 'Rect does not contain (0.9, 1.9)');
+      });
+
+      test('Point just outside NE corner', function () {
+        const rect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(1, 2),
+          3,
+          4,
+        );
+
+        const isContained = rect.contains(4.1, 1.9);
+
+        assert.isFalse(isContained, 'Rect does not contain (4.1, 1.9)');
+      });
+
+      test('Point just outside SW corner', function () {
+        const rect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(1, 2),
+          3,
+          4,
+        );
+
+        const isContained = rect.contains(0.9, 6.1);
+
+        assert.isFalse(isContained, 'Rect does not contain (0.9, 6.1)');
+      });
+
+      test('Point just outside SE corner', function () {
+        const rect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(1, 2),
+          3,
+          4,
+        );
+
+        const isContained = rect.contains(4.1, 6.1);
+
+        assert.isFalse(isContained, 'Rect does not contain (4.1, 6.1)');
+      });
+
+      test('Point just outside left edge midpoint', function () {
+        const rect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(1, 2),
+          3,
+          4,
+        );
+
+        const isContained = rect.contains(0.9, 4);
+
+        assert.isFalse(isContained, 'Rect does not contain (0.9, 4)');
+      });
+
+      test('Point just outside right edge midpoint', function () {
+        const rect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(1, 2),
+          3,
+          4,
+        );
+
+        const isContained = rect.contains(4.1, 4);
+
+        assert.isFalse(isContained, 'Rect does not contain (4.1, 4)');
+      });
+
+      test('Point just outside top edge midpoint', function () {
+        const rect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(1, 2),
+          3,
+          4,
+        );
+
+        const isContained = rect.contains(2.5, 1.9);
+
+        assert.isFalse(isContained, 'Rect does not contain (2.5, 1.9)');
+      });
+
+      test('Point just outside bottom edge midpoint', function () {
+        const rect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(1, 2),
+          3,
+          4,
+        );
+
+        const isContained = rect.contains(2.5, 6.1);
+
+        assert.isFalse(isContained, 'Rect does not contain (2.5, 6.1)');
+      });
+    });
+  });
+
+  // NOTE TO DEVELOPER: For intersection tests, rects are either large (dimension size '2') or small
+  // (dimension size '1'). For compactness, the comments denoting the scenario being tested try to
+  // label larger rects with '2' where they can fit, but smaller rects are generally too small to
+  // fit any text.
+  suite('intersects()', function () {
+    suite('does intersect', function () {
+      test('rect and itself', function () {
+        const rect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(1, 2),
+          23,
+          45,
+        );
+
+        const doIntersect = rect.intersects(rect);
+
+        assert.isTrue(doIntersect, 'a rect always intersects with itself');
+      });
+
+      test('rect and its clone', function () {
+        const rect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(1, 2),
+          23,
+          45,
+        );
+
+        const doIntersect = rect.intersects(rect.clone());
+
+        assert.isTrue(doIntersect, 'a rect always intersects with its clone');
+      });
+
+      test('two rects of the same positions and dimensions', function () {
+        const rect1 = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(1, 2),
+          23,
+          45,
+        );
+        const rect2 = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(1, 2),
+          23,
+          45,
+        );
+
+        const doIntersect = rect1.intersects(rect2);
+
+        assert.isTrue(
+          doIntersect,
+          'two rects with the same positions and dimensions intersect',
+        );
+      });
+
+      test('upper left/lower right', function () {
+        // ┌───┐
+        // │2┌───┐
+        // └─│─┘2│
+        //   └───┘
+        const nwRect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(1, 1),
+          2,
+          2,
+        );
+        const seRect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(2, 2),
+          2,
+          2,
+        );
+
+        const doIntersectOneWay = nwRect.intersects(seRect);
+        const doIntersectOtherWay = seRect.intersects(nwRect);
+
+        assert.isTrue(
+          doIntersectOneWay,
+          'SE corner of NW rect intersects with SE rect',
+        );
+        assert.isTrue(
+          doIntersectOtherWay,
+          'NW corner of SE rect intersects with NW rect',
+        );
+      });
+
+      test('upper right/lower left', function () {
+        //   ┌───┐
+        // ┌───┐2│
+        // │2└─│─┘
+        // └───┘
+        const neRect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(2, 1),
+          2,
+          2,
+        );
+        const swRect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(1, 2),
+          2,
+          2,
+        );
+
+        const doIntersectOneWay = neRect.intersects(swRect);
+        const doIntersectOtherWay = swRect.intersects(neRect);
+
+        assert.isTrue(
+          doIntersectOneWay,
+          'SW corner of NE rect intersects with SW rect',
+        );
+        assert.isTrue(
+          doIntersectOtherWay,
+          'NE corner of SW rect intersects with NE rect',
+        );
+      });
+
+      test('small rect overlapping left side of big rect', function () {
+        //   ┌────┐
+        // ┌───┐2 │
+        // └───┘  │
+        //   └────┘
+        const bigRect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(1, 1),
+          2,
+          2,
+        );
+        const smallRect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(0.5, 1.5),
+          1,
+          1,
+        );
+
+        const doIntersectOneWay = bigRect.intersects(smallRect);
+        const doIntersectOtherWay = smallRect.intersects(bigRect);
+
+        assert.isTrue(
+          doIntersectOneWay,
+          'big rect intersects top/bottom sides of small rect',
+        );
+        assert.isTrue(
+          doIntersectOtherWay,
+          'small rect intersects left side of big rect',
+        );
+      });
+
+      test('small rect overlapping right side of big rect', function () {
+        // ┌────┐
+        // │ 2┌───┐
+        // │  └───┘
+        // └────┘
+        const bigRect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(1, 1),
+          2,
+          2,
+        );
+        const smallRect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(2.5, 1.5),
+          1,
+          1,
+        );
+
+        const doIntersectOneWay = bigRect.intersects(smallRect);
+        const doIntersectOtherWay = smallRect.intersects(bigRect);
+
+        assert.isTrue(
+          doIntersectOneWay,
+          'big rect intersects top/bottom sides of small rect',
+        );
+        assert.isTrue(
+          doIntersectOtherWay,
+          'small rect intersects right side of big rect',
+        );
+      });
+
+      test('small rect overlapping top side of big rect', function () {
+        //  ┌─┐
+        // ┌│─│┐
+        // │└─┘│
+        // └───┘
+        const bigRect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(1, 1),
+          2,
+          2,
+        );
+        const smallRect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(1.5, 0.5),
+          1,
+          1,
+        );
+
+        const doIntersectOneWay = bigRect.intersects(smallRect);
+        const doIntersectOtherWay = smallRect.intersects(bigRect);
+
+        assert.isTrue(
+          doIntersectOneWay,
+          'big rect intersects left/right sides of small rect',
+        );
+        assert.isTrue(
+          doIntersectOtherWay,
+          'small rect intersects top side of big rect',
+        );
+      });
+
+      test('small rect overlapping bottom side of big rect', function () {
+        // ┌───┐
+        // │┌─┐│
+        // └│─│┘
+        //  └─┘
+        const bigRect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(1, 1),
+          2,
+          2,
+        );
+        const smallRect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(1.5, 2.5),
+          1,
+          1,
+        );
+
+        const doIntersectOneWay = bigRect.intersects(smallRect);
+        const doIntersectOtherWay = smallRect.intersects(bigRect);
+
+        assert.isTrue(
+          doIntersectOneWay,
+          'big rect intersects left/right sides of small rect',
+        );
+        assert.isTrue(
+          doIntersectOtherWay,
+          'small rect intersects bottom side of big rect',
+        );
+      });
+
+      test('edge only intersection with all corners outside each rect', function () {
+        //   ┌─┐
+        //   │ │
+        // ┌─────┐
+        // └─────┘
+        //   │ │
+        //   └─┘
+        const tallRect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(2, 1),
+          1,
+          2,
+        );
+        const wideRect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(1, 2),
+          2,
+          1,
+        );
+
+        const doIntersectOneWay = tallRect.intersects(wideRect);
+        const doIntersectOtherWay = wideRect.intersects(tallRect);
+
+        assert.isTrue(
+          doIntersectOneWay,
+          'tall rect intersects top/bottom of wide rect',
+        );
+        assert.isTrue(
+          doIntersectOtherWay,
+          'wide rect intersects left/right of tall rect',
+        );
+      });
+
+      test('small rect within larger rect', function () {
+        // ┌─────┐
+        // │ ┌─┐ │
+        // │ └─┘ │
+        // └─────┘
+        const bigRect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(1, 1),
+          2,
+          2,
+        );
+        const smallRect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(1.5, 1.5),
+          1,
+          1,
+        );
+
+        const doIntersectOneWay = bigRect.intersects(smallRect);
+        const doIntersectOtherWay = smallRect.intersects(bigRect);
+
+        assert.isTrue(
+          doIntersectOneWay,
+          'big rect intersects small rect since it is contained',
+        );
+        assert.isTrue(
+          doIntersectOtherWay,
+          'small rect intersects big rect since it is contained',
+        );
+      });
+
+      test('rects overlapping on left/right sides', function () {
+        // ┌──┌────┐
+        // │ 2│ │2 │
+        // └──└────┘
+        const leftRect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(1, 1),
+          2,
+          2,
+        );
+        const rightRect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(2, 1),
+          2,
+          2,
+        );
+
+        const doIntersectOneWay = leftRect.intersects(rightRect);
+        const doIntersectOtherWay = rightRect.intersects(leftRect);
+
+        assert.isTrue(
+          doIntersectOneWay,
+          "Left rect's right overlaps with right rect's left",
+        );
+        assert.isTrue(
+          doIntersectOtherWay,
+          "Right rect's left overlaps with left rect's right",
+        );
+      });
+
+      test('rects overlapping on top/bottom sides', function () {
+        // ┌───┐
+        // ┌───┐
+        // │───│
+        // └───┘
+        const topRect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(1, 1),
+          2,
+          2,
+        );
+        const bottomRect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(1, 2),
+          2,
+          2,
+        );
+
+        const doIntersectOneWay = topRect.intersects(bottomRect);
+        const doIntersectOtherWay = bottomRect.intersects(topRect);
+
+        assert.isTrue(
+          doIntersectOneWay,
+          "Top rect's bottom overlaps with bottom rect's top",
+        );
+        assert.isTrue(
+          doIntersectOtherWay,
+          "Bottom rect's top overlaps with top rect's bottom",
+        );
+      });
+
+      test('rects adjacent on left/right sides', function () {
+        // ┌───┬───┐
+        // │ 2 │ 2 │
+        // └───┴───┘
+        const leftRect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(1, 1),
+          2,
+          2,
+        );
+        const rightRect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(3, 1),
+          2,
+          2,
+        );
+
+        const doIntersectOneWay = leftRect.intersects(rightRect);
+        const doIntersectOtherWay = rightRect.intersects(leftRect);
+
+        assert.isTrue(
+          doIntersectOneWay,
+          "Left rect's right intersects with right rect's left",
+        );
+        assert.isTrue(
+          doIntersectOtherWay,
+          "Right rect's left intersects with left rect's right",
+        );
+      });
+
+      test('rects adjacent on top/bottom sides', function () {
+        // ┌───┐
+        // │ 2 │
+        // ├───┤
+        // │ 2 │
+        // └───┘
+        const topRect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(1, 1),
+          2,
+          2,
+        );
+        const bottomRect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(1, 3),
+          2,
+          2,
+        );
+
+        const doIntersectOneWay = topRect.intersects(bottomRect);
+        const doIntersectOtherWay = bottomRect.intersects(topRect);
+
+        assert.isTrue(
+          doIntersectOneWay,
+          "Top rect's bottom intersects with bottom rect's top",
+        );
+        assert.isTrue(
+          doIntersectOtherWay,
+          "Bottom rect's top intersects with top rect's bottom",
+        );
+      });
+
+      test('small left rect adjacent to big right rect', function () {
+        //   ┌───┐
+        // ┌─┐ 2 │
+        // └─┘   │
+        //   └───┘
+        const bigRect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(2, 1),
+          2,
+          2,
+        );
+        const smallRect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(1, 1.5),
+          1,
+          1,
+        );
+
+        const doIntersectOneWay = bigRect.intersects(smallRect);
+        const doIntersectOtherWay = smallRect.intersects(bigRect);
+
+        assert.isTrue(
+          doIntersectOneWay,
+          "big rect's left intersects small rect's right",
+        );
+        assert.isTrue(
+          doIntersectOtherWay,
+          "small rect's right intersects big rect's left",
+        );
+      });
+
+      test('small right rect adjacent to big left rect', function () {
+        // ┌───┐
+        // │ 2 ┌─┐
+        // │   └─┘
+        // └───┘
+        const bigRect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(1, 1),
+          2,
+          2,
+        );
+        const smallRect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(3, 1.5),
+          1,
+          1,
+        );
+
+        const doIntersectOneWay = bigRect.intersects(smallRect);
+        const doIntersectOtherWay = smallRect.intersects(bigRect);
+
+        assert.isTrue(
+          doIntersectOneWay,
+          "big rect's right intersects small rect's left",
+        );
+        assert.isTrue(
+          doIntersectOtherWay,
+          "small rect's left intersects big rect's right",
+        );
+      });
+
+      test('small top rect adjacent to big bottom rect', function () {
+        //  ┌─┐
+        // ┌└─┘┐
+        // │ 2 │
+        // └───┘
+        const bigRect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(1, 1),
+          2,
+          2,
+        );
+        const smallRect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(1.5, 0),
+          1,
+          1,
+        );
+
+        const doIntersectOneWay = bigRect.intersects(smallRect);
+        const doIntersectOtherWay = smallRect.intersects(bigRect);
+
+        assert.isTrue(
+          doIntersectOneWay,
+          "big rect's top intersects small rect's bottom",
+        );
+        assert.isTrue(
+          doIntersectOtherWay,
+          "small rect's bottom intersects big rect's top",
+        );
+      });
+
+      test('small bottom rect adjacent to big top rect', function () {
+        // ┌───┐
+        // │ 2 │
+        // └┌─┐┘
+        //  └─┘
+        const bigRect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(1, 1),
+          2,
+          2,
+        );
+        const smallRect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(1.5, 3),
+          1,
+          1,
+        );
+
+        const doIntersectOneWay = bigRect.intersects(smallRect);
+        const doIntersectOtherWay = smallRect.intersects(bigRect);
+
+        assert.isTrue(
+          doIntersectOneWay,
+          "big rect's bottom intersects small rect's top",
+        );
+        assert.isTrue(
+          doIntersectOtherWay,
+          "small rect's top intersects big rect's bottom",
+        );
+      });
+
+      test('SW rect corner-adjacent to NE rect', function () {
+        //     ┌───┐
+        //     │ 2 │
+        // ┌───┐───┘
+        // │ 2 │
+        // └───┘
+        const swRect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(1, 3),
+          2,
+          2,
+        );
+        const neRect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(3, 1),
+          2,
+          2,
+        );
+
+        const doIntersectOneWay = swRect.intersects(neRect);
+        const doIntersectOtherWay = neRect.intersects(swRect);
+
+        assert.isTrue(
+          doIntersectOneWay,
+          'SW rect intersects with SW corner of NE rect',
+        );
+        assert.isTrue(
+          doIntersectOtherWay,
+          'NE rect intersects with NE corner of SW rect',
+        );
+      });
+
+      test('NW rect corner-adjacent to SE rect', function () {
+        // ┌───┐
+        // │ 2 │
+        // └───┘───┐
+        //     │ 2 │
+        //     └───┘
+        const nwRect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(1, 1),
+          2,
+          2,
+        );
+        const seRect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(3, 3),
+          2,
+          2,
+        );
+
+        const doIntersectOneWay = seRect.intersects(nwRect);
+        const doIntersectOtherWay = nwRect.intersects(seRect);
+
+        assert.isTrue(
+          doIntersectOneWay,
+          'SE rect intersects with SE corner of NW rect',
+        );
+        assert.isTrue(
+          doIntersectOtherWay,
+          'NW rect intersects with NW corner of SE rect',
+        );
+      });
+    });
+    suite('does not intersect', function () {
+      test('Same-size rects nearly side-adjacent', function () {
+        // ┌───┐ ┌───┐
+        // │ 2 │ │ 2 │
+        // └───┘ └───┘
+        const westRect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(1, 1),
+          2,
+          2,
+        );
+        const eastRect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(3.5, 1),
+          2,
+          2,
+        );
+
+        const doIntersectOneWay = westRect.intersects(eastRect);
+        const doIntersectOtherWay = eastRect.intersects(westRect);
+
+        assert.isFalse(
+          doIntersectOneWay,
+          'Western rect does not intersect with eastern rect',
+        );
+        assert.isFalse(
+          doIntersectOtherWay,
+          'Eastern rect does not intersect with western rect',
+        );
+      });
+
+      test('Same-size rects nearly side-adjacent', function () {
+        // ┌───┐
+        // │ 2 │
+        // └───┘
+        // ┌───┐
+        // │ 2 │
+        // └───┘
+        const northRect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(1, 1),
+          2,
+          2,
+        );
+        const southRect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(1, 3.5),
+          2,
+          2,
+        );
+
+        const doIntersectOneWay = northRect.intersects(southRect);
+        const doIntersectOtherWay = southRect.intersects(northRect);
+
+        assert.isFalse(
+          doIntersectOneWay,
+          'Northern rect does not intersect with southern rect',
+        );
+        assert.isFalse(
+          doIntersectOtherWay,
+          'Southern rect does not intersect with northern rect',
+        );
+      });
+
+      test('Small rect left of big rect', function () {
+        //    ┌───┐
+        // ┌─┐│ 2 │
+        // └─┘│   │
+        //    └───┘
+        const westRect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(1, 1),
+          1,
+          1,
+        );
+        const eastRect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(2.5, 1),
+          2,
+          2,
+        );
+
+        const doIntersectOneWay = westRect.intersects(eastRect);
+        const doIntersectOtherWay = eastRect.intersects(westRect);
+
+        assert.isFalse(
+          doIntersectOneWay,
+          'Western rect does not intersect with eastern rect',
+        );
+        assert.isFalse(
+          doIntersectOtherWay,
+          'Eastern rect does not intersect with western rect',
+        );
+      });
+
+      test('Small rect right of big rect', function () {
+        // ┌───┐
+        // │ 2 │┌─┐
+        // │   │└─┘
+        // └───┘
+        const westRect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(1, 1),
+          2,
+          2,
+        );
+        const eastRect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(3.5, 1),
+          1,
+          1,
+        );
+
+        const doIntersectOneWay = westRect.intersects(eastRect);
+        const doIntersectOtherWay = eastRect.intersects(westRect);
+
+        assert.isFalse(
+          doIntersectOneWay,
+          'Western rect does not intersect with eastern rect',
+        );
+        assert.isFalse(
+          doIntersectOtherWay,
+          'Eastern rect does not intersect with western rect',
+        );
+      });
+
+      test('Small rect above big rect', function () {
+        //  ┌─┐
+        //  └─┘
+        // ┌───┐
+        // │ 2 │
+        // └───┘
+        const northRect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(1, 1),
+          1,
+          1,
+        );
+        const southRect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(1, 2.5),
+          2,
+          2,
+        );
+
+        const doIntersectOneWay = northRect.intersects(southRect);
+        const doIntersectOtherWay = southRect.intersects(northRect);
+
+        assert.isFalse(
+          doIntersectOneWay,
+          'Northern rect does not intersect with southern rect',
+        );
+        assert.isFalse(
+          doIntersectOtherWay,
+          'Southern rect does not intersect with northern rect',
+        );
+      });
+
+      test('Small rect below big rect', function () {
+        // ┌───┐
+        // │ 2 │
+        // └───┘
+        //  ┌─┐
+        //  └─┘
+        const northRect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(1, 1),
+          2,
+          2,
+        );
+        const southRect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(1, 3.5),
+          1,
+          1,
+        );
+
+        const doIntersectOneWay = northRect.intersects(southRect);
+        const doIntersectOtherWay = southRect.intersects(northRect);
+
+        assert.isFalse(
+          doIntersectOneWay,
+          'Northern rect does not intersect with southern rect',
+        );
+        assert.isFalse(
+          doIntersectOtherWay,
+          'Southern rect does not intersect with northern rect',
+        );
+      });
+
+      test('Same-size rects diagonal (NE and SW) to each other', function () {
+        //      ┌───┐
+        //      │ 2 │
+        //      └───┘
+        // ┌───┐
+        // │ 2 │
+        // └───┘
+        const neRect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(3.5, 1),
+          2,
+          2,
+        );
+        const swRect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(1, 3.5),
+          2,
+          2,
+        );
+
+        const doIntersectOneWay = neRect.intersects(swRect);
+        const doIntersectOtherWay = swRect.intersects(neRect);
+
+        assert.isFalse(
+          doIntersectOneWay,
+          'NE rect does not intersect with SW rect',
+        );
+        assert.isFalse(
+          doIntersectOtherWay,
+          'SW rect does not intersect with NE rect',
+        );
+      });
+
+      test('Same-size rects diagonal (NW and SE) to each other', function () {
+        // ┌───┐
+        // │ 2 │
+        // └───┘
+        //      ┌───┐
+        //      │ 2 │
+        //      └───┘
+        const nwRect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(1, 1),
+          2,
+          2,
+        );
+        const seRect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(3.5, 3.5),
+          2,
+          2,
+        );
+
+        const doIntersectOneWay = nwRect.intersects(seRect);
+        const doIntersectOtherWay = seRect.intersects(nwRect);
+
+        assert.isFalse(
+          doIntersectOneWay,
+          'NW rect does not intersect with SE rect',
+        );
+        assert.isFalse(
+          doIntersectOtherWay,
+          'SE rect does not intersect with NW rect',
+        );
+      });
+
+      test('Small rect NE of big rect', function () {
+        //      ┌─┐
+        //      └─┘
+        // ┌───┐
+        // │ 2 │
+        // └───┘
+        const neRect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(3.5, 1),
+          1,
+          1,
+        );
+        const swRect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(1, 2.5),
+          2,
+          2,
+        );
+
+        const doIntersectOneWay = neRect.intersects(swRect);
+        const doIntersectOtherWay = swRect.intersects(neRect);
+
+        assert.isFalse(
+          doIntersectOneWay,
+          'NE rect does not intersect with SW rect',
+        );
+        assert.isFalse(
+          doIntersectOtherWay,
+          'SW rect does not intersect with NE rect',
+        );
+      });
+
+      test('Small rect NW of big rect', function () {
+        // ┌─┐
+        // └─┘
+        //      ┌───┐
+        //      │ 2 │
+        //      └───┘
+        const nwRect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(1, 1),
+          1,
+          1,
+        );
+        const seRect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(2.5, 2.5),
+          2,
+          2,
+        );
+
+        const doIntersectOneWay = nwRect.intersects(seRect);
+        const doIntersectOtherWay = seRect.intersects(nwRect);
+
+        assert.isFalse(
+          doIntersectOneWay,
+          'NW rect does not intersect with SE rect',
+        );
+        assert.isFalse(
+          doIntersectOtherWay,
+          'SE rect does not intersect with NW rect',
+        );
+      });
+
+      test('Small rect SW of big rect', function () {
+        //      ┌───┐
+        //      │ 2 │
+        //      └───┘
+        // ┌─┐
+        // └─┘
+        const neRect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(2.5, 1),
+          2,
+          2,
+        );
+        const swRect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(1, 3.5),
+          1,
+          1,
+        );
+
+        const doIntersectOneWay = neRect.intersects(swRect);
+        const doIntersectOtherWay = swRect.intersects(neRect);
+
+        assert.isFalse(
+          doIntersectOneWay,
+          'NE rect does not intersect with SW rect',
+        );
+        assert.isFalse(
+          doIntersectOtherWay,
+          'SW rect does not intersect with NE rect',
+        );
+      });
+
+      test('Small rect SE of big rect', function () {
+        // ┌───┐
+        // │ 2 │
+        // └───┘
+        //      ┌─┐
+        //      └─┘
+        const nwRect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(1, 1),
+          2,
+          2,
+        );
+        const seRect = Blockly.utils.Rect.createFromPoint(
+          this.createCoord(3.5, 3.5),
+          1,
+          1,
+        );
+
+        const doIntersectOneWay = nwRect.intersects(seRect);
+        const doIntersectOtherWay = seRect.intersects(nwRect);
+
+        assert.isFalse(
+          doIntersectOneWay,
+          'NW rect does not intersect with SE rect',
+        );
+        assert.isFalse(
+          doIntersectOtherWay,
+          'SE rect does not intersect with NW rect',
+        );
+      });
+    });
+  });
+});