Enforced consistent use of expect.toHaveLength

again, gives more info than "expected 1 to be 2"

test/abilities/arena_trap.test.ts

@@ -50,7 +50,7 @@ describe("Abilities - Arena Trap", () => {
 
     await game.classicMode.startBattle();
 
-    expect(game.scene.getEnemyField().length).toBe(2);
+    expect(game.scene.getEnemyField()).toHaveLength(2);
   });
 
   /**

test/abilities/illuminate.test.ts

@@ -49,6 +49,6 @@ describe("Abilities - Illuminate", () => {
 
     await game.classicMode.startBattle();
 
-    expect(game.scene.getEnemyField().length).toBe(2);
+    expect(game.scene.getEnemyField()).toHaveLength(2);
   });
 });

test/abilities/imposter.test.ts

@@ -60,7 +60,7 @@ describe("Abilities - Imposter", () => {
     const playerMoveset = player.getMoveset();
     const enemyMoveset = player.getMoveset();
 
-    expect(playerMoveset.length).toBe(enemyMoveset.length);
+    expect(playerMoveset).toHaveLength(enemyMoveset.length);
     for (let i = 0; i < playerMoveset.length && i < enemyMoveset.length; i++) {
       expect(playerMoveset[i]?.moveId).toBe(enemyMoveset[i]?.moveId);
     }
@@ -68,7 +68,7 @@ describe("Abilities - Imposter", () => {
     const playerTypes = player.getTypes();
     const enemyTypes = enemy.getTypes();
 
-    expect(playerTypes.length).toBe(enemyTypes.length);
+    expect(playerTypes).toHaveLength(enemyTypes.length);
     for (let i = 0; i < playerTypes.length && i < enemyTypes.length; i++) {
       expect(playerTypes[i]).toBe(enemyTypes[i]);
     }

test/abilities/moody.test.ts

@@ -45,7 +45,7 @@ describe("Abilities - Moody", () => {
     );
 
     expect(changedStats).toBeTruthy();
-    expect(changedStats.length).toBe(2);
+    expect(changedStats).toHaveLength(2);
     expect(changedStats[0] !== changedStats[1]).toBeTruthy();
   });
 
@@ -64,7 +64,7 @@ describe("Abilities - Moody", () => {
     const increasedStat = EFFECTIVE_STATS.filter(s => playerPokemon.getStatStage(s) === -4);
 
     expect(increasedStat).toBeTruthy();
-    expect(increasedStat.length).toBe(1);
+    expect(increasedStat).toHaveLength(1);
   });
 
   it("should only decrease one stat stage by 1 stage if all stat stages are at 6", async () => {
@@ -82,6 +82,6 @@ describe("Abilities - Moody", () => {
     const decreasedStat = EFFECTIVE_STATS.filter(s => playerPokemon.getStatStage(s) === 5);
 
     expect(decreasedStat).toBeTruthy();
-    expect(decreasedStat.length).toBe(1);
+    expect(decreasedStat).toHaveLength(1);
   });
 });

test/abilities/no_guard.test.ts

@@ -58,6 +58,6 @@ describe("Abilities - No Guard", () => {
 
     await game.classicMode.startBattle();
 
-    expect(game.scene.getEnemyField().length).toBe(2);
+    expect(game.scene.getEnemyField()).toHaveLength(2);
   });
 });

test/abilities/perish_body.test.ts

@@ -74,14 +74,14 @@ describe("Abilities - Perish Song", () => {
     await game.toNextTurn();
 
     const cursola = game.scene.getPlayerPokemon();
-    expect(cursola?.summonData.tags.length).toBe(0);
+    expect(cursola?.summonData.tags).toHaveLength(0);
     expect(magikarp?.summonData.tags[0].turnCount).toBe(2);
 
     game.move.select(Moves.SPLASH);
     await game.forceEnemyMove(Moves.AQUA_JET);
     await game.toNextTurn();
 
-    expect(cursola?.summonData.tags.length).toBe(0);
+    expect(cursola?.summonData.tags).toHaveLength(0);
     expect(magikarp?.summonData.tags[0].turnCount).toBe(1);
   });
 
@@ -99,14 +99,14 @@ describe("Abilities - Perish Song", () => {
 
     const magikarp = game.scene.getEnemyPokemon();
     expect(cursola?.summonData.tags[0].turnCount).toBe(3);
-    expect(magikarp?.summonData.tags.length).toBe(0);
+    expect(magikarp?.summonData.tags).toHaveLength(0);
 
     game.move.select(Moves.SPLASH);
     await game.forceEnemyMove(Moves.AQUA_JET);
     await game.toNextTurn();
 
     expect(cursola?.summonData.tags[0].turnCount).toBe(2);
-    expect(magikarp?.summonData.tags.length).toBe(1);
+    expect(magikarp?.summonData.tags).toHaveLength(1);
     expect(magikarp?.summonData.tags[0].turnCount).toBe(3);
   });
 });

test/field/pokemon.test.ts

@@ -134,7 +134,7 @@ describe("Spec - Pokemon", () => {
 
       const types = pokemon.getTypes();
       expect(types[0]).toBe(PokemonType.PSYCHIC);
-      expect(types.length).toBe(1);
+      expect(types).toHaveLength(1);
     });
 
     it("Fusing mons with one and two types", async () => {

test/inputs/inputs.test.ts

@@ -33,56 +33,56 @@ describe("Inputs", () => {
 
   it("Mobile - test touch holding for 1ms - 1 input", async () => {
     await game.inputsHandler.pressTouch("dpadUp", 1);
-    expect(game.inputsHandler.log.length).toBe(1);
+    expect(game.inputsHandler.log).toHaveLength(1);
   });
 
   it("Mobile - test touch holding for 200ms - 1 input", async () => {
     await game.inputsHandler.pressTouch("dpadUp", 200);
-    expect(game.inputsHandler.log.length).toBe(1);
+    expect(game.inputsHandler.log).toHaveLength(1);
   });
 
   it("Mobile - test touch holding for 300ms - 2 input", async () => {
     await game.inputsHandler.pressTouch("dpadUp", 300);
-    expect(game.inputsHandler.log.length).toBe(2);
+    expect(game.inputsHandler.log).toHaveLength(2);
   });
 
   it("Mobile - test touch holding for 1000ms - 4 input", async () => {
     await game.inputsHandler.pressTouch("dpadUp", 1050);
-    expect(game.inputsHandler.log.length).toBe(5);
+    expect(game.inputsHandler.log).toHaveLength(5);
   });
 
   it("keyboard - test input holding for 200ms - 1 input", async () => {
     await game.inputsHandler.pressKeyboardKey(cfg_keyboard_qwerty.deviceMapping.KEY_ARROW_UP, 200);
-    expect(game.inputsHandler.log.length).toBe(1);
+    expect(game.inputsHandler.log).toHaveLength(1);
   });
 
   it("keyboard - test input holding for 300ms - 2 input", async () => {
     await game.inputsHandler.pressKeyboardKey(cfg_keyboard_qwerty.deviceMapping.KEY_ARROW_UP, 300);
-    expect(game.inputsHandler.log.length).toBe(2);
+    expect(game.inputsHandler.log).toHaveLength(2);
   });
 
   it("keyboard - test input holding for 1000ms - 4 input", async () => {
     await game.inputsHandler.pressKeyboardKey(cfg_keyboard_qwerty.deviceMapping.KEY_ARROW_UP, 1050);
-    expect(game.inputsHandler.log.length).toBe(5);
+    expect(game.inputsHandler.log).toHaveLength(5);
   });
 
   it("gamepad - test input holding for 1ms - 1 input", async () => {
     await game.inputsHandler.pressGamepadButton(pad_xbox360.deviceMapping.RC_S, 1);
-    expect(game.inputsHandler.log.length).toBe(1);
+    expect(game.inputsHandler.log).toHaveLength(1);
   });
 
   it("gamepad - test input holding for 200ms - 1 input", async () => {
     await game.inputsHandler.pressGamepadButton(pad_xbox360.deviceMapping.RC_S, 200);
-    expect(game.inputsHandler.log.length).toBe(1);
+    expect(game.inputsHandler.log).toHaveLength(1);
   });
 
   it("gamepad - test input holding for 300ms - 2 input", async () => {
     await game.inputsHandler.pressGamepadButton(pad_xbox360.deviceMapping.RC_S, 300);
-    expect(game.inputsHandler.log.length).toBe(2);
+    expect(game.inputsHandler.log).toHaveLength(2);
   });
 
   it("gamepad - test input holding for 1000ms - 4 input", async () => {
     await game.inputsHandler.pressGamepadButton(pad_xbox360.deviceMapping.RC_S, 1050);
-    expect(game.inputsHandler.log.length).toBe(5);
+    expect(game.inputsHandler.log).toHaveLength(5);
   });
 });

test/items/double_battle_chance_booster.test.ts

@@ -31,7 +31,7 @@ describe("Items - Double Battle Chance Boosters", () => {
 
     await game.classicMode.startBattle();
 
-    expect(game.scene.getEnemyField().length).toBe(2);
+    expect(game.scene.getEnemyField()).toHaveLength(2);
   });
 
   it("should guarantee double boss battle with 3 unique tiers", async () => {
@@ -41,7 +41,7 @@ describe("Items - Double Battle Chance Boosters", () => {
 
     const enemyField = game.scene.getEnemyField();
 
-    expect(enemyField.length).toBe(2);
+    expect(enemyField).toHaveLength(2);
     expect(enemyField[0].isBoss()).toBe(true);
     expect(enemyField[1].isBoss()).toBe(true);
   });

test/moves/baddy_bad.test.ts

@@ -36,6 +36,6 @@ describe("Moves - Baddy Bad", () => {
     game.move.select(Moves.BADDY_BAD);
     await game.phaseInterceptor.to("BerryPhase");
 
-    expect(game.scene.arena.tags.length).toBe(0);
+    expect(game.scene.arena.tags).toHaveLength(0);
   });
 });

test/moves/destiny_bond.test.ts

@@ -249,6 +249,6 @@ describe("Moves - Destiny Bond", () => {
     const revSeeds = game.scene
       .getModifiers(PokemonInstantReviveModifier)
       .filter(m => m.pokemonId === playerPokemon?.id);
-    expect(revSeeds.length).toBe(1);
+    expect(revSeeds).toHaveLength(1);
   });
 });

test/moves/dragon_tail.test.ts

@@ -156,7 +156,7 @@ describe("Moves - Dragon Tail", () => {
     // Make sure the enemy has a fainted Pokemon in their party and not on the field
     const faintedEnemy = game.scene.getEnemyParty().find(p => !p.isAllowedInBattle());
     expect(faintedEnemy).toBeDefined();
-    expect(game.scene.getEnemyField().length).toBe(1);
+    expect(game.scene.getEnemyField()).toHaveLength(1);
   });
 
   it("should not cause a softlock when activating an opponent trainer's reviver seed", async () => {
@@ -174,7 +174,7 @@ describe("Moves - Dragon Tail", () => {
     const enemy = game.scene.getEnemyPokemon()!;
     expect(enemy).toBeDefined();
     expect(enemy.hp).toBe(Math.floor(enemy.getMaxHp() / 2));
-    expect(game.scene.getEnemyField().length).toBe(1);
+    expect(game.scene.getEnemyField()).toHaveLength(1);
   });
 
   it("should not cause a softlock when activating a player's reviver seed", async () => {
@@ -192,7 +192,7 @@ describe("Moves - Dragon Tail", () => {
     const dratini = game.scene.getPlayerPokemon()!;
     expect(dratini).toBeDefined();
     expect(dratini.hp).toBe(Math.floor(dratini.getMaxHp() / 2));
-    expect(game.scene.getPlayerField().length).toBe(1);
+    expect(game.scene.getPlayerField()).toHaveLength(1);
   });
 
   it("should force switches randomly", async () => {

test/moves/focus_punch.test.ts

@@ -51,12 +51,12 @@ describe("Moves - Focus Punch", () => {
     await game.phaseInterceptor.to(MessagePhase);
 
     expect(enemyPokemon.hp).toBe(enemyStartingHp);
-    expect(leadPokemon.getMoveHistory().length).toBe(0);
+    expect(leadPokemon.getMoveHistory()).toHaveLength(0);
 
     await game.phaseInterceptor.to(BerryPhase, false);
 
     expect(enemyPokemon.hp).toBeLessThan(enemyStartingHp);
-    expect(leadPokemon.getMoveHistory().length).toBe(1);
+    expect(leadPokemon.getMoveHistory()).toHaveLength(1);
     expect(leadPokemon.turnData.totalDamageDealt).toBe(enemyStartingHp - enemyPokemon.hp);
   });
 
@@ -75,12 +75,12 @@ describe("Moves - Focus Punch", () => {
     await game.phaseInterceptor.to(MessagePhase);
 
     expect(enemyPokemon.hp).toBe(enemyStartingHp);
-    expect(leadPokemon.getMoveHistory().length).toBe(0);
+    expect(leadPokemon.getMoveHistory()).toHaveLength(0);
 
     await game.phaseInterceptor.to(BerryPhase, false);
 
     expect(enemyPokemon.hp).toBe(enemyStartingHp);
-    expect(leadPokemon.getMoveHistory().length).toBe(1);
+    expect(leadPokemon.getMoveHistory()).toHaveLength(1);
     expect(leadPokemon.turnData.totalDamageDealt).toBe(0);
   });
 
@@ -96,11 +96,11 @@ describe("Moves - Focus Punch", () => {
 
     await game.phaseInterceptor.to(MessagePhase); // Header message
 
-    expect(leadPokemon.getMoveHistory().length).toBe(0);
+    expect(leadPokemon.getMoveHistory()).toHaveLength(0);
 
     await game.phaseInterceptor.to(BerryPhase, false);
 
-    expect(leadPokemon.getMoveHistory().length).toBe(1);
+    expect(leadPokemon.getMoveHistory()).toHaveLength(1);
     expect(enemyPokemon.hp).toBe(enemyPokemon.getMaxHp());
   });
 

test/moves/instruct.test.ts

@@ -118,7 +118,7 @@ describe("Moves - Instruct", () => {
     await game.phaseInterceptor.to("BerryPhase");
 
     instructSuccess(enemy, Moves.GIGATON_HAMMER);
-    expect(game.scene.getPlayerPokemon()!.turnData.attacksReceived.length).toBe(2);
+    expect(game.scene.getPlayerPokemon()!.turnData.attacksReceived).toHaveLength(2);
   });
 
   it("should add moves to move queue for copycat", async () => {
@@ -135,7 +135,7 @@ describe("Moves - Instruct", () => {
 
     instructSuccess(enemy1, Moves.WATER_GUN);
     // amoonguss gets hit by water gun thrice; once by original attack, once by instructed use and once by copycat
-    expect(game.scene.getPlayerPokemon()!.turnData.attacksReceived.length).toBe(3);
+    expect(game.scene.getPlayerPokemon()!.turnData.attacksReceived).toHaveLength(3);
   });
 
   it("should respect enemy's status condition", async () => {
@@ -175,7 +175,7 @@ describe("Moves - Instruct", () => {
 
     const playerMoves = game.scene.getPlayerPokemon()!.getLastXMoves(-1)!;
     expect(playerMoves[0].result).toBe(MoveResult.FAIL);
-    expect(enemyPokemon.getMoveHistory().length).toBe(1);
+    expect(enemyPokemon.getMoveHistory()).toHaveLength(1);
   });
 
   it("should redirect attacking moves if enemy faints", async () => {
@@ -218,7 +218,7 @@ describe("Moves - Instruct", () => {
     // fiery dance triggered dancer successfully for a total of 4 hits
     // Enemy level is set to a high value so that it does not faint even after all 4 hits
     instructSuccess(volcarona, Moves.FIERY_DANCE);
-    expect(game.scene.getEnemyField()[0].turnData.attacksReceived.length).toBe(4);
+    expect(game.scene.getEnemyField()[0].turnData.attacksReceived).toHaveLength(4);
   });
 
   it("should not repeat move when switching out", async () => {
@@ -492,14 +492,14 @@ describe("Moves - Instruct", () => {
     await game.setTurnOrder([BattlerIndex.PLAYER, BattlerIndex.ENEMY]);
     await game.phaseInterceptor.to("BerryPhase");
 
-    expect(bulbasaur.turnData.attacksReceived.length).toBe(10);
+    expect(bulbasaur.turnData.attacksReceived).toHaveLength(10);
 
     await game.toNextTurn();
     game.move.select(Moves.INSTRUCT);
     await game.setTurnOrder([BattlerIndex.ENEMY, BattlerIndex.PLAYER]);
     await game.phaseInterceptor.to("BerryPhase");
 
-    expect(bulbasaur.turnData.attacksReceived.length).toBe(10);
+    expect(bulbasaur.turnData.attacksReceived).toHaveLength(10);
   });
 
   it("should cause multi-hit moves to hit the appropriate number of times in doubles", async () => {
@@ -526,7 +526,7 @@ describe("Moves - Instruct", () => {
     await game.setTurnOrder([BattlerIndex.PLAYER, BattlerIndex.PLAYER_2, BattlerIndex.ENEMY, BattlerIndex.ENEMY_2]);
     await game.phaseInterceptor.to("BerryPhase");
 
-    expect(ivysaur.turnData.attacksReceived.length).toBe(15);
+    expect(ivysaur.turnData.attacksReceived).toHaveLength(15);
 
     await game.toNextTurn();
     game.move.select(Moves.INSTRUCT, BattlerIndex.PLAYER, BattlerIndex.ENEMY);
@@ -536,6 +536,6 @@ describe("Moves - Instruct", () => {
     await game.setTurnOrder([BattlerIndex.ENEMY, BattlerIndex.ENEMY_2, BattlerIndex.PLAYER, BattlerIndex.PLAYER_2]);
     await game.phaseInterceptor.to("BerryPhase");
 
-    expect(ivysaur.turnData.attacksReceived.length).toBe(15);
+    expect(ivysaur.turnData.attacksReceived).toHaveLength(15);
   });
 });

test/moves/roost.test.ts

@@ -58,7 +58,7 @@ describe("Moves - Roost", () => {
     // Should only be normal type, and NOT flying type
     let playerPokemonTypes = playerPokemon.getTypes();
     expect(playerPokemonTypes[0]).toBe(PokemonType.NORMAL);
-    expect(playerPokemonTypes.length).toBe(1);
+    expect(playerPokemonTypes).toHaveLength(1);
     expect(playerPokemon.isGrounded()).toBeTruthy();
 
     await game.phaseInterceptor.to(TurnEndPhase);
@@ -67,7 +67,7 @@ describe("Moves - Roost", () => {
     playerPokemonTypes = playerPokemon.getTypes();
     expect(playerPokemon.hp).toBeLessThan(playerPokemonStartingHP);
     expect(playerPokemonTypes[0]).toBe(PokemonType.NORMAL);
-    expect(playerPokemonTypes.length).toBe(1);
+    expect(playerPokemonTypes).toHaveLength(1);
     expect(playerPokemon.isGrounded()).toBeTruthy();
   });
 
@@ -106,7 +106,7 @@ describe("Moves - Roost", () => {
     // Should only be pure fighting type and grounded
     let playerPokemonTypes = playerPokemon.getTypes();
     expect(playerPokemonTypes[0]).toBe(PokemonType.FIGHTING);
-    expect(playerPokemonTypes.length).toBe(1);
+    expect(playerPokemonTypes).toHaveLength(1);
     expect(playerPokemon.isGrounded()).toBeTruthy();
 
     await game.phaseInterceptor.to(TurnEndPhase);
@@ -131,7 +131,7 @@ describe("Moves - Roost", () => {
     // Should only be pure eletric type and grounded
     let playerPokemonTypes = playerPokemon.getTypes();
     expect(playerPokemonTypes[0]).toBe(PokemonType.ELECTRIC);
-    expect(playerPokemonTypes.length).toBe(1);
+    expect(playerPokemonTypes).toHaveLength(1);
     expect(playerPokemon.isGrounded()).toBeFalsy();
 
     await game.phaseInterceptor.to(TurnEndPhase);
@@ -155,7 +155,7 @@ describe("Moves - Roost", () => {
     // Should only be pure flying type after burn up
     let playerPokemonTypes = playerPokemon.getTypes();
     expect(playerPokemonTypes[0]).toBe(PokemonType.FLYING);
-    expect(playerPokemonTypes.length).toBe(1);
+    expect(playerPokemonTypes).toHaveLength(1);
 
     await game.phaseInterceptor.to(TurnEndPhase);
     game.move.select(Moves.ROOST);
@@ -166,7 +166,7 @@ describe("Moves - Roost", () => {
     playerPokemonTypes = playerPokemon.getTypes();
     expect(playerPokemon.getTag(BattlerTagType.ROOSTED)).toBeDefined();
     expect(playerPokemonTypes[0]).toBe(PokemonType.UNKNOWN);
-    expect(playerPokemonTypes.length).toBe(1);
+    expect(playerPokemonTypes).toHaveLength(1);
     expect(playerPokemon.isGrounded()).toBeTruthy();
 
     await game.phaseInterceptor.to(TurnEndPhase);
@@ -175,7 +175,7 @@ describe("Moves - Roost", () => {
     playerPokemonTypes = playerPokemon.getTypes();
     expect(playerPokemon.hp).toBeLessThan(playerPokemonStartingHP);
     expect(playerPokemonTypes[0]).toBe(PokemonType.FLYING);
-    expect(playerPokemonTypes.length).toBe(1);
+    expect(playerPokemonTypes).toHaveLength(1);
     expect(playerPokemon.isGrounded()).toBeFalsy();
   });
 
@@ -191,7 +191,7 @@ describe("Moves - Roost", () => {
     // Should only be pure flying type after burn up
     let playerPokemonTypes = playerPokemon.getTypes();
     expect(playerPokemonTypes[0]).toBe(PokemonType.FLYING);
-    expect(playerPokemonTypes.length).toBe(1);
+    expect(playerPokemonTypes).toHaveLength(1);
 
     await game.phaseInterceptor.to(TurnEndPhase);
     game.move.select(Moves.ROOST);
@@ -202,7 +202,7 @@ describe("Moves - Roost", () => {
     playerPokemonTypes = playerPokemon.getTypes();
     expect(playerPokemon.getTag(BattlerTagType.ROOSTED)).toBeDefined();
     expect(playerPokemonTypes[0]).toBe(PokemonType.UNKNOWN);
-    expect(playerPokemonTypes.length).toBe(1);
+    expect(playerPokemonTypes).toHaveLength(1);
     expect(playerPokemon.isGrounded()).toBeTruthy();
 
     await game.phaseInterceptor.to(TurnEndPhase);
@@ -211,7 +211,7 @@ describe("Moves - Roost", () => {
     playerPokemonTypes = playerPokemon.getTypes();
     expect(playerPokemon.hp).toBeLessThan(playerPokemonStartingHP);
     expect(playerPokemonTypes[0]).toBe(PokemonType.FLYING);
-    expect(playerPokemonTypes.length).toBe(1);
+    expect(playerPokemonTypes).toHaveLength(1);
     expect(playerPokemon.isGrounded()).toBeFalsy();
   });
 
@@ -229,7 +229,7 @@ describe("Moves - Roost", () => {
 
     let playerPokemonTypes = playerPokemon.getTypes();
     expect(playerPokemonTypes[0]).toBe(PokemonType.FIRE);
-    expect(playerPokemonTypes.length).toBe(1);
+    expect(playerPokemonTypes).toHaveLength(1);
     expect(playerPokemon.isGrounded()).toBeTruthy();
 
     await game.phaseInterceptor.to(TurnEndPhase);
@@ -239,7 +239,7 @@ describe("Moves - Roost", () => {
     expect(playerPokemonTypes.filter(type => type === PokemonType.FLYING)).toHaveLength(1);
     expect(playerPokemonTypes.filter(type => type === PokemonType.FIRE)).toHaveLength(1);
     expect(playerPokemonTypes.filter(type => type === PokemonType.GHOST)).toHaveLength(1);
-    expect(playerPokemonTypes.length).toBe(3);
+    expect(playerPokemonTypes).toHaveLength(3);
     expect(playerPokemon.isGrounded()).toBeFalsy();
   });
 });

test/moves/shed_tail.test.ts

@@ -56,7 +56,7 @@ describe("Moves - Shed Tail", () => {
     await game.classicMode.startBattle([Species.MAGIKARP]);
 
     const magikarp = game.scene.getPlayerPokemon()!;
-    expect(game.scene.getPlayerParty().length).toBe(1);
+    expect(game.scene.getPlayerParty()).toHaveLength(1);
 
     game.move.select(Moves.SHED_TAIL);
 

test/moves/substitute.test.ts

@@ -309,7 +309,7 @@ describe("Moves - Substitute", () => {
 
     await game.phaseInterceptor.to("BerryPhase", false);
 
-    expect(leadPokemon.getHeldItems().length).toBe(1);
+    expect(leadPokemon.getHeldItems()).toHaveLength(1);
   });
 
   it("should prevent the user's items from being removed", async () => {
@@ -326,7 +326,7 @@ describe("Moves - Substitute", () => {
 
     await game.phaseInterceptor.to("MoveEndPhase", false);
 
-    expect(enemyPokemon.getHeldItems().length).toBe(enemyNumItems);
+    expect(enemyPokemon.getHeldItems()).toHaveLength(enemyNumItems);
   });
 
   it("move effect should prevent the user's berries from being stolen and eaten", async () => {
@@ -346,7 +346,7 @@ describe("Moves - Substitute", () => {
 
     await game.phaseInterceptor.to("BerryPhase", false);
 
-    expect(leadPokemon.getHeldItems().length).toBe(1);
+    expect(leadPokemon.getHeldItems()).toHaveLength(1);
     expect(enemyPokemon.hp).toBe(enemyPostAttackHp);
   });
 

test/moves/toxic_spikes.test.ts

@@ -102,7 +102,7 @@ describe("Moves - Toxic Spikes", () => {
 
     expect(muk.isFullHp()).toBe(true);
     expect(muk.status?.effect).toBeUndefined();
-    expect(game.scene.arena.tags.length).toBe(0);
+    expect(game.scene.arena.tags).toHaveLength(0);
   });
 
   it("shouldn't create multiple layers per use in doubles", async () => {

test/mystery-encounter/encounters/a-trainers-test-encounter.test.ts

@@ -69,7 +69,7 @@ describe("A Trainer's Test - Mystery Encounter", () => {
     expect(ATrainersTestEncounter.dialogue.encounterOptionsDialogue?.title).toBe(`${namespace}:title`);
     expect(ATrainersTestEncounter.dialogue.encounterOptionsDialogue?.description).toBe(`${namespace}:description`);
     expect(ATrainersTestEncounter.dialogue.encounterOptionsDialogue?.query).toBe(`${namespace}:query`);
-    expect(ATrainersTestEncounter.options.length).toBe(2);
+    expect(ATrainersTestEncounter.options).toHaveLength(2);
   });
 
   it("should initialize fully ", async () => {
@@ -107,7 +107,7 @@ describe("A Trainer's Test - Mystery Encounter", () => {
 
       const enemyField = scene.getEnemyField();
       expect(scene.getCurrentPhase()?.constructor.name).toBe(CommandPhase.name);
-      expect(enemyField.length).toBe(1);
+      expect(enemyField).toHaveLength(1);
       expect(scene.currentBattle.trainer).toBeDefined();
       expect(
         [
@@ -167,7 +167,7 @@ describe("A Trainer's Test - Mystery Encounter", () => {
       await runMysteryEncounterToEnd(game, 2);
 
       const partyHealPhases = phaseSpy.mock.calls.filter(p => p[0] instanceof PartyHealPhase).map(p => p[0]);
-      expect(partyHealPhases.length).toBe(1);
+      expect(partyHealPhases).toHaveLength(1);
     });
 
     it("Should reward the player with a Rare egg", async () => {

test/mystery-encounter/encounters/absolute-avarice-encounter.test.ts

@@ -66,7 +66,7 @@ describe("Absolute Avarice - Mystery Encounter", () => {
     expect(AbsoluteAvariceEncounter.dialogue.encounterOptionsDialogue?.title).toBe(`${namespace}:title`);
     expect(AbsoluteAvariceEncounter.dialogue.encounterOptionsDialogue?.description).toBe(`${namespace}:description`);
     expect(AbsoluteAvariceEncounter.dialogue.encounterOptionsDialogue?.query).toBe(`${namespace}:query`);
-    expect(AbsoluteAvariceEncounter.options.length).toBe(3);
+    expect(AbsoluteAvariceEncounter.options).toHaveLength(3);
   });
 
   it("should not spawn outside of proper biomes", async () => {
@@ -106,7 +106,7 @@ describe("Absolute Avarice - Mystery Encounter", () => {
     await game.runToMysteryEncounter(MysteryEncounterType.ABSOLUTE_AVARICE, defaultParty);
 
     expect(scene.currentBattle?.mysteryEncounter?.encounterType).toBe(MysteryEncounterType.ABSOLUTE_AVARICE);
-    expect(scene.modifiers?.length).toBe(0);
+    expect(scene.modifiers).toHaveLength(0);
   });
 
   describe("Option 1 - Fight the Greedent", () => {
@@ -133,15 +133,15 @@ describe("Absolute Avarice - Mystery Encounter", () => {
 
       const enemyField = scene.getEnemyField();
       expect(scene.getCurrentPhase()?.constructor.name).toBe(CommandPhase.name);
-      expect(enemyField.length).toBe(1);
+      expect(enemyField).toHaveLength(1);
       expect(enemyField[0].species.speciesId).toBe(Species.GREEDENT);
       const moveset = enemyField[0].moveset.map(m => m.moveId);
-      expect(moveset?.length).toBe(4);
+      expect(moveset).toHaveLength(4);
-      expect(moveset).toEqual([Moves.THRASH, Moves.CRUNCH, Moves.BODY_PRESS, Moves.SLACK_OFF]);
+      expect(moveset).toEqual([Moves.THRASH, Moves.BODY_PRESS, Moves.STUFF_CHEEKS, Moves.CRUNCH]);
 
       const movePhases = phaseSpy.mock.calls.filter(p => p[0] instanceof MovePhase).map(p => p[0]);
-      expect(movePhases.length).toBe(1);
+      expect(movePhases).toHaveLength(1);
-      expect(movePhases.filter(p => (p as MovePhase).move.moveId === Moves.STUFF_CHEEKS).length).toBe(1); // Stuff Cheeks used before battle
+      expect(movePhases.filter(p => (p as MovePhase).move.moveId === Moves.STUFF_CHEEKS)).toHaveLength(1); // Stuff Cheeks used before battle
     });
 
     it("should give reviver seed to each pokemon after battle", async () => {
@@ -192,7 +192,7 @@ describe("Absolute Avarice - Mystery Encounter", () => {
       await game.runToMysteryEncounter(MysteryEncounterType.ABSOLUTE_AVARICE, defaultParty);
 
       expect(scene.currentBattle?.mysteryEncounter?.encounterType).toBe(MysteryEncounterType.ABSOLUTE_AVARICE);
-      expect(scene.modifiers?.length).toBe(0);
+      expect(scene.modifiers).toHaveLength(0);
 
       await runMysteryEncounterToEnd(game, 2);
 
@@ -212,7 +212,7 @@ describe("Absolute Avarice - Mystery Encounter", () => {
       await game.runToMysteryEncounter(MysteryEncounterType.ABSOLUTE_AVARICE, defaultParty);
 
       expect(scene.currentBattle?.mysteryEncounter?.encounterType).toBe(MysteryEncounterType.ABSOLUTE_AVARICE);
-      expect(scene.modifiers?.length).toBe(0);
+      expect(scene.modifiers).toHaveLength(0);
 
       await runMysteryEncounterToEnd(game, 2);
 
@@ -259,7 +259,7 @@ describe("Absolute Avarice - Mystery Encounter", () => {
       const greedent = scene.getPlayerParty()[scene.getPlayerParty().length - 1];
       expect(greedent.species.speciesId).toBe(Species.GREEDENT);
       const moveset = greedent.moveset.map(m => m.moveId);
-      expect(moveset?.length).toBe(4);
+      expect(moveset).toHaveLength(4);
       expect(moveset).toEqual([Moves.THRASH, Moves.BODY_PRESS, Moves.STUFF_CHEEKS, Moves.SLACK_OFF]);
     });
 

test/mystery-encounter/encounters/an-offer-you-cant-refuse-encounter.test.ts

@@ -73,7 +73,7 @@ describe("An Offer You Can't Refuse - Mystery Encounter", () => {
       `${namespace}:description`,
     );
     expect(AnOfferYouCantRefuseEncounter.dialogue.encounterOptionsDialogue?.query).toBe(`${namespace}:query`);
-    expect(AnOfferYouCantRefuseEncounter.options.length).toBe(3);
+    expect(AnOfferYouCantRefuseEncounter.options).toHaveLength(3);
   });
 
   it("should not spawn outside of HUMAN_TRANSITABLE_BIOMES", async () => {
@@ -158,7 +158,7 @@ describe("An Offer You Can't Refuse - Mystery Encounter", () => {
 
       await runMysteryEncounterToEnd(game, 1);
 
-      expect(scene.getPlayerParty().length).toBe(initialPartySize - 1);
+      expect(scene.getPlayerParty()).toHaveLength(initialPartySize - 1);
       expect(scene.getPlayerParty().find(p => p.name === pokemonName)).toBeUndefined();
     });
 

test/mystery-encounter/encounters/berries-abound-encounter.test.ts

@@ -69,7 +69,7 @@ describe("Berries Abound - Mystery Encounter", () => {
     expect(BerriesAboundEncounter.dialogue.encounterOptionsDialogue?.title).toBe(`${namespace}:title`);
     expect(BerriesAboundEncounter.dialogue.encounterOptionsDialogue?.description).toBe(`${namespace}:description`);
     expect(BerriesAboundEncounter.dialogue.encounterOptionsDialogue?.query).toBe(`${namespace}:query`);
-    expect(BerriesAboundEncounter.options.length).toBe(3);
+    expect(BerriesAboundEncounter.options).toHaveLength(3);
   });
 
   it("should initialize fully", async () => {
@@ -115,7 +115,7 @@ describe("Berries Abound - Mystery Encounter", () => {
 
       const enemyField = scene.getEnemyField();
       expect(scene.getCurrentPhase()?.constructor.name).toBe(CommandPhase.name);
-      expect(enemyField.length).toBe(1);
+      expect(enemyField).toHaveLength(1);
       expect(enemyField[0].species.speciesId).toBe(speciesToSpawn);
     });
 
@@ -189,7 +189,7 @@ describe("Berries Abound - Mystery Encounter", () => {
 
       const enemyField = scene.getEnemyField();
       expect(scene.getCurrentPhase()?.constructor.name).toBe(CommandPhase.name);
-      expect(enemyField.length).toBe(1);
+      expect(enemyField).toHaveLength(1);
       expect(enemyField[0].species.speciesId).toBe(speciesToSpawn);
 
       // Should be enraged
@@ -213,7 +213,7 @@ describe("Berries Abound - Mystery Encounter", () => {
 
       const enemyField = scene.getEnemyField();
       expect(scene.getCurrentPhase()?.constructor.name).toBe(CommandPhase.name);
-      expect(enemyField.length).toBe(1);
+      expect(enemyField).toHaveLength(1);
       expect(enemyField[0].species.speciesId).toBe(speciesToSpawn);
 
       // Should be enraged

test/mystery-encounter/encounters/bug-type-superfan-encounter.test.ts

@@ -193,7 +193,7 @@ describe("Bug-Type Superfan - Mystery Encounter", () => {
     expect(BugTypeSuperfanEncounter.dialogue.encounterOptionsDialogue?.title).toBe(`${namespace}:title`);
     expect(BugTypeSuperfanEncounter.dialogue.encounterOptionsDialogue?.description).toBe(`${namespace}:description`);
     expect(BugTypeSuperfanEncounter.dialogue.encounterOptionsDialogue?.query).toBe(`${namespace}:query`);
-    expect(BugTypeSuperfanEncounter.options.length).toBe(3);
+    expect(BugTypeSuperfanEncounter.options).toHaveLength(3);
   });
 
   it("should initialize fully", async () => {
@@ -238,7 +238,7 @@ describe("Bug-Type Superfan - Mystery Encounter", () => {
 
       const enemyParty = scene.getEnemyParty();
       expect(scene.getCurrentPhase()?.constructor.name).toBe(CommandPhase.name);
-      expect(enemyParty.length).toBe(2);
+      expect(enemyParty).toHaveLength(2);
       expect(scene.currentBattle.trainer?.config.trainerType).toBe(TrainerType.BUG_TYPE_SUPERFAN);
       expect(enemyParty[0].species.speciesId).toBe(Species.BEEDRILL);
       expect(enemyParty[1].species.speciesId).toBe(Species.BUTTERFREE);
@@ -251,7 +251,7 @@ describe("Bug-Type Superfan - Mystery Encounter", () => {
 
       const enemyParty = scene.getEnemyParty();
       expect(scene.getCurrentPhase()?.constructor.name).toBe(CommandPhase.name);
-      expect(enemyParty.length).toBe(3);
+      expect(enemyParty).toHaveLength(3);
       expect(scene.currentBattle.trainer?.config.trainerType).toBe(TrainerType.BUG_TYPE_SUPERFAN);
       expect(enemyParty[0].species.speciesId).toBe(Species.BEEDRILL);
       expect(enemyParty[1].species.speciesId).toBe(Species.BUTTERFREE);
@@ -265,7 +265,7 @@ describe("Bug-Type Superfan - Mystery Encounter", () => {
 
       const enemyParty = scene.getEnemyParty();
       expect(scene.getCurrentPhase()?.constructor.name).toBe(CommandPhase.name);
-      expect(enemyParty.length).toBe(4);
+      expect(enemyParty).toHaveLength(4);
       expect(scene.currentBattle.trainer?.config.trainerType).toBe(TrainerType.BUG_TYPE_SUPERFAN);
       expect(enemyParty[0].species.speciesId).toBe(Species.BEEDRILL);
       expect(enemyParty[1].species.speciesId).toBe(Species.BUTTERFREE);
@@ -280,7 +280,7 @@ describe("Bug-Type Superfan - Mystery Encounter", () => {
 
       const enemyParty = scene.getEnemyParty();
       expect(scene.getCurrentPhase()?.constructor.name).toBe(CommandPhase.name);
-      expect(enemyParty.length).toBe(5);
+      expect(enemyParty).toHaveLength(5);
       expect(scene.currentBattle.trainer?.config.trainerType).toBe(TrainerType.BUG_TYPE_SUPERFAN);
       expect(enemyParty[0].species.speciesId).toBe(Species.BEEDRILL);
       expect(enemyParty[1].species.speciesId).toBe(Species.BUTTERFREE);
@@ -296,7 +296,7 @@ describe("Bug-Type Superfan - Mystery Encounter", () => {
 
       const enemyParty = scene.getEnemyParty();
       expect(scene.getCurrentPhase()?.constructor.name).toBe(CommandPhase.name);
-      expect(enemyParty.length).toBe(5);
+      expect(enemyParty).toHaveLength(5);
       expect(scene.currentBattle.trainer?.config.trainerType).toBe(TrainerType.BUG_TYPE_SUPERFAN);
       expect(enemyParty[0].species.speciesId).toBe(Species.BEEDRILL);
       expect(enemyParty[0].formIndex).toBe(1);
@@ -314,7 +314,7 @@ describe("Bug-Type Superfan - Mystery Encounter", () => {
 
       const enemyParty = scene.getEnemyParty();
       expect(scene.getCurrentPhase()?.constructor.name).toBe(CommandPhase.name);
-      expect(enemyParty.length).toBe(5);
+      expect(enemyParty).toHaveLength(5);
       expect(scene.currentBattle.trainer?.config.trainerType).toBe(TrainerType.BUG_TYPE_SUPERFAN);
       expect(enemyParty[0].species.speciesId).toBe(Species.BEEDRILL);
       expect(enemyParty[0].formIndex).toBe(1);
@@ -332,7 +332,7 @@ describe("Bug-Type Superfan - Mystery Encounter", () => {
 
       const enemyParty = scene.getEnemyParty();
       expect(scene.getCurrentPhase()?.constructor.name).toBe(CommandPhase.name);
-      expect(enemyParty.length).toBe(5);
+      expect(enemyParty).toHaveLength(5);
       expect(scene.currentBattle.trainer?.config.trainerType).toBe(TrainerType.BUG_TYPE_SUPERFAN);
       expect(enemyParty[0].species.speciesId).toBe(Species.BEEDRILL);
       expect(enemyParty[0].formIndex).toBe(1);
@@ -350,7 +350,7 @@ describe("Bug-Type Superfan - Mystery Encounter", () => {
 
       const enemyParty = scene.getEnemyParty();
       expect(scene.getCurrentPhase()?.constructor.name).toBe(CommandPhase.name);
-      expect(enemyParty.length).toBe(5);
+      expect(enemyParty).toHaveLength(5);
       expect(scene.currentBattle.trainer?.config.trainerType).toBe(TrainerType.BUG_TYPE_SUPERFAN);
       expect(enemyParty[0].species.speciesId).toBe(Species.BEEDRILL);
       expect(enemyParty[0].formIndex).toBe(1);

test/mystery-encounter/encounters/clowning-around-encounter.test.ts

@@ -86,7 +86,7 @@ describe("Clowning Around - Mystery Encounter", () => {
     expect(ClowningAroundEncounter.dialogue.encounterOptionsDialogue?.title).toBe(`${namespace}:title`);
     expect(ClowningAroundEncounter.dialogue.encounterOptionsDialogue?.description).toBe(`${namespace}:description`);
     expect(ClowningAroundEncounter.dialogue.encounterOptionsDialogue?.query).toBe(`${namespace}:query`);
-    expect(ClowningAroundEncounter.options.length).toBe(3);
+    expect(ClowningAroundEncounter.options).toHaveLength(3);
   });
 
   it("should not run below wave 80", async () => {
@@ -124,7 +124,7 @@ describe("Clowning Around - Mystery Encounter", () => {
       isBoss: true,
       moveSet: [Moves.TRICK, Moves.HYPNOSIS, Moves.SHADOW_BALL, Moves.MIND_BLOWN],
     });
-    expect(config.pokemonConfigs?.[1].customPokemonData?.types.length).toBe(2);
+    expect(config.pokemonConfigs?.[1].customPokemonData?.types).toHaveLength(2);
     expect([
       Abilities.STURDY,
       Abilities.PICKUP,
@@ -173,7 +173,7 @@ describe("Clowning Around - Mystery Encounter", () => {
 
       const enemyField = scene.getEnemyField();
       expect(scene.getCurrentPhase()?.constructor.name).toBe(CommandPhase.name);
-      expect(enemyField.length).toBe(2);
+      expect(enemyField).toHaveLength(2);
       expect(enemyField[0].species.speciesId).toBe(Species.MR_MIME);
       expect(enemyField[0].moveset).toEqual([
         new PokemonMove(Moves.TEETER_DANCE),
@@ -191,9 +191,9 @@ describe("Clowning Around - Mystery Encounter", () => {
 
       // Should have used moves pre-battle
       const movePhases = phaseSpy.mock.calls.filter(p => p[0] instanceof MovePhase).map(p => p[0]);
-      expect(movePhases.length).toBe(3);
+      expect(movePhases).toHaveLength(3);
-      expect(movePhases.filter(p => (p as MovePhase).move.moveId === Moves.ROLE_PLAY).length).toBe(1);
+      expect(movePhases.filter(p => (p as MovePhase).move.moveId === Moves.ROLE_PLAY)).toHaveLength(1);
-      expect(movePhases.filter(p => (p as MovePhase).move.moveId === Moves.TAUNT).length).toBe(2);
+      expect(movePhases.filter(p => (p as MovePhase).move.moveId === Moves.TAUNT)).toHaveLength(2);
     });
 
     it("should let the player gain the ability after battle completion", async () => {
@@ -305,7 +305,7 @@ describe("Clowning Around - Mystery Encounter", () => {
       expect(rogueCountAfter).toBe(7);
 
       const secondItemsAfter = scene.getPlayerParty()[1].getHeldItems();
-      expect(secondItemsAfter.length).toBe(1);
+      expect(secondItemsAfter).toHaveLength(1);
       expect(secondItemsAfter[0].type.id).toBe("SOUL_DEW");
       expect(secondItemsAfter[0]?.stackCount).toBe(5);
     });
@@ -359,14 +359,14 @@ describe("Clowning Around - Mystery Encounter", () => {
       const secondaryTypesAfter = scene.getPlayerParty()[1].getTypes();
       const thirdTypesAfter = scene.getPlayerParty()[2].getTypes();
 
-      expect(leadTypesAfter.length).toBe(2);
+      expect(leadTypesAfter).toHaveLength(2);
       expect(leadTypesAfter[0]).toBe(PokemonType.WATER);
       expect([PokemonType.WATER, PokemonType.ICE].includes(leadTypesAfter[1])).toBeFalsy();
-      expect(secondaryTypesAfter.length).toBe(2);
+      expect(secondaryTypesAfter).toHaveLength(2);
       expect(secondaryTypesAfter[0]).toBe(PokemonType.GHOST);
       expect([PokemonType.GHOST, PokemonType.POISON].includes(secondaryTypesAfter[1])).toBeFalsy();
       expect([PokemonType.GRASS, PokemonType.ELECTRIC].includes(secondaryTypesAfter[1])).toBeTruthy();
-      expect(thirdTypesAfter.length).toBe(2);
+      expect(thirdTypesAfter).toHaveLength(2);
       expect(thirdTypesAfter[0]).toBe(PokemonType.PSYCHIC);
       expect(secondaryTypesAfter[1]).not.toBe(PokemonType.PSYCHIC);
     });

test/mystery-encounter/encounters/dancing-lessons-encounter.test.ts

@@ -69,7 +69,7 @@ describe("Dancing Lessons - Mystery Encounter", () => {
     expect(DancingLessonsEncounter.dialogue.encounterOptionsDialogue?.title).toBe(`${namespace}:title`);
     expect(DancingLessonsEncounter.dialogue.encounterOptionsDialogue?.description).toBe(`${namespace}:description`);
     expect(DancingLessonsEncounter.dialogue.encounterOptionsDialogue?.query).toBe(`${namespace}:query`);
-    expect(DancingLessonsEncounter.options.length).toBe(3);
+    expect(DancingLessonsEncounter.options).toHaveLength(3);
   });
 
   it("should not spawn outside of proper biomes", async () => {
@@ -107,15 +107,15 @@ describe("Dancing Lessons - Mystery Encounter", () => {
 
       const enemyField = scene.getEnemyField();
       expect(scene.getCurrentPhase()?.constructor.name).toBe(CommandPhase.name);
-      expect(enemyField.length).toBe(1);
+      expect(enemyField).toHaveLength(1);
       expect(enemyField[0].species.speciesId).toBe(Species.ORICORIO);
       expect(enemyField[0].summonData.statStages).toEqual([1, 1, 1, 1, 0, 0, 0]);
       const moveset = enemyField[0].moveset.map(m => m.moveId);
       expect(moveset.some(m => m === Moves.REVELATION_DANCE)).toBeTruthy();
 
       const movePhases = phaseSpy.mock.calls.filter(p => p[0] instanceof MovePhase).map(p => p[0]);
-      expect(movePhases.length).toBe(1);
+      expect(movePhases).toHaveLength(1);
-      expect(movePhases.filter(p => (p as MovePhase).move.moveId === Moves.REVELATION_DANCE).length).toBe(1); // Revelation Dance used before battle
+      expect(movePhases.filter(p => (p as MovePhase).move.moveId === Moves.REVELATION_DANCE)).toHaveLength(1); // Revelation Dance used before battle
     });
 
     it("should have a Baton in the rewards after battle", async () => {
@@ -163,8 +163,8 @@ describe("Dancing Lessons - Mystery Encounter", () => {
       await runMysteryEncounterToEnd(game, 2, { pokemonNo: 1 });
 
       const movePhases = phaseSpy.mock.calls.filter(p => p[0] instanceof LearnMovePhase).map(p => p[0]);
-      expect(movePhases.length).toBe(1);
+      expect(movePhases).toHaveLength(1);
-      expect(movePhases.filter(p => (p as LearnMovePhase)["moveId"] === Moves.REVELATION_DANCE).length).toBe(1); // Revelation Dance taught to pokemon
+      expect(movePhases.filter(p => (p as LearnMovePhase)["moveId"] === Moves.REVELATION_DANCE)).toHaveLength(1); // Revelation Dance taught to pokemon
     });
 
     it("should leave encounter without battle", async () => {

test/mystery-encounter/encounters/delibirdy-encounter.test.ts

@@ -72,7 +72,7 @@ describe("Delibird-y - Mystery Encounter", () => {
     expect(DelibirdyEncounter.dialogue.encounterOptionsDialogue?.title).toBe(`${namespace}:title`);
     expect(DelibirdyEncounter.dialogue.encounterOptionsDialogue?.description).toBe(`${namespace}:description`);
     expect(DelibirdyEncounter.dialogue.encounterOptionsDialogue?.query).toBe(`${namespace}:query`);
-    expect(DelibirdyEncounter.options.length).toBe(3);
+    expect(DelibirdyEncounter.options).toHaveLength(3);
   });
 
   it("should not spawn if player does not have enough money", async () => {

test/mystery-encounter/encounters/department-store-sale-encounter.test.ts

@@ -69,7 +69,7 @@ describe("Department Store Sale - Mystery Encounter", () => {
       `${namespace}:description`,
     );
     expect(DepartmentStoreSaleEncounter.dialogue.encounterOptionsDialogue?.query).toBe(`${namespace}:query`);
-    expect(DepartmentStoreSaleEncounter.options.length).toBe(4);
+    expect(DepartmentStoreSaleEncounter.options).toHaveLength(4);
   });
 
   it("should not spawn outside of CIVILIZATION_ENCOUNTER_BIOMES", async () => {

test/mystery-encounter/encounters/field-trip-encounter.test.ts

@@ -67,7 +67,7 @@ describe("Field Trip - Mystery Encounter", () => {
     expect(FieldTripEncounter.dialogue.encounterOptionsDialogue?.title).toBe(`${namespace}:title`);
     expect(FieldTripEncounter.dialogue.encounterOptionsDialogue?.description).toBe(`${namespace}:description`);
     expect(FieldTripEncounter.dialogue.encounterOptionsDialogue?.query).toBe(`${namespace}:query`);
-    expect(FieldTripEncounter.options.length).toBe(3);
+    expect(FieldTripEncounter.options).toHaveLength(3);
   });
 
   describe("Option 1 - Show off a physical move", () => {

test/mystery-encounter/encounters/fiery-fallout-encounter.test.ts

@@ -78,7 +78,7 @@ describe("Fiery Fallout - Mystery Encounter", () => {
     expect(FieryFalloutEncounter.dialogue.encounterOptionsDialogue?.title).toBe(`${namespace}:title`);
     expect(FieryFalloutEncounter.dialogue.encounterOptionsDialogue?.description).toBe(`${namespace}:description`);
     expect(FieryFalloutEncounter.dialogue.encounterOptionsDialogue?.query).toBe(`${namespace}:query`);
-    expect(FieryFalloutEncounter.options.length).toBe(3);
+    expect(FieryFalloutEncounter.options).toHaveLength(3);
   });
 
   it("should not spawn outside of volcano biome", async () => {
@@ -162,14 +162,14 @@ describe("Fiery Fallout - Mystery Encounter", () => {
 
       const enemyField = scene.getEnemyField();
       expect(scene.getCurrentPhase()?.constructor.name).toBe(CommandPhase.name);
-      expect(enemyField.length).toBe(2);
+      expect(enemyField).toHaveLength(2);
       expect(enemyField[0].species.speciesId).toBe(Species.VOLCARONA);
       expect(enemyField[1].species.speciesId).toBe(Species.VOLCARONA);
       expect(enemyField[0].gender).not.toEqual(enemyField[1].gender); // Should be opposite gender
 
       const movePhases = phaseSpy.mock.calls.filter(p => p[0] instanceof MovePhase).map(p => p[0]);
-      expect(movePhases.length).toBe(2);
+      expect(movePhases).toHaveLength(2);
-      expect(movePhases.filter(p => (p as MovePhase).move.moveId === Moves.FIRE_SPIN).length).toBe(2); // Fire spin used twice before battle
+      expect(movePhases.filter(p => (p as MovePhase).move.moveId === Moves.FIRE_SPIN)).toHaveLength(2); // Fire spin used twice before battle
     });
 
     it("should give attack type boosting item to lead pokemon", async () => {

test/mystery-encounter/encounters/fight-or-flight-encounter.test.ts

@@ -65,7 +65,7 @@ describe("Fight or Flight - Mystery Encounter", () => {
     expect(FightOrFlightEncounter.dialogue.encounterOptionsDialogue?.title).toBe(`${namespace}:title`);
     expect(FightOrFlightEncounter.dialogue.encounterOptionsDialogue?.description).toBe(`${namespace}:description`);
     expect(FightOrFlightEncounter.dialogue.encounterOptionsDialogue?.query).toBe(`${namespace}:query`);
-    expect(FightOrFlightEncounter.options.length).toBe(3);
+    expect(FightOrFlightEncounter.options).toHaveLength(3);
   });
 
   it("should initialize fully", async () => {
@@ -111,7 +111,7 @@ describe("Fight or Flight - Mystery Encounter", () => {
 
       const enemyField = scene.getEnemyField();
       expect(scene.getCurrentPhase()?.constructor.name).toBe(CommandPhase.name);
-      expect(enemyField.length).toBe(1);
+      expect(enemyField).toHaveLength(1);
       expect(enemyField[0].species.speciesId).toBe(speciesToSpawn);
     });
 

test/mystery-encounter/encounters/fun-and-games-encounter.test.ts

@@ -74,7 +74,7 @@ describe("Fun And Games! - Mystery Encounter", () => {
     expect(FunAndGamesEncounter.dialogue.encounterOptionsDialogue?.title).toBe(`${namespace}:title`);
     expect(FunAndGamesEncounter.dialogue.encounterOptionsDialogue?.description).toBe(`${namespace}:description`);
     expect(FunAndGamesEncounter.dialogue.encounterOptionsDialogue?.query).toBe(`${namespace}:query`);
-    expect(FunAndGamesEncounter.options.length).toBe(2);
+    expect(FunAndGamesEncounter.options).toHaveLength(2);
   });
 
   it("should not spawn outside of CIVILIZATIONN biomes", async () => {

test/mystery-encounter/encounters/global-trade-system-encounter.test.ts

@@ -66,7 +66,7 @@ describe("Global Trade System - Mystery Encounter", () => {
     expect(GlobalTradeSystemEncounter.dialogue.encounterOptionsDialogue?.title).toBe(`${namespace}:title`);
     expect(GlobalTradeSystemEncounter.dialogue.encounterOptionsDialogue?.description).toBe(`${namespace}:description`);
     expect(GlobalTradeSystemEncounter.dialogue.encounterOptionsDialogue?.query).toBe(`${namespace}:query`);
-    expect(GlobalTradeSystemEncounter.options.length).toBe(4);
+    expect(GlobalTradeSystemEncounter.options).toHaveLength(4);
   });
 
   it("should not loop infinitely when generating trade options for extreme BST non-legendaries", async () => {
@@ -80,7 +80,7 @@ describe("Global Trade System - Mystery Encounter", () => {
     expect(GlobalTradeSystemEncounter.dialogue.encounterOptionsDialogue?.title).toBe(`${namespace}:title`);
     expect(GlobalTradeSystemEncounter.dialogue.encounterOptionsDialogue?.description).toBe(`${namespace}:description`);
     expect(GlobalTradeSystemEncounter.dialogue.encounterOptionsDialogue?.query).toBe(`${namespace}:query`);
-    expect(GlobalTradeSystemEncounter.options.length).toBe(4);
+    expect(GlobalTradeSystemEncounter.options).toHaveLength(4);
   });
 
   it("should not spawn outside of CIVILIZATION_ENCOUNTER_BIOMES", async () => {

test/mystery-encounter/encounters/lost-at-sea-encounter.test.ts

@@ -62,7 +62,7 @@ describe("Lost at Sea - Mystery Encounter", () => {
     expect(LostAtSeaEncounter.dialogue.encounterOptionsDialogue?.title).toBe(`${namespace}:title`);
     expect(LostAtSeaEncounter.dialogue.encounterOptionsDialogue?.description).toBe(`${namespace}:description`);
     expect(LostAtSeaEncounter.dialogue.encounterOptionsDialogue?.query).toBe(`${namespace}:query`);
-    expect(LostAtSeaEncounter.options.length).toBe(3);
+    expect(LostAtSeaEncounter.options).toHaveLength(3);
   });
 
   it("should not spawn outside of sea biome", async () => {

test/mystery-encounter/encounters/mysterious-challengers-encounter.test.ts

@@ -72,7 +72,7 @@ describe("Mysterious Challengers - Mystery Encounter", () => {
       `${namespace}:description`,
     );
     expect(MysteriousChallengersEncounter.dialogue.encounterOptionsDialogue?.query).toBe(`${namespace}:query`);
-    expect(MysteriousChallengersEncounter.options.length).toBe(3);
+    expect(MysteriousChallengersEncounter.options).toHaveLength(3);
   });
 
   it("should not spawn outside of HUMAN_TRANSITABLE_BIOMES", async () => {
@@ -96,7 +96,7 @@ describe("Mysterious Challengers - Mystery Encounter", () => {
     const onInitResult = onInit!();
 
     expect(encounter.enemyPartyConfigs).toBeDefined();
-    expect(encounter.enemyPartyConfigs.length).toBe(3);
+    expect(encounter.enemyPartyConfigs).toHaveLength(3);
     expect(encounter.enemyPartyConfigs).toEqual([
       {
         trainerConfig: expect.any(TrainerConfig),
@@ -127,7 +127,7 @@ describe("Mysterious Challengers - Mystery Encounter", () => {
       ),
     );
     expect(encounter.spriteConfigs).toBeDefined();
-    expect(encounter.spriteConfigs.length).toBe(3);
+    expect(encounter.spriteConfigs).toHaveLength(3);
     expect(onInitResult).toBe(true);
   });
 

test/mystery-encounter/encounters/part-timer-encounter.test.ts

@@ -71,7 +71,7 @@ describe("Part-Timer - Mystery Encounter", () => {
     expect(PartTimerEncounter.dialogue.encounterOptionsDialogue?.title).toBe(`${namespace}:title`);
     expect(PartTimerEncounter.dialogue.encounterOptionsDialogue?.description).toBe(`${namespace}:description`);
     expect(PartTimerEncounter.dialogue.encounterOptionsDialogue?.query).toBe(`${namespace}:query`);
-    expect(PartTimerEncounter.options.length).toBe(3);
+    expect(PartTimerEncounter.options).toHaveLength(3);
   });
 
   it("should not spawn outside of CIVILIZATION_ENCOUNTER_BIOMES", async () => {

test/mystery-encounter/encounters/safari-zone.test.ts

@@ -67,7 +67,7 @@ describe("Safari Zone - Mystery Encounter", () => {
     expect(SafariZoneEncounter.dialogue.encounterOptionsDialogue?.title).toBe(`${namespace}:title`);
     expect(SafariZoneEncounter.dialogue.encounterOptionsDialogue?.description).toBe(`${namespace}:description`);
     expect(SafariZoneEncounter.dialogue.encounterOptionsDialogue?.query).toBe(`${namespace}:query`);
-    expect(SafariZoneEncounter.options.length).toBe(2);
+    expect(SafariZoneEncounter.options).toHaveLength(2);
   });
 
   it("should not spawn outside of the forest, swamp, or jungle biomes", async () => {

test/mystery-encounter/encounters/teleporting-hijinks-encounter.test.ts

@@ -69,7 +69,7 @@ describe("Teleporting Hijinks - Mystery Encounter", () => {
     expect(TeleportingHijinksEncounter.dialogue.encounterOptionsDialogue?.title).toBe(`${namespace}:title`);
     expect(TeleportingHijinksEncounter.dialogue.encounterOptionsDialogue?.description).toBe(`${namespace}:description`);
     expect(TeleportingHijinksEncounter.dialogue.encounterOptionsDialogue?.query).toBe(`${namespace}:query`);
-    expect(TeleportingHijinksEncounter.options.length).toBe(3);
+    expect(TeleportingHijinksEncounter.options).toHaveLength(3);
   });
 
   it("should run in waves that are X1", async () => {

test/mystery-encounter/encounters/the-expert-breeder-encounter.test.ts

@@ -77,7 +77,7 @@ describe("The Expert Pokémon Breeder - Mystery Encounter", () => {
       `${namespace}:description`,
     );
     expect(TheExpertPokemonBreederEncounter.dialogue.encounterOptionsDialogue?.query).toBe(`${namespace}:query`);
-    expect(TheExpertPokemonBreederEncounter.options.length).toBe(3);
+    expect(TheExpertPokemonBreederEncounter.options).toHaveLength(3);
   });
 
   it("should not spawn outside of HUMAN_TRANSITABLE_BIOMES", async () => {
@@ -103,11 +103,11 @@ describe("The Expert Pokémon Breeder - Mystery Encounter", () => {
     const onInitResult = onInit!();
 
     expect(encounter.enemyPartyConfigs).toBeDefined();
-    expect(encounter.enemyPartyConfigs.length).toBe(1);
+    expect(encounter.enemyPartyConfigs).toHaveLength(1);
     expect(encounter.enemyPartyConfigs[0].trainerType).toBe(TrainerType.EXPERT_POKEMON_BREEDER);
-    expect(encounter.enemyPartyConfigs[0].pokemonConfigs?.length).toBe(3);
+    expect(encounter.enemyPartyConfigs[0].pokemonConfigs).toHaveLength(3);
     expect(encounter.spriteConfigs).toBeDefined();
-    expect(encounter.spriteConfigs.length).toBe(2);
+    expect(encounter.spriteConfigs).toHaveLength(2);
     expect(onInitResult).toBe(true);
   });
 
@@ -159,7 +159,7 @@ describe("The Expert Pokémon Breeder - Mystery Encounter", () => {
       expect(scene.getCurrentPhase()?.constructor.name).toBe(CommandPhase.name);
       expect(scene.currentBattle.trainer).toBeDefined();
       expect(scene.currentBattle.mysteryEncounter?.encounterMode).toBe(MysteryEncounterMode.TRAINER_BATTLE);
-      expect(scene.getPlayerParty().length).toBe(1);
+      expect(scene.getPlayerParty()).toHaveLength(1);
     });
 
     it("Should reward the player with friendship and eggs based on pokemon selected", async () => {
@@ -182,8 +182,8 @@ describe("The Expert Pokémon Breeder - Mystery Encounter", () => {
       const rareEggs = scene.currentBattle.mysteryEncounter!.misc.pokemon1RareEggs;
       expect(eggsAfter).toBeDefined();
       expect(eggsBeforeLength + commonEggs + rareEggs).toBe(eggsAfter.length);
-      expect(eggsAfter.filter(egg => egg.tier === EggTier.COMMON).length).toBe(commonEggs);
+      expect(eggsAfter.filter(egg => egg.tier === EggTier.COMMON)).toHaveLength(commonEggs);
-      expect(eggsAfter.filter(egg => egg.tier === EggTier.RARE).length).toBe(rareEggs);
+      expect(eggsAfter.filter(egg => egg.tier === EggTier.RARE)).toHaveLength(rareEggs);
 
       game.phaseInterceptor.superEndPhase();
       await game.phaseInterceptor.to(PostMysteryEncounterPhase);
@@ -244,7 +244,7 @@ describe("The Expert Pokémon Breeder - Mystery Encounter", () => {
       expect(scene.getCurrentPhase()?.constructor.name).toBe(CommandPhase.name);
       expect(scene.currentBattle.trainer).toBeDefined();
       expect(scene.currentBattle.mysteryEncounter?.encounterMode).toBe(MysteryEncounterMode.TRAINER_BATTLE);
-      expect(scene.getPlayerParty().length).toBe(1);
+      expect(scene.getPlayerParty()).toHaveLength(1);
     });
 
     it("Should reward the player with friendship and eggs based on pokemon selected", async () => {
@@ -267,8 +267,8 @@ describe("The Expert Pokémon Breeder - Mystery Encounter", () => {
       const rareEggs = scene.currentBattle.mysteryEncounter!.misc.pokemon2RareEggs;
       expect(eggsAfter).toBeDefined();
       expect(eggsBeforeLength + commonEggs + rareEggs).toBe(eggsAfter.length);
-      expect(eggsAfter.filter(egg => egg.tier === EggTier.COMMON).length).toBe(commonEggs);
+      expect(eggsAfter.filter(egg => egg.tier === EggTier.COMMON)).toHaveLength(commonEggs);
-      expect(eggsAfter.filter(egg => egg.tier === EggTier.RARE).length).toBe(rareEggs);
+      expect(eggsAfter.filter(egg => egg.tier === EggTier.RARE)).toHaveLength(rareEggs);
 
       game.phaseInterceptor.superEndPhase();
       await game.phaseInterceptor.to(PostMysteryEncounterPhase);
@@ -326,7 +326,7 @@ describe("The Expert Pokémon Breeder - Mystery Encounter", () => {
       expect(scene.getCurrentPhase()?.constructor.name).toBe(CommandPhase.name);
       expect(scene.currentBattle.trainer).toBeDefined();
       expect(scene.currentBattle.mysteryEncounter?.encounterMode).toBe(MysteryEncounterMode.TRAINER_BATTLE);
-      expect(scene.getPlayerParty().length).toBe(1);
+      expect(scene.getPlayerParty()).toHaveLength(1);
     });
 
     it("Should reward the player with friendship and eggs based on pokemon selected", async () => {
@@ -349,8 +349,8 @@ describe("The Expert Pokémon Breeder - Mystery Encounter", () => {
       const rareEggs = scene.currentBattle.mysteryEncounter!.misc.pokemon3RareEggs;
       expect(eggsAfter).toBeDefined();
       expect(eggsBeforeLength + commonEggs + rareEggs).toBe(eggsAfter.length);
-      expect(eggsAfter.filter(egg => egg.tier === EggTier.COMMON).length).toBe(commonEggs);
+      expect(eggsAfter.filter(egg => egg.tier === EggTier.COMMON)).toHaveLength(commonEggs);
-      expect(eggsAfter.filter(egg => egg.tier === EggTier.RARE).length).toBe(rareEggs);
+      expect(eggsAfter.filter(egg => egg.tier === EggTier.RARE)).toHaveLength(rareEggs);
 
       game.phaseInterceptor.superEndPhase();
       await game.phaseInterceptor.to(PostMysteryEncounterPhase);

test/mystery-encounter/encounters/the-pokemon-salesman-encounter.test.ts

@@ -74,7 +74,7 @@ describe("The Pokemon Salesman - Mystery Encounter", () => {
     expect(title).toBe(`${namespace}:title`);
     expect(description).toMatch(new RegExp(`^${namespace}\\:description(_shiny)?$`));
     expect(query).toBe(`${namespace}:query`);
-    expect(options.length).toBe(2);
+    expect(options).toHaveLength(2);
   });
 
   it("should not spawn outside of HUMAN_TRANSITABLE_BIOMES", async () => {
@@ -150,7 +150,7 @@ describe("The Pokemon Salesman - Mystery Encounter", () => {
 
       await runMysteryEncounterToEnd(game, 1);
 
-      expect(scene.getPlayerParty().length).toBe(initialPartySize + 1);
+      expect(scene.getPlayerParty()).toHaveLength(initialPartySize + 1);
 
       const newlyPurchasedPokemon = scene.getPlayerParty()[scene.getPlayerParty().length - 1];
       expect(newlyPurchasedPokemon.name).toBe(pokemonName);

test/mystery-encounter/encounters/the-strong-stuff-encounter.test.ts

@@ -77,7 +77,7 @@ describe("The Strong Stuff - Mystery Encounter", () => {
     expect(TheStrongStuffEncounter.dialogue.encounterOptionsDialogue?.title).toBe(`${namespace}:title`);
     expect(TheStrongStuffEncounter.dialogue.encounterOptionsDialogue?.description).toBe(`${namespace}:description`);
     expect(TheStrongStuffEncounter.dialogue.encounterOptionsDialogue?.query).toBe(`${namespace}:query`);
-    expect(TheStrongStuffEncounter.options.length).toBe(2);
+    expect(TheStrongStuffEncounter.options).toHaveLength(2);
   });
 
   it("should not spawn outside of CAVE biome", async () => {
@@ -193,11 +193,11 @@ describe("The Strong Stuff - Mystery Encounter", () => {
 
       const enemyField = scene.getEnemyField();
       expect(scene.getCurrentPhase()?.constructor.name).toBe(CommandPhase.name);
-      expect(enemyField.length).toBe(1);
+      expect(enemyField).toHaveLength(1);
       expect(enemyField[0].species.speciesId).toBe(Species.SHUCKLE);
       expect(enemyField[0].summonData.statStages).toEqual([0, 1, 0, 1, 0, 0, 0]);
       const shuckleItems = enemyField[0].getHeldItems();
-      expect(shuckleItems.length).toBe(5);
+      expect(shuckleItems).toHaveLength(5);
       expect(shuckleItems.find(m => m instanceof BerryModifier && m.berryType === BerryType.SITRUS)?.stackCount).toBe(
         1,
       );
@@ -220,9 +220,9 @@ describe("The Strong Stuff - Mystery Encounter", () => {
 
       // Should have used moves pre-battle
       const movePhases = phaseSpy.mock.calls.filter(p => p[0] instanceof MovePhase).map(p => p[0]);
-      expect(movePhases.length).toBe(2);
+      expect(movePhases).toHaveLength(2);
-      expect(movePhases.filter(p => (p as MovePhase).move.moveId === Moves.GASTRO_ACID).length).toBe(1);
+      expect(movePhases.filter(p => (p as MovePhase).move.moveId === Moves.GASTRO_ACID)).toHaveLength(1);
-      expect(movePhases.filter(p => (p as MovePhase).move.moveId === Moves.STEALTH_ROCK).length).toBe(1);
+      expect(movePhases.filter(p => (p as MovePhase).move.moveId === Moves.STEALTH_ROCK)).toHaveLength(1);
     });
 
     it("should have Soul Dew in rewards", async () => {

test/mystery-encounter/encounters/the-winstrate-challenge-encounter.test.ts

@@ -79,7 +79,7 @@ describe("The Winstrate Challenge - Mystery Encounter", () => {
       `${namespace}:description`,
     );
     expect(TheWinstrateChallengeEncounter.dialogue.encounterOptionsDialogue?.query).toBe(`${namespace}:query`);
-    expect(TheWinstrateChallengeEncounter.options.length).toBe(2);
+    expect(TheWinstrateChallengeEncounter.options).toHaveLength(2);
   });
 
   it("should not spawn outside of HUMAN_TRANSITABLE_BIOMES", async () => {
@@ -103,7 +103,7 @@ describe("The Winstrate Challenge - Mystery Encounter", () => {
     const onInitResult = onInit!();
 
     expect(encounter.enemyPartyConfigs).toBeDefined();
-    expect(encounter.enemyPartyConfigs.length).toBe(5);
+    expect(encounter.enemyPartyConfigs).toHaveLength(5);
     expect(encounter.enemyPartyConfigs).toEqual([
       {
         trainerType: TrainerType.VITO,
@@ -236,7 +236,7 @@ describe("The Winstrate Challenge - Mystery Encounter", () => {
       },
     ]);
     expect(encounter.spriteConfigs).toBeDefined();
-    expect(encounter.spriteConfigs.length).toBe(5);
+    expect(encounter.spriteConfigs).toHaveLength(5);
     expect(onInitResult).toBe(true);
   });
 
@@ -264,31 +264,31 @@ describe("The Winstrate Challenge - Mystery Encounter", () => {
       expect(scene.getCurrentPhase()?.constructor.name).toBe(CommandPhase.name);
       expect(scene.currentBattle.trainer).toBeDefined();
       expect(scene.currentBattle.trainer!.config.trainerType).toBe(TrainerType.VICTOR);
-      expect(scene.currentBattle.mysteryEncounter?.enemyPartyConfigs.length).toBe(4);
+      expect(scene.currentBattle.mysteryEncounter?.enemyPartyConfigs).toHaveLength(4);
       expect(scene.currentBattle.mysteryEncounter?.encounterMode).toBe(MysteryEncounterMode.TRAINER_BATTLE);
 
       await skipBattleToNextBattle(game);
       expect(scene.currentBattle.trainer).toBeDefined();
       expect(scene.currentBattle.trainer!.config.trainerType).toBe(TrainerType.VICTORIA);
-      expect(scene.currentBattle.mysteryEncounter?.enemyPartyConfigs.length).toBe(3);
+      expect(scene.currentBattle.mysteryEncounter?.enemyPartyConfigs).toHaveLength(3);
       expect(scene.currentBattle.mysteryEncounter?.encounterMode).toBe(MysteryEncounterMode.TRAINER_BATTLE);
 
       await skipBattleToNextBattle(game);
       expect(scene.currentBattle.trainer).toBeDefined();
       expect(scene.currentBattle.trainer!.config.trainerType).toBe(TrainerType.VIVI);
-      expect(scene.currentBattle.mysteryEncounter?.enemyPartyConfigs.length).toBe(2);
+      expect(scene.currentBattle.mysteryEncounter?.enemyPartyConfigs).toHaveLength(2);
       expect(scene.currentBattle.mysteryEncounter?.encounterMode).toBe(MysteryEncounterMode.TRAINER_BATTLE);
 
       await skipBattleToNextBattle(game);
       expect(scene.currentBattle.trainer).toBeDefined();
       expect(scene.currentBattle.trainer!.config.trainerType).toBe(TrainerType.VICKY);
-      expect(scene.currentBattle.mysteryEncounter?.enemyPartyConfigs.length).toBe(1);
+      expect(scene.currentBattle.mysteryEncounter?.enemyPartyConfigs).toHaveLength(1);
       expect(scene.currentBattle.mysteryEncounter?.encounterMode).toBe(MysteryEncounterMode.TRAINER_BATTLE);
 
       await skipBattleToNextBattle(game);
       expect(scene.currentBattle.trainer).toBeDefined();
       expect(scene.currentBattle.trainer!.config.trainerType).toBe(TrainerType.VITO);
-      expect(scene.currentBattle.mysteryEncounter?.enemyPartyConfigs.length).toBe(0);
+      expect(scene.currentBattle.mysteryEncounter?.enemyPartyConfigs).toHaveLength(0);
       expect(scene.currentBattle.mysteryEncounter?.encounterMode).toBe(MysteryEncounterMode.TRAINER_BATTLE);
 
       // Should have Macho Brace in the rewards
@@ -330,7 +330,7 @@ describe("The Winstrate Challenge - Mystery Encounter", () => {
       await runMysteryEncounterToEnd(game, 2);
 
       const partyHealPhases = phaseSpy.mock.calls.filter(p => p[0] instanceof PartyHealPhase).map(p => p[0]);
-      expect(partyHealPhases.length).toBe(1);
+      expect(partyHealPhases).toHaveLength(1);
     });
 
     it("should have a Rarer Candy in the rewards", async () => {

test/mystery-encounter/encounters/trash-to-treasure-encounter.test.ts

@@ -75,7 +75,7 @@ describe("Trash to Treasure - Mystery Encounter", () => {
     expect(TrashToTreasureEncounter.dialogue.encounterOptionsDialogue?.title).toBe(`${namespace}:title`);
     expect(TrashToTreasureEncounter.dialogue.encounterOptionsDialogue?.description).toBe(`${namespace}:description`);
     expect(TrashToTreasureEncounter.dialogue.encounterOptionsDialogue?.query).toBe(`${namespace}:query`);
-    expect(TrashToTreasureEncounter.options.length).toBe(2);
+    expect(TrashToTreasureEncounter.options).toHaveLength(2);
   });
 
   it("should initialize fully", async () => {
@@ -221,7 +221,7 @@ describe("Trash to Treasure - Mystery Encounter", () => {
 
       const enemyField = scene.getEnemyField();
       expect(scene.getCurrentPhase()?.constructor.name).toBe(CommandPhase.name);
-      expect(enemyField.length).toBe(1);
+      expect(enemyField).toHaveLength(1);
       expect(enemyField[0].species.speciesId).toBe(Species.GARBODOR);
       expect(enemyField[0].moveset).toEqual([
         new PokemonMove(Moves.GUNK_SHOT),
@@ -232,9 +232,9 @@ describe("Trash to Treasure - Mystery Encounter", () => {
 
       // Should have used moves pre-battle
       const movePhases = phaseSpy.mock.calls.filter(p => p[0] instanceof MovePhase).map(p => p[0]);
-      expect(movePhases.length).toBe(2);
+      expect(movePhases).toHaveLength(2);
-      expect(movePhases.filter(p => (p as MovePhase).move.moveId === Moves.TOXIC).length).toBe(1);
+      expect(movePhases.filter(p => (p as MovePhase).move.moveId === Moves.TOXIC)).toHaveLength(1);
-      expect(movePhases.filter(p => (p as MovePhase).move.moveId === Moves.STOCKPILE).length).toBe(1);
+      expect(movePhases.filter(p => (p as MovePhase).move.moveId === Moves.STOCKPILE)).toHaveLength(1);
     });
 
     it("should have 2 Rogue, 1 Ultra, 1 Great in rewards", async () => {

test/mystery-encounter/encounters/uncommon-breed-encounter.test.ts

@@ -74,7 +74,7 @@ describe("Uncommon Breed - Mystery Encounter", () => {
     expect(UncommonBreedEncounter.dialogue.encounterOptionsDialogue?.title).toBe(`${namespace}:title`);
     expect(UncommonBreedEncounter.dialogue.encounterOptionsDialogue?.description).toBe(`${namespace}:description`);
     expect(UncommonBreedEncounter.dialogue.encounterOptionsDialogue?.query).toBe(`${namespace}:query`);
-    expect(UncommonBreedEncounter.options.length).toBe(3);
+    expect(UncommonBreedEncounter.options).toHaveLength(3);
   });
 
   it("should initialize fully", async () => {
@@ -122,7 +122,7 @@ describe("Uncommon Breed - Mystery Encounter", () => {
 
       const enemyField = scene.getEnemyField();
       expect(scene.getCurrentPhase()?.constructor.name).toBe(CommandPhase.name);
-      expect(enemyField.length).toBe(1);
+      expect(enemyField).toHaveLength(1);
       expect(enemyField[0].species.speciesId).toBe(speciesToSpawn);
 
       const statStagePhases = unshiftPhaseSpy.mock.calls.filter(p => p[0] instanceof StatStageChangePhase)[0][0] as any;
@@ -130,7 +130,7 @@ describe("Uncommon Breed - Mystery Encounter", () => {
 
       // Should have used its egg move pre-battle
       const movePhases = phaseSpy.mock.calls.filter(p => p[0] instanceof MovePhase).map(p => p[0]);
-      expect(movePhases.length).toBe(1);
+      expect(movePhases).toHaveLength(1);
       const eggMoves: Moves[] = speciesEggMoves[getPokemonSpecies(speciesToSpawn).getRootSpeciesId()];
       const usedMove = (movePhases[0] as MovePhase).move.moveId;
       expect(eggMoves.includes(usedMove)).toBe(true);
@@ -149,7 +149,7 @@ describe("Uncommon Breed - Mystery Encounter", () => {
 
       const enemyField = scene.getEnemyField();
       expect(scene.getCurrentPhase()?.constructor.name).toBe(CommandPhase.name);
-      expect(enemyField.length).toBe(1);
+      expect(enemyField).toHaveLength(1);
       expect(enemyField[0].species.speciesId).toBe(speciesToSpawn);
 
       const statStagePhases = unshiftPhaseSpy.mock.calls.filter(p => p[0] instanceof StatStageChangePhase)[0][0] as any;
@@ -157,7 +157,7 @@ describe("Uncommon Breed - Mystery Encounter", () => {
 
       // Should have used its egg move pre-battle
       const movePhases = phaseSpy.mock.calls.filter(p => p[0] instanceof MovePhase).map(p => p[0]);
-      expect(movePhases.length).toBe(1);
+      expect(movePhases).toHaveLength(1);
       const eggMoves: Moves[] = speciesEggMoves[getPokemonSpecies(speciesToSpawn).getRootSpeciesId()];
       const usedMove = (movePhases[0] as MovePhase).move.moveId;
       expect(eggMoves.includes(usedMove)).toBe(true);

test/mystery-encounter/encounters/weird-dream-encounter.test.ts

@@ -74,7 +74,7 @@ describe("Weird Dream - Mystery Encounter", () => {
     expect(WeirdDreamEncounter.dialogue.encounterOptionsDialogue?.title).toBe(`${namespace}:title`);
     expect(WeirdDreamEncounter.dialogue.encounterOptionsDialogue?.description).toBe(`${namespace}:description`);
     expect(WeirdDreamEncounter.dialogue.encounterOptionsDialogue?.query).toBe(`${namespace}:query`);
-    expect(WeirdDreamEncounter.options.length).toBe(3);
+    expect(WeirdDreamEncounter.options).toHaveLength(3);
   });
 
   it("should initialize fully", async () => {
@@ -126,14 +126,14 @@ describe("Weird Dream - Mystery Encounter", () => {
       for (let i = 0; i < pokemonAfter.length; i++) {
         const newPokemon = pokemonAfter[i];
         expect(newPokemon.getSpeciesForm().speciesId).not.toBe(pokemonPrior[i].getSpeciesForm().speciesId);
-        expect(newPokemon.customPokemonData?.types.length).toBe(2);
+        expect(newPokemon.customPokemonData?.types).toHaveLength(2);
       }
 
       const plus90To110 = bstDiff.filter(bst => bst > 80);
       const plus40To50 = bstDiff.filter(bst => bst < 80);
 
-      expect(plus90To110.length).toBe(2);
+      expect(plus90To110).toHaveLength(2);
-      expect(plus40To50.length).toBe(1);
+      expect(plus40To50).toHaveLength(1);
     });
 
     it("should have 1 Memory Mushroom, 5 Rogue Balls, and 3 Mints in rewards", async () => {
@@ -187,8 +187,8 @@ describe("Weird Dream - Mystery Encounter", () => {
 
       const enemyField = scene.getEnemyField();
       expect(scene.getCurrentPhase()?.constructor.name).toBe(CommandPhase.name);
-      expect(enemyField.length).toBe(1);
+      expect(enemyField).toHaveLength(1);
-      expect(scene.getEnemyParty().length).toBe(scene.getPlayerParty().length);
+      expect(scene.getEnemyParty()).toHaveLength(scene.getPlayerParty().length);
     });
 
     it("should have 2 Rogue/2 Ultra/2 Great items in rewards", async () => {

test/phases/frenzy-move-reset.test.ts

@@ -59,14 +59,14 @@ describe("Frenzy Move Reset", () => {
     await game.move.forceStatusActivation(false);
     await game.toNextTurn();
 
-    expect(playerPokemon.summonData.moveQueue.length).toBe(2);
+    expect(playerPokemon.summonData.moveQueue).toHaveLength(2);
     expect(playerPokemon.summonData.tags.some(tag => tag.tagType === BattlerTagType.FRENZY)).toBe(true);
 
     await game.setTurnOrder([BattlerIndex.PLAYER, BattlerIndex.ENEMY]);
     await game.move.forceStatusActivation(true);
     await game.toNextTurn();
 
-    expect(playerPokemon.summonData.moveQueue.length).toBe(0);
+    expect(playerPokemon.summonData.moveQueue).toHaveLength(0);
     expect(playerPokemon.summonData.tags.some(tag => tag.tagType === BattlerTagType.FRENZY)).toBe(false);
   });
 });

test/sprites/pokemonSprite.test.ts

@@ -189,7 +189,7 @@ describe("check if every variant's sprite are correctly set", () => {
     if (errors.length) {
       console.log("errors", errors);
     }
-    expect(errors.length).toBe(0);
+    expect(errors).toHaveLength(0);
   });
 
   it("check exp back male variant files", () => {
@@ -269,7 +269,7 @@ describe("check if every variant's sprite are correctly set", () => {
     if (errors.length) {
       console.log("errors for ", dirPath, errors);
     }
-    expect(errors.length).toBe(0);
+    expect(errors).toHaveLength(0);
   });
 
   it("look over every file in variant exp female and check if present in masterlist", () => {

test/ui/pokedex.test.ts

@@ -443,7 +443,7 @@ describe("UI - Pokedex", () => {
     let filteredPokemon = pokedexHandler.filteredPokemonData.map(pokemon => pokemon.species.speciesId);
 
     // Red shiny
-    expect(filteredPokemon.length).toBe(1);
+    expect(filteredPokemon).toHaveLength(1);
     expect(filteredPokemon[0], "tier 1 shiny").toBe(Species.CATERPIE);
 
     // tier 2 shiny
@@ -452,14 +452,14 @@ describe("UI - Pokedex", () => {
 
     // @ts-expect-error - `filteredPokemonData` is private
     filteredPokemon = pokedexHandler.filteredPokemonData.map(pokemon => pokemon.species.speciesId);
-    expect(filteredPokemon.length).toBe(1);
+    expect(filteredPokemon).toHaveLength(1);
     expect(filteredPokemon[0], "tier 2 shiny").toBe(Species.RATTATA);
 
     filter.toggleOptionState(2);
     filter.toggleOptionState(1);
     // @ts-expect-error - `filteredPokemonData` is private
     filteredPokemon = pokedexHandler.filteredPokemonData.map(pokemon => pokemon.species.speciesId);
-    expect(filteredPokemon.length).toBe(1);
+    expect(filteredPokemon).toHaveLength(1);
     expect(filteredPokemon[0], "tier 3 shiny").toBe(Species.EKANS);
 
     // filter by no shiny
@@ -468,7 +468,7 @@ describe("UI - Pokedex", () => {
 
     // @ts-expect-error - `filteredPokemonData` is private
     filteredPokemon = pokedexHandler.filteredPokemonData.map(pokemon => pokemon.species.speciesId);
-    expect(filteredPokemon.length).toBe(27);
+    expect(filteredPokemon).toHaveLength(27);
     expect(filteredPokemon, "not shiny").not.toContain(Species.CATERPIE);
     expect(filteredPokemon, "not shiny").not.toContain(Species.RATTATA);
     expect(filteredPokemon, "not shiny").not.toContain(Species.EKANS);

test/ui/starter-select.test.ts

@@ -579,7 +579,7 @@ describe("UI - Starter select", () => {
       });
     });
 
-    expect(starterSelectUiHandler?.starterSpecies.length).toBe(1);
+    expect(starterSelectUiHandler?.starterSpecies).toHaveLength(1);
     expect(starterSelectUiHandler?.starterSpecies[0].generation).toBe(1);
     expect(starterSelectUiHandler?.starterSpecies[0].speciesId).toBe(32);
     expect(starterSelectUiHandler?.cursorObj.x).toBe(53);

test/utils.test.ts

@@ -14,7 +14,7 @@ describe("utils", () => {
   describe("randomString", () => {
     it("should return a string of the specified length", () => {
       const str = randomString(10);
-      expect(str.length).toBe(10);
+      expect(str).toHaveLength(10);
     });
 
     it("should work with seed", () => {