Viewing github.com/facebook/react/packages/react-devtools-timeline/src/view-base/__tests_

```
/**
```

 * Copyright (c) Meta Platforms, Inc. and affiliates.

```
 *
```

 * This source code is licensed under the MIT license found in the

 * LICENSE file in the root directory of this source tree.

```
 *
```
```
 * @flow
```
```
 */
```
```
import {
```
```
  pointEqualToPoint,
```
```
  sizeEqualToSize,
```
```
  rectEqualToRect,
```
```
  sizeIsValid,
```
```
  sizeIsEmpty,
```
```
  rectIntersectsRect,
```
```
  intersectionOfRects,
```
```
  rectContainsPoint,
```
```
  unionOfRects,
```
```
} from '../geometry';
```
```
describe(pointEqualToPoint, () => {
```

  it('should return true when 2 points have the same values', () => {

    expect(pointEqualToPoint({x: 1, y: 1}, {x: 1, y: 1})).toBe(true);

    expect(pointEqualToPoint({x: -1, y: 2}, {x: -1, y: 2})).toBe(true);

```
    expect(
```

      pointEqualToPoint({x: 3.14159, y: 0.26535}, {x: 3.14159, y: 0.26535}),

```
    ).toBe(true);
```
```
  });
```

  it('should return false when 2 points have different values', () => {

    expect(pointEqualToPoint({x: 1, y: 1}, {x: 1, y: 0})).toBe(false);

    expect(pointEqualToPoint({x: -1, y: 2}, {x: 0, y: 1})).toBe(false);

```
    expect(
```

      pointEqualToPoint({x: 3.1416, y: 0.26534}, {x: 3.14159, y: 0.26535}),

```
    ).toBe(false);
```
```
  });
```
```
});
```
```
describe(sizeEqualToSize, () => {
```

  it('should return true when 2 sizes have the same values', () => {

    expect(sizeEqualToSize({width: 1, height: 1}, {width: 1, height: 1})).toBe(

```
      true,
```
```
    );
```
```
    expect(
```

      sizeEqualToSize({width: -1, height: 2}, {width: -1, height: 2}),

```
    ).toBe(true);
```
```
    expect(
```
```
      sizeEqualToSize(
```

        {width: 3.14159, height: 0.26535},

        {width: 3.14159, height: 0.26535},

```
      ),
```
```
    ).toBe(true);
```
```
  });
```

  it('should return false when 2 sizes have different values', () => {

    expect(sizeEqualToSize({width: 1, height: 1}, {width: 1, height: 0})).toBe(

```
      false,
```
```
    );
```

    expect(sizeEqualToSize({width: -1, height: 2}, {width: 0, height: 1})).toBe(

```
      false,
```
```
    );
```
```
    expect(
```
```
      sizeEqualToSize(
```

        {width: 3.1416, height: 0.26534},

        {width: 3.14159, height: 0.26535},

```
      ),
```
```
    ).toBe(false);
```
```
  });
```
```
});
```
```
describe(rectEqualToRect, () => {
```

  it('should return true when 2 rects have the same values', () => {

```
    expect(
```
```
      rectEqualToRect(
```

        {origin: {x: 1, y: 1}, size: {width: 1, height: 1}},

        {origin: {x: 1, y: 1}, size: {width: 1, height: 1}},

```
      ),
```
```
    ).toBe(true);
```
```
    expect(
```
```
      rectEqualToRect(
```

        {origin: {x: 1, y: 2}, size: {width: 3.14, height: 4}},

        {origin: {x: 1, y: 2}, size: {width: 3.14, height: 4}},

```
      ),
```
```
    ).toBe(true);
```
```
  });
```

  it('should return false when 2 rects have different values', () => {

```
    expect(
```
```
      rectEqualToRect(
```

        {origin: {x: 1, y: 1}, size: {width: 1, height: 1}},

        {origin: {x: 0, y: 1}, size: {width: 1, height: 1}},

```
      ),
```
```
    ).toBe(false);
```
```
    expect(
```
```
      rectEqualToRect(
```

        {origin: {x: 1, y: 2}, size: {width: 3.14, height: 4}},

        {origin: {x: 1, y: 2}, size: {width: 3.15, height: 4}},

```
      ),
```
```
    ).toBe(false);
```
```
  });
```
```
});
```
```
describe(sizeIsValid, () => {
```

  it('should return true when the size has non-negative width and height', () => {

    expect(sizeIsValid({width: 1, height: 1})).toBe(true);

    expect(sizeIsValid({width: 0, height: 0})).toBe(true);

```
  });
```

  it('should return false when the size has negative width or height', () => {

    expect(sizeIsValid({width: 0, height: -1})).toBe(false);

    expect(sizeIsValid({width: -1, height: 0})).toBe(false);

    expect(sizeIsValid({width: -1, height: -1})).toBe(false);

```
  });
```
```
});
```
```
describe(sizeIsEmpty, () => {
```

  it('should return true when the size has negative area', () => {

    expect(sizeIsEmpty({width: 1, height: -1})).toBe(true);

    expect(sizeIsEmpty({width: -1, height: -1})).toBe(true);

```
  });
```

  it('should return true when the size has zero area', () => {

    expect(sizeIsEmpty({width: 0, height: 0})).toBe(true);

    expect(sizeIsEmpty({width: 0, height: 1})).toBe(true);

    expect(sizeIsEmpty({width: 1, height: 0})).toBe(true);

```
  });
```

  it('should return false when the size has positive area', () => {

    expect(sizeIsEmpty({width: 1, height: 1})).toBe(false);

    expect(sizeIsEmpty({width: 2, height: 1})).toBe(false);

```
  });
```
```
});
```
```
describe(rectIntersectsRect, () => {
```

  it('should return true when 2 rects intersect', () => {

```
    // Rects touch
```
```
    expect(
```
```
      rectIntersectsRect(
```

        {origin: {x: 0, y: 0}, size: {width: 1, height: 1}},

        {origin: {x: 1, y: 1}, size: {width: 1, height: 1}},

```
      ),
```
```
    ).toEqual(true);
```
```
    // Rects overlap
```
```
    expect(
```
```
      rectIntersectsRect(
```

        {origin: {x: 0, y: 0}, size: {width: 2, height: 1}},

        {origin: {x: 1, y: -2}, size: {width: 0.5, height: 5}},

```
      ),
```
```
    ).toEqual(true);
```
```
    // Rects are equal
```
```
    expect(
```
```
      rectIntersectsRect(
```

        {origin: {x: 1, y: 2}, size: {width: 3.14, height: 4}},

        {origin: {x: 1, y: 2}, size: {width: 3.14, height: 4}},

```
      ),
```
```
    ).toEqual(true);
```
```
  });
```

  it('should return false when 2 rects do not intersect', () => {

```
    expect(
```
```
      rectIntersectsRect(
```

        {origin: {x: 0, y: 1}, size: {width: 1, height: 1}},

        {origin: {x: 0, y: 10}, size: {width: 1, height: 1}},

```
      ),
```
```
    ).toBe(false);
```
```
    expect(
```
```
      rectIntersectsRect(
```

        {origin: {x: 1, y: 2}, size: {width: 3.14, height: 4}},

        {origin: {x: -4, y: 2}, size: {width: 3.15, height: 4}},

```
      ),
```
```
    ).toBe(false);
```
```
  });
```
```
});
```
```
describe(intersectionOfRects, () => {
```

  // NOTE: Undefined behavior if rects do not intersect

  it('should return intersection when 2 rects intersect', () => {

```
    // Rects touch
```
```
    expect(
```
```
      intersectionOfRects(
```

        {origin: {x: 0, y: 0}, size: {width: 1, height: 1}},

        {origin: {x: 1, y: 1}, size: {width: 1, height: 1}},

```
      ),
```

    ).toEqual({origin: {x: 1, y: 1}, size: {width: 0, height: 0}});

```
    // Rects overlap
```
```
    expect(
```
```
      intersectionOfRects(
```

        {origin: {x: 0, y: 0}, size: {width: 2, height: 1}},

        {origin: {x: 1, y: -2}, size: {width: 0.5, height: 5}},

```
      ),
```

    ).toEqual({origin: {x: 1, y: 0}, size: {width: 0.5, height: 1}});

```
    // Rects are equal
```
```
    expect(
```
```
      intersectionOfRects(
```

        {origin: {x: 1, y: 2}, size: {width: 9.24, height: 4}},

        {origin: {x: 1, y: 2}, size: {width: 9.24, height: 4}},

```
      ),
```

    ).toEqual({origin: {x: 1, y: 2}, size: {width: 9.24, height: 4}});

```
  });
```
```
});
```
```
describe(rectContainsPoint, () => {
```

  it("should return true if point is on the rect's edge", () => {

```
    expect(
```
```
      rectContainsPoint(
```
```
        {x: 0, y: 0},
```

        {origin: {x: 0, y: 0}, size: {width: 1, height: 1}},

```
      ),
```
```
    ).toBe(true);
```
```
    expect(
```
```
      rectContainsPoint(
```
```
        {x: 5, y: 0},
```

        {origin: {x: 0, y: 0}, size: {width: 10, height: 1}},

```
      ),
```
```
    ).toBe(true);
```
```
    expect(
```
```
      rectContainsPoint(
```
```
        {x: 1, y: 1},
```

        {origin: {x: 0, y: 0}, size: {width: 1, height: 1}},

```
      ),
```
```
    ).toBe(true);
```
```
  });
```

  it('should return true if point is in rect', () => {

```
    expect(
```
```
      rectContainsPoint(
```
```
        {x: 5, y: 50},
```

        {origin: {x: 0, y: 0}, size: {width: 10, height: 100}},

```
      ),
```
```
    ).toBe(true);
```
```
  });
```

  it('should return false if point is not in rect', () => {

```
    expect(
```
```
      rectContainsPoint(
```
```
        {x: -1, y: 0},
```

        {origin: {x: 0, y: 0}, size: {width: 1, height: 1}},

```
      ),
```
```
    ).toBe(false);
```
```
  });
```
```
});
```
```
describe(unionOfRects, () => {
```

  it('should return zero rect if no rects are provided', () => {

```
    expect(unionOfRects()).toEqual({
```
```
      origin: {x: 0, y: 0},
```
```
      size: {width: 0, height: 0},
```
```
    });
```
```
  });
```

  it('should return rect if 1 rect is provided', () => {

```
    expect(
```

      unionOfRects({origin: {x: 1, y: 2}, size: {width: 3, height: 4}}),

    ).toEqual({origin: {x: 1, y: 2}, size: {width: 3, height: 4}});

```
  });
```

  it('should return union of rects if more than one rect is provided', () => {

```
    expect(
```
```
      unionOfRects(
```

        {origin: {x: 1, y: 2}, size: {width: 3, height: 4}},

        {origin: {x: 100, y: 200}, size: {width: 3, height: 4}},

        {origin: {x: -10, y: -20}, size: {width: 50, height: 60}},

```
      ),
```

    ).toEqual({origin: {x: -10, y: -20}, size: {width: 113, height: 224}});

```
  });
```
```
});
```