Merge branch 'master' into new-arch/master

Author: lposen

src/core/classes/IterableEdgeInsets.test.ts

@@ -0,0 +1,347 @@
+import { IterableEdgeInsets } from './IterableEdgeInsets';
+import type { IterableEdgeInsetDetails } from '../types';
+
+describe('IterableEdgeInsets', () => {
+  describe('constructor', () => {
+    it('should create instance with valid parameters', () => {
+      // GIVEN valid edge inset parameters
+      const top = 10;
+      const left = 20;
+      const bottom = 30;
+      const right = 40;
+
+      // WHEN creating an IterableEdgeInsets instance
+      const edgeInsets = new IterableEdgeInsets(top, left, bottom, right);
+
+      // THEN it should have the correct properties
+      expect(edgeInsets.top).toBe(top);
+      expect(edgeInsets.left).toBe(left);
+      expect(edgeInsets.bottom).toBe(bottom);
+      expect(edgeInsets.right).toBe(right);
+    });
+
+    it('should create instance with zero values', () => {
+      // GIVEN zero edge inset parameters
+      const top = 0;
+      const left = 0;
+      const bottom = 0;
+      const right = 0;
+
+      // WHEN creating an IterableEdgeInsets instance
+      const edgeInsets = new IterableEdgeInsets(top, left, bottom, right);
+
+      // THEN it should have zero values
+      expect(edgeInsets.top).toBe(0);
+      expect(edgeInsets.left).toBe(0);
+      expect(edgeInsets.bottom).toBe(0);
+      expect(edgeInsets.right).toBe(0);
+    });
+
+    it('should create instance with negative values', () => {
+      // GIVEN negative edge inset parameters
+      const top = -5;
+      const left = -10;
+      const bottom = -15;
+      const right = -20;
+
+      // WHEN creating an IterableEdgeInsets instance
+      const edgeInsets = new IterableEdgeInsets(top, left, bottom, right);
+
+      // THEN it should have the negative values
+      expect(edgeInsets.top).toBe(-5);
+      expect(edgeInsets.left).toBe(-10);
+      expect(edgeInsets.bottom).toBe(-15);
+      expect(edgeInsets.right).toBe(-20);
+    });
+
+    it('should create instance with decimal values', () => {
+      // GIVEN decimal edge inset parameters
+      const top = 1.5;
+      const left = 2.7;
+      const bottom = 3.9;
+      const right = 4.1;
+
+      // WHEN creating an IterableEdgeInsets instance
+      const edgeInsets = new IterableEdgeInsets(top, left, bottom, right);
+
+      // THEN it should have the decimal values
+      expect(edgeInsets.top).toBe(1.5);
+      expect(edgeInsets.left).toBe(2.7);
+      expect(edgeInsets.bottom).toBe(3.9);
+      expect(edgeInsets.right).toBe(4.1);
+    });
+
+    it('should create instance with large values', () => {
+      // GIVEN large edge inset parameters
+      const top = 1000;
+      const left = 2000;
+      const bottom = 3000;
+      const right = 4000;
+
+      // WHEN creating an IterableEdgeInsets instance
+      const edgeInsets = new IterableEdgeInsets(top, left, bottom, right);
+
+      // THEN it should have the large values
+      expect(edgeInsets.top).toBe(1000);
+      expect(edgeInsets.left).toBe(2000);
+      expect(edgeInsets.bottom).toBe(3000);
+      expect(edgeInsets.right).toBe(4000);
+    });
+  });
+
+  describe('fromDict', () => {
+    it('should create instance from valid dictionary', () => {
+      // GIVEN a valid dictionary with edge inset details
+      const dict: IterableEdgeInsetDetails = {
+        top: 10,
+        left: 20,
+        bottom: 30,
+        right: 40
+      };
+
+      // WHEN creating from dictionary
+      const edgeInsets = IterableEdgeInsets.fromDict(dict);
+
+      // THEN it should have the correct properties
+      expect(edgeInsets.top).toBe(10);
+      expect(edgeInsets.left).toBe(20);
+      expect(edgeInsets.bottom).toBe(30);
+      expect(edgeInsets.right).toBe(40);
+    });
+
+    it('should create instance from dictionary with zero values', () => {
+      // GIVEN a dictionary with zero values
+      const dict: IterableEdgeInsetDetails = {
+        top: 0,
+        left: 0,
+        bottom: 0,
+        right: 0
+      };
+
+      // WHEN creating from dictionary
+      const edgeInsets = IterableEdgeInsets.fromDict(dict);
+
+      // THEN it should have zero values
+      expect(edgeInsets.top).toBe(0);
+      expect(edgeInsets.left).toBe(0);
+      expect(edgeInsets.bottom).toBe(0);
+      expect(edgeInsets.right).toBe(0);
+    });
+
+    it('should create instance from dictionary with negative values', () => {
+      // GIVEN a dictionary with negative values
+      const dict: IterableEdgeInsetDetails = {
+        top: -5,
+        left: -10,
+        bottom: -15,
+        right: -20
+      };
+
+      // WHEN creating from dictionary
+      const edgeInsets = IterableEdgeInsets.fromDict(dict);
+
+      // THEN it should have the negative values
+      expect(edgeInsets.top).toBe(-5);
+      expect(edgeInsets.left).toBe(-10);
+      expect(edgeInsets.bottom).toBe(-15);
+      expect(edgeInsets.right).toBe(-20);
+    });
+
+    it('should create instance from dictionary with decimal values', () => {
+      // GIVEN a dictionary with decimal values
+      const dict: IterableEdgeInsetDetails = {
+        top: 1.5,
+        left: 2.7,
+        bottom: 3.9,
+        right: 4.1
+      };
+
+      // WHEN creating from dictionary
+      const edgeInsets = IterableEdgeInsets.fromDict(dict);
+
+      // THEN it should have the decimal values
+      expect(edgeInsets.top).toBe(1.5);
+      expect(edgeInsets.left).toBe(2.7);
+      expect(edgeInsets.bottom).toBe(3.9);
+      expect(edgeInsets.right).toBe(4.1);
+    });
+
+    it('should create instance from dictionary with mixed positive and negative values', () => {
+      // GIVEN a dictionary with mixed values
+      const dict: IterableEdgeInsetDetails = {
+        top: 10,
+        left: -5,
+        bottom: 0,
+        right: 15
+      };
+
+      // WHEN creating from dictionary
+      const edgeInsets = IterableEdgeInsets.fromDict(dict);
+
+      // THEN it should have the mixed values
+      expect(edgeInsets.top).toBe(10);
+      expect(edgeInsets.left).toBe(-5);
+      expect(edgeInsets.bottom).toBe(0);
+      expect(edgeInsets.right).toBe(15);
+    });
+  });
+
+  describe('property access', () => {
+    it('should allow property modification', () => {
+      // GIVEN an IterableEdgeInsets instance
+      const edgeInsets = new IterableEdgeInsets(10, 20, 30, 40);
+
+      // WHEN modifying properties
+      edgeInsets.top = 100;
+      edgeInsets.left = 200;
+      edgeInsets.bottom = 300;
+      edgeInsets.right = 400;
+
+      // THEN the properties should be updated
+      expect(edgeInsets.top).toBe(100);
+      expect(edgeInsets.left).toBe(200);
+      expect(edgeInsets.bottom).toBe(300);
+      expect(edgeInsets.right).toBe(400);
+    });
+
+    it('should maintain property independence', () => {
+      // GIVEN an IterableEdgeInsets instance
+      const edgeInsets = new IterableEdgeInsets(10, 20, 30, 40);
+
+      // WHEN modifying one property
+      edgeInsets.top = 999;
+
+      // THEN other properties should remain unchanged
+      expect(edgeInsets.top).toBe(999);
+      expect(edgeInsets.left).toBe(20);
+      expect(edgeInsets.bottom).toBe(30);
+      expect(edgeInsets.right).toBe(40);
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should handle NaN values', () => {
+      // GIVEN NaN values
+      const top = NaN;
+      const left = NaN;
+      const bottom = NaN;
+      const right = NaN;
+
+      // WHEN creating an IterableEdgeInsets instance
+      const edgeInsets = new IterableEdgeInsets(top, left, bottom, right);
+
+      // THEN it should store NaN values
+      expect(edgeInsets.top).toBeNaN();
+      expect(edgeInsets.left).toBeNaN();
+      expect(edgeInsets.bottom).toBeNaN();
+      expect(edgeInsets.right).toBeNaN();
+    });
+
+    it('should handle Infinity values', () => {
+      // GIVEN Infinity values
+      const top = Infinity;
+      const left = -Infinity;
+      const bottom = Infinity;
+      const right = -Infinity;
+
+      // WHEN creating an IterableEdgeInsets instance
+      const edgeInsets = new IterableEdgeInsets(top, left, bottom, right);
+
+      // THEN it should store Infinity values
+      expect(edgeInsets.top).toBe(Infinity);
+      expect(edgeInsets.left).toBe(-Infinity);
+      expect(edgeInsets.bottom).toBe(Infinity);
+      expect(edgeInsets.right).toBe(-Infinity);
+    });
+
+    it('should handle very small decimal values', () => {
+      // GIVEN very small decimal values
+      const top = 0.0001;
+      const left = 0.0002;
+      const bottom = 0.0003;
+      const right = 0.0004;
+
+      // WHEN creating an IterableEdgeInsets instance
+      const edgeInsets = new IterableEdgeInsets(top, left, bottom, right);
+
+      // THEN it should store the small decimal values
+      expect(edgeInsets.top).toBe(0.0001);
+      expect(edgeInsets.left).toBe(0.0002);
+      expect(edgeInsets.bottom).toBe(0.0003);
+      expect(edgeInsets.right).toBe(0.0004);
+    });
+  });
+
+  describe('interface compliance', () => {
+    it('should implement IterableEdgeInsetDetails interface', () => {
+      // GIVEN an IterableEdgeInsets instance
+      const edgeInsets = new IterableEdgeInsets(10, 20, 30, 40);
+
+      // THEN it should have all required properties
+      expect(edgeInsets).toHaveProperty('top');
+      expect(edgeInsets).toHaveProperty('left');
+      expect(edgeInsets).toHaveProperty('bottom');
+      expect(edgeInsets).toHaveProperty('right');
+
+      // AND all properties should be numbers
+      expect(typeof edgeInsets.top).toBe('number');
+      expect(typeof edgeInsets.left).toBe('number');
+      expect(typeof edgeInsets.bottom).toBe('number');
+      expect(typeof edgeInsets.right).toBe('number');
+    });
+
+    it('should be assignable to IterableEdgeInsetDetails', () => {
+      // GIVEN an IterableEdgeInsets instance
+      const edgeInsets = new IterableEdgeInsets(10, 20, 30, 40);
+
+      // WHEN assigning to IterableEdgeInsetDetails
+      const details: IterableEdgeInsetDetails = edgeInsets;
+
+      // THEN it should work without type errors
+      expect(details.top).toBe(10);
+      expect(details.left).toBe(20);
+      expect(details.bottom).toBe(30);
+      expect(details.right).toBe(40);
+    });
+  });
+
+  describe('fromDict with edge cases', () => {
+    it('should handle dictionary with NaN values', () => {
+      // GIVEN a dictionary with NaN values
+      const dict: IterableEdgeInsetDetails = {
+        top: NaN,
+        left: NaN,
+        bottom: NaN,
+        right: NaN
+      };
+
+      // WHEN creating from dictionary
+      const edgeInsets = IterableEdgeInsets.fromDict(dict);
+
+      // THEN it should have NaN values
+      expect(edgeInsets.top).toBeNaN();
+      expect(edgeInsets.left).toBeNaN();
+      expect(edgeInsets.bottom).toBeNaN();
+      expect(edgeInsets.right).toBeNaN();
+    });
+
+    it('should handle dictionary with Infinity values', () => {
+      // GIVEN a dictionary with Infinity values
+      const dict: IterableEdgeInsetDetails = {
+        top: Infinity,
+        left: -Infinity,
+        bottom: Infinity,
+        right: -Infinity
+      };
+
+      // WHEN creating from dictionary
+      const edgeInsets = IterableEdgeInsets.fromDict(dict);
+
+      // THEN it should have Infinity values
+      expect(edgeInsets.top).toBe(Infinity);
+      expect(edgeInsets.left).toBe(-Infinity);
+      expect(edgeInsets.bottom).toBe(Infinity);
+      expect(edgeInsets.right).toBe(-Infinity);
+    });
+  });
+});