@codehz/ecs 0.7.1 → 0.7.3

package/src/__tests__/entity/id-system.test.ts

@@ -0,0 +1,260 @@
+import { describe, expect, it } from "bun:test";
+import type { ComponentId, EntityId } from "../../entity";
+import {
+  COMPONENT_ID_MAX,
+  createComponentId,
+  createEntityId,
+  decodeRelationId,
+  ENTITY_ID_START,
+  getDetailedIdType,
+  getIdType,
+  inspectEntityId,
+  INVALID_COMPONENT_ID,
+  isComponentId,
+  isEntityId,
+  isRelationId,
+  isWildcardRelationId,
+  relation,
+} from "../../entity";
+
+describe("Entity ID System", () => {
+  describe("Component IDs", () => {
+    it("should create valid component IDs", () => {
+      expect(createComponentId(1)).toBe(createComponentId(1));
+      expect(createComponentId(2)).toBe(createComponentId(2));
+      expect(createComponentId(COMPONENT_ID_MAX)).toBe(createComponentId(COMPONENT_ID_MAX));
+    });
+
+    it("should reject invalid component IDs", () => {
+      expect(() => createComponentId(0)).toThrow();
+      expect(() => createComponentId(-1)).toThrow();
+      expect(() => createComponentId(COMPONENT_ID_MAX + 1)).toThrow();
+    });
+
+    it("should identify component IDs correctly", () => {
+      expect(isComponentId(createComponentId(1))).toBe(true);
+      expect(isComponentId(createComponentId(2))).toBe(true);
+      expect(isComponentId(createComponentId(COMPONENT_ID_MAX))).toBe(true);
+      expect(isComponentId(createEntityId(ENTITY_ID_START))).toBe(false);
+      expect(isComponentId(relation(createComponentId(1), createEntityId(ENTITY_ID_START)))).toBe(false);
+    });
+  });
+
+  describe("Entity IDs", () => {
+    it("should create valid entity IDs", () => {
+      expect(createEntityId(ENTITY_ID_START)).toBe(createEntityId(ENTITY_ID_START));
+      expect(createEntityId(ENTITY_ID_START + 1)).toBe(createEntityId(ENTITY_ID_START + 1));
+      expect(createEntityId(10000)).toBe(createEntityId(10000));
+    });
+
+    it("should reject invalid entity IDs", () => {
+      expect(() => createEntityId(ENTITY_ID_START - 1)).toThrow();
+      expect(() => createEntityId(0)).toThrow();
+    });
+
+    it("should identify entity IDs correctly", () => {
+      expect(isEntityId(createEntityId(ENTITY_ID_START))).toBe(true);
+      expect(isEntityId(createEntityId(10000))).toBe(true);
+      expect(isEntityId(createComponentId(1))).toBe(false);
+      expect(isEntityId(relation(createComponentId(1), createEntityId(ENTITY_ID_START)))).toBe(false);
+    });
+  });
+
+  describe("Relation IDs", () => {
+    it("should create valid relation IDs with entities", () => {
+      const compId = createComponentId(5);
+      const entId = createEntityId(ENTITY_ID_START + 10);
+      const relationId = relation(compId, entId);
+
+      expect(relationId).toBeLessThan(0);
+      expect(isRelationId(relationId)).toBe(true);
+    });
+
+    it("should create valid relation IDs with components", () => {
+      const compId1 = createComponentId(5);
+      const compId2 = createComponentId(10);
+      const relationId = relation(compId1, compId2);
+
+      expect(relationId).toBeLessThan(0);
+      expect(isRelationId(relationId)).toBe(true);
+    });
+
+    it("should reject invalid relation creation", () => {
+      const entId = createEntityId(ENTITY_ID_START);
+      expect(() => relation(1024 as ComponentId, entId)).toThrow();
+      expect(() => relation(createComponentId(5), -1 as EntityId)).toThrow();
+      expect(() => relation(createComponentId(5), relation(createComponentId(1), createEntityId(1025)))).toThrow();
+    });
+
+    it("should decode relation IDs with entities correctly", () => {
+      const compId = createComponentId(42);
+      const entId = createEntityId(ENTITY_ID_START + 123);
+      const relationId = relation(compId, entId);
+
+      const decoded = decodeRelationId(relationId);
+      expect(decoded.componentId).toBe(compId);
+      expect(decoded.targetId).toBe(entId);
+      expect(decoded.type).toBe("entity");
+    });
+
+    it("should decode relation IDs with components correctly", () => {
+      const compId1 = createComponentId(42);
+      const compId2 = createComponentId(100);
+      const relationId = relation(compId1, compId2);
+
+      const decoded = decodeRelationId(relationId);
+      expect(decoded.componentId).toBe(compId1);
+      expect(decoded.targetId).toBe(compId2);
+      expect(decoded.type).toBe("component");
+    });
+
+    it("should create valid wildcard relation IDs", () => {
+      const compId = createComponentId(5);
+      const relationId = relation(compId, "*");
+
+      expect(relationId).toBeLessThan(0);
+      expect(isRelationId(relationId)).toBe(true);
+    });
+
+    it("should identify wildcard relation IDs correctly", () => {
+      const compId = createComponentId(5);
+      const wildcardRelationId = relation(compId, "*");
+      const entityRelationId = relation(compId, createEntityId(ENTITY_ID_START));
+      const componentRelationId = relation(compId, createComponentId(10));
+      const entityId = createEntityId(ENTITY_ID_START);
+      const componentId = createComponentId(1);
+
+      expect(isWildcardRelationId(wildcardRelationId)).toBe(true);
+      expect(isWildcardRelationId(entityRelationId)).toBe(false);
+      expect(isWildcardRelationId(componentRelationId)).toBe(false);
+      expect(isWildcardRelationId(entityId)).toBe(false);
+      expect(isWildcardRelationId(componentId)).toBe(false);
+    });
+
+    it("should decode wildcard relation IDs correctly", () => {
+      const compId = createComponentId(42);
+      const relationId = relation(compId, "*");
+
+      const decoded = decodeRelationId(relationId);
+      expect(decoded.componentId).toBe(compId);
+      expect(decoded.targetId).toBe(0 as EntityId);
+      expect(decoded.type).toBe("wildcard");
+    });
+  });
+
+  describe("ID Type Detection", () => {
+    it("should correctly identify ID types", () => {
+      expect(getIdType(createComponentId(1))).toBe("component");
+      expect(getIdType(createComponentId(500))).toBe("component");
+      expect(getIdType(createEntityId(ENTITY_ID_START))).toBe("entity");
+      expect(getIdType(createEntityId(10000))).toBe("entity");
+      expect(getIdType(relation(createComponentId(1), createEntityId(ENTITY_ID_START)))).toBe("entity-relation");
+      expect(getIdType(relation(createComponentId(1), createComponentId(2)))).toBe("component-relation");
+      expect(getIdType(relation(createComponentId(1), "*"))).toBe("wildcard-relation");
+
+      expect(getIdType(INVALID_COMPONENT_ID as EntityId)).toBe("invalid");
+      expect(getIdType(-999999 as EntityId)).toBe("invalid");
+    });
+
+    it("should provide detailed ID type information", () => {
+      const compResult = getDetailedIdType(createComponentId(42));
+      expect(compResult.type).toBe("component");
+      expect(compResult.componentId).toBeUndefined();
+      expect(compResult.targetId).toBeUndefined();
+
+      const entityResult = getDetailedIdType(createEntityId(ENTITY_ID_START + 100));
+      expect(entityResult.type).toBe("entity");
+      expect(entityResult.componentId).toBeUndefined();
+      expect(entityResult.targetId).toBeUndefined();
+
+      const entityRelationId = relation(createComponentId(5), createEntityId(ENTITY_ID_START + 200));
+      const entityRelationResult = getDetailedIdType(entityRelationId);
+      expect(entityRelationResult.type).toBe("entity-relation");
+      expect(entityRelationResult.componentId).toBe(createComponentId(5));
+      expect(entityRelationResult.targetId).toBe(createEntityId(ENTITY_ID_START + 200));
+
+      const compRelationId = relation(createComponentId(10), createComponentId(20));
+      const compRelationResult = getDetailedIdType(compRelationId);
+      expect(compRelationResult.type).toBe("component-relation");
+      expect(compRelationResult.componentId).toBe(createComponentId(10));
+      expect(compRelationResult.targetId).toBe(createComponentId(20));
+
+      const wildcardRelationId = relation(createComponentId(15), "*");
+      const wildcardRelationResult = getDetailedIdType(wildcardRelationId);
+      expect(wildcardRelationResult.type).toBe("wildcard-relation");
+      expect(wildcardRelationResult.componentId).toBe(createComponentId(15));
+      expect(wildcardRelationResult.targetId).toBe(0 as EntityId);
+
+      const invalidResult = getDetailedIdType(INVALID_COMPONENT_ID as EntityId);
+      expect(invalidResult.type).toBe("invalid");
+      expect(invalidResult.componentId).toBeUndefined();
+      expect(invalidResult.targetId).toBeUndefined();
+
+      const invalidRelationResult = getDetailedIdType(-999999 as EntityId);
+      expect(invalidRelationResult.type).toBe("invalid");
+      expect(invalidRelationResult.componentId).toBeUndefined();
+      expect(invalidRelationResult.targetId).toBeUndefined();
+    });
+  });
+
+  describe("ID Inspection", () => {
+    it("should inspect invalid component ID", () => {
+      expect(inspectEntityId(INVALID_COMPONENT_ID as EntityId)).toBe("Invalid Component ID (0)");
+    });
+
+    it("should inspect component IDs", () => {
+      expect(inspectEntityId(createComponentId(1))).toBe("Component ID (1)");
+      expect(inspectEntityId(createComponentId(42))).toBe("Component ID (42)");
+      expect(inspectEntityId(createComponentId(COMPONENT_ID_MAX))).toBe(`Component ID (${COMPONENT_ID_MAX})`);
+    });
+
+    it("should inspect entity IDs", () => {
+      expect(inspectEntityId(createEntityId(ENTITY_ID_START))).toBe(`Entity ID (${ENTITY_ID_START})`);
+      expect(inspectEntityId(createEntityId(10000))).toBe("Entity ID (10000)");
+    });
+
+    it("should inspect relation IDs with entities", () => {
+      const compId = createComponentId(5);
+      const entId = createEntityId(ENTITY_ID_START + 10);
+      const relationId = relation(compId, entId);
+
+      expect(inspectEntityId(relationId)).toBe("Relation ID: Component ID (5) -> Entity ID (1034)");
+    });
+
+    it("should inspect relation IDs with components", () => {
+      const compId1 = createComponentId(10);
+      const compId2 = createComponentId(20);
+      const relationId = relation(compId1, compId2);
+
+      expect(inspectEntityId(relationId)).toBe("Relation ID: Component ID (10) -> Component ID (20)");
+    });
+
+    it("should handle invalid relation IDs gracefully", () => {
+      const invalidRelationId = -999999 as EntityId;
+      expect(inspectEntityId(invalidRelationId)).toBe("Invalid Relation ID (-999999)");
+    });
+
+    it("should inspect wildcard relation IDs", () => {
+      const compId = createComponentId(15);
+      const relationId = relation(compId, "*");
+
+      expect(inspectEntityId(relationId)).toBe("Relation ID: Component ID (15) -> Wildcard (*)");
+    });
+  });
+
+  describe("Bit Operations Safety", () => {
+    it("should handle large entity IDs within safe integer range", () => {
+      const largeEntityId = (1 << 42) - 1 + ENTITY_ID_START;
+      expect(Number.isSafeInteger(largeEntityId)).toBe(true);
+
+      const compId = createComponentId(1023);
+      const relationId = relation(compId, largeEntityId as EntityId);
+      expect(Number.isSafeInteger(relationId)).toBe(true);
+
+      const decoded = decodeRelationId(relationId);
+      expect(decoded.componentId).toBe(compId);
+      expect(decoded.targetId).toBe(largeEntityId as EntityId);
+      expect(decoded.type).toBe("entity");
+    });
+  });
+});

