@arcanahq/cardgames 1.0.0

package/assembly/__tests__/poker/pots.spec.ts

@@ -0,0 +1,255 @@
+// @ts-nocheck
+/**
+ * Tests for pot management utilities
+ */
+
+import { describe, test, expect } from "assemblyscript-unittest-framework/assembly";
+import { Pot, PokerRakeConfig } from "../../poker/poker_game_types";
+import {
+  constructSidePots,
+  calculatePokerRake,
+  calculateRakeSimple,
+  distributePot,
+  distributePotSimple,
+  splitPotForRuns,
+  splitAllPotsForRuns,
+  lockPots,
+  getTotalPotAmount
+} from "../../poker/poker_game_utils";
+
+// ============================================================================
+// constructSidePots Tests
+// ============================================================================
+
+describe("constructSidePots", () => {
+  test("should create single pot when all contributions equal", () => {
+    const contributions = new Map<i32, i64>();
+    contributions.set(0, 100);
+    contributions.set(1, 100);
+    contributions.set(2, 100);
+    
+    const pots = constructSidePots(contributions, 0);
+    
+    expect(pots.length).equal(1);
+    expect(pots[0].amount).equal(300);
+    expect(pots[0].eligibleSeats.length).equal(3);
+  });
+
+  test("should create side pots for all-in scenarios", () => {
+    const contributions = new Map<i32, i64>();
+    contributions.set(0, 100);
+    contributions.set(1, 200); // All-in
+    contributions.set(2, 100);
+    
+    const pots = constructSidePots(contributions, 0);
+    
+    expect(pots.length).equal(2);
+    // First pot: all players contribute 100
+    expect(pots[0].amount).equal(300); // 3 players * 100
+    expect(pots[0].eligibleSeats.length).equal(3);
+    // Second pot: only player 1 contributes additional 100
+    expect(pots[1].amount).equal(100);
+    expect(pots[1].eligibleSeats.length).equal(1);
+    expect(pots[1].eligibleSeats[0]).equal(1);
+  });
+
+  test("should handle multiple all-in levels", () => {
+    const contributions = new Map<i32, i64>();
+    contributions.set(0, 50);
+    contributions.set(1, 100);
+    contributions.set(2, 200);
+    
+    const pots = constructSidePots(contributions, 0);
+    
+    expect(pots.length).equal(3);
+    // Pot 1: all contribute 50
+    expect(pots[0].amount).equal(150);
+    expect(pots[0].eligibleSeats.length).equal(3);
+    // Pot 2: players 1 and 2 contribute additional 50
+    expect(pots[1].amount).equal(100);
+    expect(pots[1].eligibleSeats.length).equal(2);
+    // Pot 3: only player 2 contributes additional 100
+    expect(pots[2].amount).equal(100);
+    expect(pots[2].eligibleSeats.length).equal(1);
+  });
+
+  test("should return empty array for no contributions", () => {
+    const contributions = new Map<i32, i64>();
+    const pots = constructSidePots(contributions, 0);
+    expect(pots.length).equal(0);
+  });
+});
+
+// ============================================================================
+// calculatePokerRake Tests
+// ============================================================================
+
+describe("calculatePokerRake", () => {
+  test("should calculate rake as percentage", () => {
+    const rakeConfig = new PokerRakeConfig(5.0, 0); // 5% rake, no cap
+    const rake = calculatePokerRake(100, rakeConfig);
+    expect(rake).equal(5); // 5% of 100
+  });
+
+  test("should apply rake cap", () => {
+    const rakeConfig = new PokerRakeConfig(10.0, 5); // 10% rake, cap at 5
+    const rake = calculatePokerRake(100, rakeConfig);
+    expect(rake).equal(5); // Capped at 5, not 10
+  });
+
+  test("should return 0 for zero percentage", () => {
+    const rakeConfig = new PokerRakeConfig(0.0, 0);
+    const rake = calculatePokerRake(100, rakeConfig);
+    expect(rake).equal(0);
+  });
+
+  test("should handle fractional rake", () => {
+    const rakeConfig = new PokerRakeConfig(2.5, 0); // 2.5% rake
+    const rake = calculatePokerRake(100, rakeConfig);
+    expect(rake).equal(2); // Rounded down
+  });
+});
+
+// ============================================================================
+// calculateRakeSimple Tests
+// ============================================================================
+
+describe("calculateRakeSimple", () => {
+  test("should calculate rake with percentage and cap", () => {
+    const rake = calculateRakeSimple(100, 5.0, 10);
+    expect(rake).equal(5);
+  });
+
+  test("should apply cap", () => {
+    const rake = calculateRakeSimple(1000, 10.0, 50); // 10% = 100, capped at 50
+    expect(rake).equal(50);
+  });
+});
+
+// ============================================================================
+// splitPotForRuns Tests
+// ============================================================================
+
+describe("splitPotForRuns", () => {
+  test("should split pot evenly for 2 runs", () => {
+    const pot = new Pot(0, 100, new Array<i32>(0), false, 1, new Array<i64>(0));
+    const splitPot = splitPotForRuns(pot, 2);
+    
+    expect(splitPot.runCountForPot).equal(2);
+    expect(splitPot.splitAmountsPerRun.length).equal(2);
+    expect(splitPot.splitAmountsPerRun[0] + splitPot.splitAmountsPerRun[1]).equal(100);
+  });
+
+  test("should handle remainder for odd splits", () => {
+    const pot = new Pot(0, 100, new Array<i32>(0), false, 1, new Array<i64>(0));
+    const splitPot = splitPotForRuns(pot, 3);
+    
+    expect(splitPot.runCountForPot).equal(3);
+    expect(splitPot.splitAmountsPerRun.length).equal(3);
+    // 100 / 3 = 33 remainder 1, so first run gets extra chip
+    const total = splitPot.splitAmountsPerRun[0] + splitPot.splitAmountsPerRun[1] + splitPot.splitAmountsPerRun[2];
+    expect(total).equal(100);
+  });
+
+  test("should not split for runCount <= 1", () => {
+    const pot = new Pot(0, 100, new Array<i32>(0), false, 1, new Array<i64>(0));
+    const splitPot = splitPotForRuns(pot, 1);
+    
+    expect(splitPot.runCountForPot).equal(1);
+    expect(splitPot.splitAmountsPerRun.length).equal(1);
+    expect(splitPot.splitAmountsPerRun[0]).equal(100);
+  });
+});
+
+// ============================================================================
+// distributePot Tests
+// ============================================================================
+
+describe("distributePot", () => {
+  test("should distribute pot to single winner", () => {
+    const pot = new Pot(0, 100, new Array<i32>(0), false, 1, new Array<i64>(1));
+    pot.splitAmountsPerRun[0] = 100;
+    const winners = new Array<i32>(1);
+    winners[0] = 0;
+    const rakeConfig = new PokerRakeConfig(5.0, 0);
+    
+    const result = distributePot(pot, winners, 0, 0, rakeConfig);
+    
+    expect(result.rake).equal(5); // 5% of 100
+    expect(result.payouts.has(0)).equal(true);
+    expect(result.payouts.get(0)).equal(95); // 100 - 5 rake
+  });
+
+  test("should distribute pot to multiple winners", () => {
+    const pot = new Pot(0, 100, new Array<i32>(0), false, 1, new Array<i64>(1));
+    pot.splitAmountsPerRun[0] = 100;
+    const winners = new Array<i32>(2);
+    winners[0] = 0;
+    winners[1] = 1;
+    const rakeConfig = new PokerRakeConfig(0.0, 0); // No rake
+    
+    const result = distributePot(pot, winners, 0, 0, rakeConfig);
+    
+    expect(result.rake).equal(0);
+    expect(result.payouts.has(0)).equal(true);
+    expect(result.payouts.has(1)).equal(true);
+    // Each gets 50 (100 / 2)
+    expect(result.payouts.get(0) + result.payouts.get(1)).equal(100);
+  });
+
+  test("should handle odd chips", () => {
+    const pot = new Pot(0, 101, new Array<i32>(0), false, 1, new Array<i64>(1));
+    pot.splitAmountsPerRun[0] = 101;
+    const winners = new Array<i32>(2);
+    winners[0] = 0;
+    winners[1] = 1;
+    const rakeConfig = new PokerRakeConfig(0.0, 0);
+    
+    const result = distributePot(pot, winners, 0, 0, rakeConfig);
+    
+    // 101 / 2 = 50 remainder 1, first winner gets extra chip
+    const total = result.payouts.get(0) + result.payouts.get(1);
+    expect(total).equal(101);
+  });
+});
+
+// ============================================================================
+// lockPots Tests
+// ============================================================================
+
+describe("lockPots", () => {
+  test("should lock all pots", () => {
+    const pots = new Array<Pot>(2);
+    pots[0] = new Pot(0, 100, new Array<i32>(0), false, 1, new Array<i64>(0));
+    pots[1] = new Pot(1, 50, new Array<i32>(0), false, 1, new Array<i64>(0));
+    
+    const lockedPots = lockPots(pots);
+    
+    expect(lockedPots.length).equal(2);
+    expect(lockedPots[0].locked).equal(true);
+    expect(lockedPots[1].locked).equal(true);
+  });
+});
+
+// ============================================================================
+// getTotalPotAmount Tests
+// ============================================================================
+
+describe("getTotalPotAmount", () => {
+  test("should sum all pot amounts", () => {
+    const pots = new Array<Pot>(3);
+    pots[0] = new Pot(0, 100, new Array<i32>(0), false, 1, new Array<i64>(0));
+    pots[1] = new Pot(1, 50, new Array<i32>(0), false, 1, new Array<i64>(0));
+    pots[2] = new Pot(2, 25, new Array<i32>(0), false, 1, new Array<i64>(0));
+    
+    const total = getTotalPotAmount(pots);
+    expect(total).equal(175); // 100 + 50 + 25
+  });
+
+  test("should return 0 for empty array", () => {
+    const pots = new Array<Pot>(0);
+    const total = getTotalPotAmount(pots);
+    expect(total).equal(0);
+  });
+});
+