package/src/__tests__/perf/comprehensive.perf.test.ts

@@ -0,0 +1,300 @@
+import { describe, expect, it } from "bun:test";
+import { component, relation, type EntityId } from "../../entity";
+import { World } from "../../world/world";
+
+function benchmark(label: string, warmupRounds: number, measuredRounds: number, fn: (round: number) => void): number {
+  const durations: number[] = [];
+
+  const totalRounds = warmupRounds + measuredRounds;
+  for (let round = 0; round < totalRounds; round++) {
+    const start = performance.now();
+    fn(round);
+    const duration = performance.now() - start;
+    if (round >= warmupRounds) {
+      durations.push(duration);
+    }
+  }
+
+  const average = durations.reduce((sum, duration) => sum + duration, 0) / durations.length;
+  console.log(
+    `${label}: avg ${average.toFixed(2)}ms after ${warmupRounds} warmup rounds (${durations
+      .map((d) => d.toFixed(2))
+      .join("ms, ")}ms per measured round)`,
+  );
+  return average;
+}
+
+describe("Comprehensive ECS performance benchmarks", () => {
+  /**
+   * Benchmark 1: Component set (no structural change) - hot path for data updates
+   * This is the most common operation: updating a component value without archetype migration
+   */
+  it("should handle many component value updates efficiently", () => {
+    const world = new World();
+    const Position = component<{ x: number; y: number }>();
+    const Velocity = component<{ vx: number; vy: number }>();
+
+    const entityCount = 10_000;
+    const entities: EntityId[] = [];
+    for (let i = 0; i < entityCount; i++) {
+      const entity = world.new();
+      entities.push(entity);
+      world.set(entity, Position, { x: i, y: i });
+      world.set(entity, Velocity, { vx: 1, vy: 1 });
+    }
+    world.sync();
+
+    // Single component update
+    const singleCompAvg = benchmark("10k entities: single component update + sync", 2, 6, (round) => {
+      for (let i = 0; i < entities.length; i++) {
+        world.set(entities[i]!, Position, { x: round, y: i });
+      }
+      world.sync();
+    });
+
+    // Two component update
+    const twoCompAvg = benchmark("10k entities: two component updates + sync", 2, 6, (round) => {
+      for (let i = 0; i < entities.length; i++) {
+        world.set(entities[i]!, Position, { x: round, y: i });
+        world.set(entities[i]!, Velocity, { vx: round, vy: i });
+      }
+      world.sync();
+    });
+
+    expect(singleCompAvg).toBeLessThan(300);
+    expect(twoCompAvg).toBeLessThan(500);
+  });
+
+  /**
+   * Benchmark 2: Structural archetype migrations - entities moving between archetypes
+   * These are more expensive than value updates because of array manipulation
+   */
+  it("should handle archetype migrations efficiently", () => {
+    const world = new World();
+    const Alive = component<void>();
+    const Dead = component<void>();
+
+    const entityCount = 4000;
+    const entities: EntityId[] = [];
+    for (let i = 0; i < entityCount; i++) {
+      const entity = world.new();
+      entities.push(entity);
+      world.set(entity, Alive);
+    }
+    world.sync();
+
+    // Add/remove components causing archetype migration
+    const migrationAvg = benchmark("4k entities: archetype migration (add/remove) + sync", 2, 6, (round) => {
+      if (round % 2 === 0) {
+        for (let i = 0; i < entities.length; i++) {
+          world.set(entities[i]!, Dead);
+        }
+      } else {
+        for (let i = 0; i < entities.length; i++) {
+          world.remove(entities[i]!, Dead);
+        }
+      }
+      world.sync();
+    });
+
+    expect(migrationAvg).toBeLessThan(300);
+  });
+
+  /**
+   * Benchmark 3: Query iteration - the inner loop of ECS systems
+   * This is the absolute hot path - should be very fast
+   */
+  it("should iterate over queries efficiently", () => {
+    const world = new World();
+    const Position = component<{ x: number; y: number }>();
+    const Velocity = component<{ vx: number; vy: number }>();
+
+    const entityCount = 10_000;
+    for (let i = 0; i < entityCount; i++) {
+      const entity = world.new();
+      world.set(entity, Position, { x: i, y: i });
+      world.set(entity, Velocity, { vx: 1, vy: 1 });
+    }
+    world.sync();
+
+    const movementQuery = world.createQuery([Position, Velocity]);
+
+    // Pure iteration (no writes)
+    const readAvg = benchmark("10k entities: forEach read-only query", 2, 6, () => {
+      let count = 0;
+      movementQuery.forEach([Position, Velocity], (_entity, _pos, _vel) => {
+        count++;
+      });
+      expect(count).toBe(entityCount);
+    });
+
+    // Read and modify in place (no sync needed for non-structural)
+    let sumX = 0;
+    const updateAvg = benchmark("10k entities: forEach query with accumulation", 2, 6, () => {
+      sumX = 0;
+      movementQuery.forEach([Position, Velocity], (_entity, pos, vel) => {
+        sumX += pos.x + vel.vx;
+      });
+    });
+
+    movementQuery.dispose();
+
+    console.log(`Sum X (to prevent optimization): ${sumX}`);
+    expect(readAvg).toBeLessThan(20);
+    expect(updateAvg).toBeLessThan(20);
+  });
+
+  /**
+   * Benchmark 4: Entity spawn and sync - creating entities
+   */
+  it("should spawn and sync entities efficiently", () => {
+    const world = new World();
+    const Position = component<{ x: number; y: number }>();
+    const Velocity = component<{ vx: number; vy: number }>();
+
+    const entityCount = 1000;
+
+    const spawnAvg = benchmark("1k entity spawn + 2 components + sync", 2, 6, () => {
+      const entities: EntityId[] = [];
+      for (let i = 0; i < entityCount; i++) {
+        const entity = world.new();
+        entities.push(entity);
+        world.set(entity, Position, { x: i, y: i });
+        world.set(entity, Velocity, { vx: 1, vy: 1 });
+      }
+      world.sync();
+      // Cleanup
+      for (const entity of entities) {
+        world.delete(entity);
+      }
+      world.sync();
+    });
+
+    expect(spawnAvg).toBeLessThan(150);
+  });
+
+  /**
+   * Benchmark 5: Mixed operations - realistic game loop simulation
+   * Some entities update, some spawn, some die - typical game scenario
+   */
+  it("should handle mixed operations in a realistic game loop", () => {
+    const world = new World();
+    const Position = component<{ x: number; y: number }>();
+    const Health = component<number>();
+    const Alive = component<void>();
+
+    const initialCount = 2000;
+    const entities: EntityId[] = [];
+
+    for (let i = 0; i < initialCount; i++) {
+      const entity = world.new();
+      entities.push(entity);
+      world.set(entity, Position, { x: i, y: i });
+      world.set(entity, Health, 100);
+      world.set(entity, Alive);
+    }
+    world.sync();
+
+    const movementQuery = world.createQuery([Position, Health]);
+
+    const mixedAvg = benchmark("2k entities: mixed ops (update 90%, spawn 5%, delete 5%) + sync", 2, 6, (round) => {
+      const deleteCount = Math.floor(entities.length * 0.05);
+      const spawnCount = deleteCount;
+
+      // Update most entities
+      movementQuery.forEach([Position, Health], (entity, pos, health) => {
+        world.set(entity, Position, { x: pos.x + 1, y: pos.y + 1 });
+        world.set(entity, Health, health - 1);
+      });
+
+      // Delete some
+      for (let i = 0; i < deleteCount && entities.length > 0; i++) {
+        const idx = (round * deleteCount + i) % entities.length;
+        world.delete(entities[idx]!);
+        entities.splice(idx, 1);
+      }
+
+      // Spawn some
+      for (let i = 0; i < spawnCount; i++) {
+        const entity = world.new();
+        entities.push(entity);
+        world.set(entity, Position, { x: i, y: i });
+        world.set(entity, Health, 100);
+        world.set(entity, Alive);
+      }
+
+      world.sync();
+    });
+
+    movementQuery.dispose();
+    expect(mixedAvg).toBeLessThan(300);
+  });
+
+  /**
+   * Benchmark 6: CommandBuffer grouping overhead
+   * Tests the overhead of the Map grouping in execute()
+   * This specifically targets the new Map() allocation per sync call
+   */
+  it("should execute command buffer efficiently with many commands", () => {
+    const world = new World();
+    const A = component<number>();
+    const B = component<number>();
+    const C = component<number>();
+
+    const entityCount = 5000;
+    const entities: EntityId[] = [];
+    for (let i = 0; i < entityCount; i++) {
+      const entity = world.new();
+      entities.push(entity);
+      world.set(entity, A, i);
+      world.set(entity, B, i * 2);
+    }
+    world.sync();
+
+    // Many commands per sync - tests command buffer grouping
+    const manyCommandsAvg = benchmark("5k entities: 3 commands each + sync (15k total commands)", 2, 6, (round) => {
+      for (let i = 0; i < entities.length; i++) {
+        world.set(entities[i]!, A, round + i);
+        world.set(entities[i]!, B, round - i);
+        world.set(entities[i]!, C, round * i);
+      }
+      world.sync();
+    });
+
+    expect(manyCommandsAvg).toBeLessThan(600);
+  });
+
+  /**
+   * Benchmark 7: dontFragment relation updates (the existing benchmark scenario)
+   */
+  it("should handle dontFragment exclusive relation flips efficiently", () => {
+    const world = new World();
+    const Position = component<{ x: number; y: number }>();
+    const ChildOf = component({ dontFragment: true, exclusive: true });
+
+    const parentA = world.new();
+    const parentB = world.new();
+
+    const entityCount = 4000;
+    const entities: EntityId[] = [];
+    for (let i = 0; i < entityCount; i++) {
+      const entity = world.new();
+      entities.push(entity);
+      world.set(entity, Position, { x: i, y: i });
+      world.set(entity, relation(ChildOf, parentA));
+    }
+    world.sync();
+
+    const relationFlipAvg = benchmark("4k entities: exclusive dontFragment relation flip + sync", 2, 8, (round) => {
+      const target = round % 2 === 0 ? parentB : parentA;
+      for (let i = 0; i < entities.length; i++) {
+        world.set(entities[i]!, relation(ChildOf, target));
+      }
+      world.sync();
+    });
+
+    expect(world.query([Position]).length).toBe(entityCount);
+    expect(world.query([relation(ChildOf, "*")]).length).toBe(entityCount);
+    expect(relationFlipAvg).toBeLessThan(350);
+  });
+});