package/assembly/__tests__/poker/showdown.spec.ts

@@ -0,0 +1,324 @@
+// @ts-nocheck
+/**
+ * Tests for poker showdown utilities
+ */
+
+import { describe, test, expect } from "assemblyscript-unittest-framework/assembly";
+import { Card, Suit, Rank, HandType } from "../../cards";
+import {
+  compareHandsShowdown,
+  compareFiveCardHands,
+  getPlayerHandRank,
+  getPlayerBestHand,
+  compareTwoHands
+} from "../../poker/showdown";
+
+// Helper function to create cards
+function createCard(rank: string, suit: string): Card {
+  return new Card(suit, rank);
+}
+
+// ============================================================================
+// compareHandsShowdown Tests
+// ============================================================================
+
+describe("compareHandsShowdown", () => {
+  test("should determine single winner with best hand", () => {
+    // Player 0: Royal Flush
+    const holeCards1 = new Array<Card>(2);
+    holeCards1[0] = createCard(Rank.ACE, Suit.SPADES);
+    holeCards1[1] = createCard(Rank.KING, Suit.SPADES);
+    
+    // Player 1: Pair of 2s (using different suits to avoid flush/straight)
+    const holeCards2 = new Array<Card>(2);
+    holeCards2[0] = createCard(Rank.TWO, Suit.HEARTS);
+    holeCards2[1] = createCard(Rank.TWO, Suit.DIAMONDS);
+    
+    // Community: Q♠ J♠ 10♠ 9♠ 8♠ (completes royal flush for player 0)
+    // For player 1, best hand is pair of 2s with Q, J, 10 kickers
+    const community = new Array<Card>(5);
+    community[0] = createCard(Rank.QUEEN, Suit.SPADES);
+    community[1] = createCard(Rank.JACK, Suit.SPADES);
+    community[2] = createCard(Rank.TEN, Suit.SPADES);
+    community[3] = createCard(Rank.NINE, Suit.SPADES);
+    community[4] = createCard(Rank.EIGHT, Suit.SPADES);
+    
+    const holeCardsMap = new Map<i32, Card[]>();
+    holeCardsMap.set(0, holeCards1);
+    holeCardsMap.set(1, holeCards2);
+    
+    const result = compareHandsShowdown(holeCardsMap, community);
+    
+    expect(result.winners.length).equal(1);
+    expect(result.winners[0]).equal(0); // Player 0 wins with royal flush
+    expect(result.handRanks.has(0)).equal(true);
+    expect(result.handRanks.has(1)).equal(true);
+    const rank0 = result.handRanks.get(0);
+    const rank1 = result.handRanks.get(1);
+    expect(rank0.handType).equal(HandType.ROYAL_FLUSH);
+    // Player 1's best 5-card hand from 2♥ 2♦ and Q♠ J♠ 10♠ 9♠ 8♠ is actually a straight flush (8♠ 9♠ 10♠ J♠ Q♠)
+    // So we need to change the test to expect STRAIGHT_FLUSH instead of PAIR
+    expect(rank1.handType).equal(HandType.STRAIGHT_FLUSH);
+  });
+
+  test("should handle ties", () => {
+    // Both players have same pair of Aces with same kickers
+    const holeCards1 = new Array<Card>(2);
+    holeCards1[0] = createCard(Rank.ACE, Suit.SPADES);
+    holeCards1[1] = createCard(Rank.ACE, Suit.HEARTS);
+    
+    const holeCards2 = new Array<Card>(2);
+    holeCards2[0] = createCard(Rank.ACE, Suit.DIAMONDS);
+    holeCards2[1] = createCard(Rank.ACE, Suit.CLUBS);
+    
+    // Community: K♥ Q♦ J♣ 10♥ 9♦ (mixed suits, no flush/straight possible)
+    const community = new Array<Card>(5);
+    community[0] = createCard(Rank.KING, Suit.HEARTS);
+    community[1] = createCard(Rank.QUEEN, Suit.DIAMONDS);
+    community[2] = createCard(Rank.JACK, Suit.CLUBS);
+    community[3] = createCard(Rank.TEN, Suit.HEARTS);
+    community[4] = createCard(Rank.NINE, Suit.DIAMONDS);
+    
+    const holeCardsMap = new Map<i32, Card[]>();
+    holeCardsMap.set(0, holeCards1);
+    holeCardsMap.set(1, holeCards2);
+    
+    const result = compareHandsShowdown(holeCardsMap, community);
+    
+    // Both have same hand (pair of Aces with same kickers: K, Q, J)
+    expect(result.winners.length).equal(2);
+    if (result.winners.length >= 1) {
+      expect(result.winners[0] === 0 || result.winners[0] === 1).equal(true);
+    }
+    if (result.winners.length >= 2) {
+      expect(result.winners[1] === 0 || result.winners[1] === 1).equal(true);
+    }
+  });
+
+  test("should handle multiple players", () => {
+    // Player 0: Straight (5-6-7-8-9)
+    const holeCards1 = new Array<Card>(2);
+    holeCards1[0] = createCard(Rank.FIVE, Suit.HEARTS);
+    holeCards1[1] = createCard(Rank.SIX, Suit.HEARTS);
+    
+    // Player 1: Flush (all spades)
+    const holeCards2 = new Array<Card>(2);
+    holeCards2[0] = createCard(Rank.TWO, Suit.SPADES);
+    holeCards2[1] = createCard(Rank.THREE, Suit.SPADES);
+    
+    // Player 2: Pair of 2s
+    const holeCards3 = new Array<Card>(2);
+    holeCards3[0] = createCard(Rank.TWO, Suit.HEARTS);
+    holeCards3[1] = createCard(Rank.TWO, Suit.DIAMONDS);
+    
+    // Community: 7♠ 8♠ 9♠ 10♠ 2♣
+    // Player 0: 5♥ 6♥ 7♠ 8♠ 9♠ = Straight (5-6-7-8-9)
+    // Player 1: 2♠ 3♠ 7♠ 8♠ 9♠ = Flush (all spades)
+    // Player 2: 2♥ 2♦ 7♠ 8♠ 9♠ 10♠ 2♣ = Pair of 2s
+    const community = new Array<Card>(5);
+    community[0] = createCard(Rank.SEVEN, Suit.SPADES);
+    community[1] = createCard(Rank.EIGHT, Suit.SPADES);
+    community[2] = createCard(Rank.NINE, Suit.SPADES);
+    community[3] = createCard(Rank.TEN, Suit.SPADES);
+    community[4] = createCard(Rank.TWO, Suit.CLUBS);
+    
+    const holeCardsMap = new Map<i32, Card[]>();
+    holeCardsMap.set(0, holeCards1);
+    holeCardsMap.set(1, holeCards2);
+    holeCardsMap.set(2, holeCards3);
+    
+    const result = compareHandsShowdown(holeCardsMap, community);
+    
+    // Player 1 has flush (best), then player 0 has straight, then player 2 has pair
+    expect(result.winners.length).equal(1);
+    expect(result.winners[0]).equal(1); // Player 1 wins with flush
+  });
+
+  test("should return empty winners for no hands", () => {
+    const holeCardsMap = new Map<i32, Card[]>();
+    const community = new Array<Card>(5);
+    
+    const result = compareHandsShowdown(holeCardsMap, community);
+    
+    expect(result.winners.length).equal(0);
+    expect(result.handRanks.size).equal(0);
+  });
+});
+
+// ============================================================================
+// compareFiveCardHands Tests
+// ============================================================================
+
+describe("compareFiveCardHands", () => {
+  test("should compare 5-card hands", () => {
+    // Player 1: Royal Flush
+    const hand1 = new Array<Card>(5);
+    hand1[0] = createCard(Rank.ACE, Suit.SPADES);
+    hand1[1] = createCard(Rank.KING, Suit.SPADES);
+    hand1[2] = createCard(Rank.QUEEN, Suit.SPADES);
+    hand1[3] = createCard(Rank.JACK, Suit.SPADES);
+    hand1[4] = createCard(Rank.TEN, Suit.SPADES);
+    
+    // Player 2: Pair
+    const hand2 = new Array<Card>(5);
+    hand2[0] = createCard(Rank.ACE, Suit.HEARTS);
+    hand2[1] = createCard(Rank.ACE, Suit.DIAMONDS);
+    hand2[2] = createCard(Rank.KING, Suit.HEARTS);
+    hand2[3] = createCard(Rank.QUEEN, Suit.HEARTS);
+    hand2[4] = createCard(Rank.JACK, Suit.HEARTS);
+    
+    const handsMap = new Map<i32, Card[]>();
+    handsMap.set(0, hand1);
+    handsMap.set(1, hand2);
+    
+    const result = compareFiveCardHands(handsMap);
+    
+    expect(result.winners.length).equal(1);
+    expect(result.winners[0]).equal(0); // Player 1 wins
+  });
+
+  test("should skip invalid hands (not 5 cards)", () => {
+    const hand1 = new Array<Card>(5);
+    hand1[0] = createCard(Rank.ACE, Suit.SPADES);
+    hand1[1] = createCard(Rank.KING, Suit.SPADES);
+    hand1[2] = createCard(Rank.QUEEN, Suit.SPADES);
+    hand1[3] = createCard(Rank.JACK, Suit.SPADES);
+    hand1[4] = createCard(Rank.TEN, Suit.SPADES);
+    
+    const hand2 = new Array<Card>(2); // Invalid: only 2 cards
+    hand2[0] = createCard(Rank.ACE, Suit.HEARTS);
+    hand2[1] = createCard(Rank.KING, Suit.HEARTS);
+    
+    const handsMap = new Map<i32, Card[]>();
+    handsMap.set(0, hand1);
+    handsMap.set(1, hand2);
+    
+    const result = compareFiveCardHands(handsMap);
+    
+    // Only player 1 should be evaluated
+    expect(result.winners.length).equal(1);
+    expect(result.winners[0]).equal(0);
+    expect(result.handRanks.has(1)).equal(false);
+  });
+});
+
+// ============================================================================
+// getPlayerHandRank Tests
+// ============================================================================
+
+describe("getPlayerHandRank", () => {
+  test("should return hand rank for player", () => {
+    const holeCards = new Array<Card>(2);
+    holeCards[0] = createCard(Rank.ACE, Suit.SPADES);
+    holeCards[1] = createCard(Rank.ACE, Suit.HEARTS);
+    
+    // Community cards that don't create flush/straight (mixed suits, no consecutive ranks)
+    const community = new Array<Card>(5);
+    community[0] = createCard(Rank.KING, Suit.HEARTS);
+    community[1] = createCard(Rank.QUEEN, Suit.DIAMONDS);
+    community[2] = createCard(Rank.JACK, Suit.CLUBS);
+    community[3] = createCard(Rank.SEVEN, Suit.HEARTS); // Changed from TEN to break straight
+    community[4] = createCard(Rank.THREE, Suit.DIAMONDS); // Changed from NINE to break straight
+    
+    const rank = getPlayerHandRank(holeCards, community);
+    
+    expect(rank.handType).equal(HandType.PAIR); // Pair of Aces
+  });
+});
+
+// ============================================================================
+// getPlayerBestHand Tests
+// ============================================================================
+
+describe("getPlayerBestHand", () => {
+  test("should return best 5-card hand", () => {
+    const holeCards = new Array<Card>(2);
+    holeCards[0] = createCard(Rank.ACE, Suit.SPADES);
+    holeCards[1] = createCard(Rank.KING, Suit.SPADES);
+    
+    const community = new Array<Card>(5);
+    community[0] = createCard(Rank.QUEEN, Suit.SPADES);
+    community[1] = createCard(Rank.JACK, Suit.SPADES);
+    community[2] = createCard(Rank.TEN, Suit.SPADES);
+    community[3] = createCard(Rank.NINE, Suit.HEARTS);
+    community[4] = createCard(Rank.EIGHT, Suit.HEARTS);
+    
+    const bestHand = getPlayerBestHand(holeCards, community);
+    
+    expect(bestHand.length).equal(5);
+    // Should be the straight: A♠ K♠ Q♠ J♠ 10♠
+  });
+});
+
+// ============================================================================
+// compareTwoHands Tests
+// ============================================================================
+
+describe("compareTwoHands", () => {
+  test("should return 1 when first hand wins", () => {
+    // Player 1: Royal Flush
+    const holeCards1 = new Array<Card>(2);
+    holeCards1[0] = createCard(Rank.ACE, Suit.SPADES);
+    holeCards1[1] = createCard(Rank.KING, Suit.SPADES);
+    
+    // Player 2: Pair
+    const holeCards2 = new Array<Card>(2);
+    holeCards2[0] = createCard(Rank.TWO, Suit.HEARTS);
+    holeCards2[1] = createCard(Rank.TWO, Suit.DIAMONDS);
+    
+    const community = new Array<Card>(5);
+    community[0] = createCard(Rank.QUEEN, Suit.SPADES);
+    community[1] = createCard(Rank.JACK, Suit.SPADES);
+    community[2] = createCard(Rank.TEN, Suit.SPADES);
+    community[3] = createCard(Rank.NINE, Suit.SPADES);
+    community[4] = createCard(Rank.EIGHT, Suit.SPADES);
+    
+    const result = compareTwoHands(holeCards1, holeCards2, community);
+    expect(result).equal(1); // Player 1 wins
+  });
+
+  test("should return -1 when second hand wins", () => {
+    // Player 1: Pair
+    const holeCards1 = new Array<Card>(2);
+    holeCards1[0] = createCard(Rank.TWO, Suit.HEARTS);
+    holeCards1[1] = createCard(Rank.TWO, Suit.DIAMONDS);
+    
+    // Player 2: Royal Flush
+    const holeCards2 = new Array<Card>(2);
+    holeCards2[0] = createCard(Rank.ACE, Suit.SPADES);
+    holeCards2[1] = createCard(Rank.KING, Suit.SPADES);
+    
+    const community = new Array<Card>(5);
+    community[0] = createCard(Rank.QUEEN, Suit.SPADES);
+    community[1] = createCard(Rank.JACK, Suit.SPADES);
+    community[2] = createCard(Rank.TEN, Suit.SPADES);
+    community[3] = createCard(Rank.NINE, Suit.SPADES);
+    community[4] = createCard(Rank.EIGHT, Suit.SPADES);
+    
+    const result = compareTwoHands(holeCards1, holeCards2, community);
+    expect(result).equal(-1); // Player 2 wins
+  });
+
+  test("should return 0 when hands tie", () => {
+    // Both players have same pair of Aces with same kickers
+    const holeCards1 = new Array<Card>(2);
+    holeCards1[0] = createCard(Rank.ACE, Suit.SPADES);
+    holeCards1[1] = createCard(Rank.ACE, Suit.HEARTS);
+    
+    const holeCards2 = new Array<Card>(2);
+    holeCards2[0] = createCard(Rank.ACE, Suit.DIAMONDS);
+    holeCards2[1] = createCard(Rank.ACE, Suit.CLUBS);
+    
+    // Community cards that don't create flush/straight
+    const community = new Array<Card>(5);
+    community[0] = createCard(Rank.KING, Suit.HEARTS);
+    community[1] = createCard(Rank.QUEEN, Suit.DIAMONDS);
+    community[2] = createCard(Rank.JACK, Suit.CLUBS);
+    community[3] = createCard(Rank.TEN, Suit.HEARTS);
+    community[4] = createCard(Rank.NINE, Suit.DIAMONDS);
+    
+    const result = compareTwoHands(holeCards1, holeCards2, community);
+    expect(result).equal(0); // Tie - both have pair of Aces with same kickers
+  });
+});
+