package/src/__tests__/perf/sync-hotpath.perf.test.ts

@@ -0,0 +1,79 @@
+import { describe, expect, it } from "bun:test";
+import { component, relation, type EntityId } from "../../entity";
+import { World } from "../../world/world";
+
+function benchmark(label: string, warmupRounds: number, measuredRounds: number, fn: (round: number) => void): number {
+  const durations: number[] = [];
+
+  const totalRounds = warmupRounds + measuredRounds;
+  for (let round = 0; round < totalRounds; round++) {
+    const start = performance.now();
+    fn(round);
+    const duration = performance.now() - start;
+    if (round >= warmupRounds) {
+      durations.push(duration);
+    }
+  }
+
+  const average = durations.reduce((sum, duration) => sum + duration, 0) / durations.length;
+  console.log(
+    `${label}: avg ${average.toFixed(2)}ms after ${warmupRounds} warmup rounds (${durations
+      .map((d) => d.toFixed(2))
+      .join("ms, ")}ms per measured round)`,
+  );
+  return average;
+}
+
+describe("World sync hot-path performance", () => {
+  it("should keep stable sync throughput for frequent set/remove patterns", () => {
+    const world = new World();
+    const Position = component<{ x: number; y: number }>();
+    const ChildOf = component({ dontFragment: true, exclusive: true });
+
+    const parentA = world.new();
+    const parentB = world.new();
+
+    const entityCount = 4000;
+    const entities: EntityId[] = [];
+
+    for (let i = 0; i < entityCount; i++) {
+      const entity = world.new();
+      entities.push(entity);
+      world.set(entity, Position, { x: i, y: i });
+      world.set(entity, relation(ChildOf, parentA));
+    }
+    world.sync();
+
+    const warmupRounds = 2;
+    const measuredRounds = 8;
+
+    const positionAverage = benchmark("position update + sync", warmupRounds, measuredRounds, (round) => {
+      for (let i = 0; i < entities.length; i++) {
+        const entity = entities[i]!;
+        world.set(entity, Position, { x: round, y: i });
+      }
+      world.sync();
+    });
+
+    const relationAverage = benchmark(
+      "exclusive dontFragment relation flip + sync",
+      warmupRounds,
+      measuredRounds,
+      (round) => {
+        const target = round % 2 === 0 ? parentB : parentA;
+        for (let i = 0; i < entities.length; i++) {
+          const entity = entities[i]!;
+          world.set(entity, relation(ChildOf, target));
+        }
+        world.sync();
+      },
+    );
+
+    expect(world.query([Position]).length).toBe(entityCount);
+    expect(world.query([relation(ChildOf, "*")]).length).toBe(entityCount);
+
+    // Guard against pathological regressions while keeping CI variance tolerance.
+    expect(positionAverage).toBeLessThan(250);
+    expect(relationAverage).toBeLessThan(350);
+  });
+});