@arcanahq/cardgames 1.0.0

package/assembly/__tests__/deck/shoe.spec.ts

@@ -0,0 +1,410 @@
+// @ts-nocheck
+/**
+ * Tests for multi-deck shoe functionality
+ */
+
+import { describe, test, expect } from "assemblyscript-unittest-framework/assembly";
+import {
+  ShoeConfig,
+  DeckConfig,
+  dealCardFromShoe,
+  CardIndexMapper
+} from "../../deck/deck";
+import { Card, Suit, Rank } from "../../cards";
+
+// ============================================================================
+// ShoeConfig Tests
+// ============================================================================
+
+describe("ShoeConfig", () => {
+  test("should create single deck shoe", () => {
+    const shoe = ShoeConfig.standard(1);
+    expect(shoe.numDecks).equal(1);
+    expect(shoe.deckConfig.totalCards).equal(52);
+    expect(shoe.getShoeSize()).equal(52);
+  });
+  
+  test("should create 2-deck shoe", () => {
+    const shoe = ShoeConfig.standard(2);
+    expect(shoe.numDecks).equal(2);
+    expect(shoe.deckConfig.totalCards).equal(52);
+    expect(shoe.getShoeSize()).equal(104); // 2 * 52
+  });
+  
+  test("should create 4-deck shoe", () => {
+    const shoe = ShoeConfig.standard(4);
+    expect(shoe.numDecks).equal(4);
+    expect(shoe.deckConfig.totalCards).equal(52);
+    expect(shoe.getShoeSize()).equal(208); // 4 * 52
+  });
+  
+  test("should create 6-deck shoe", () => {
+    const shoe = ShoeConfig.standard(6);
+    expect(shoe.numDecks).equal(6);
+    expect(shoe.deckConfig.totalCards).equal(52);
+    expect(shoe.getShoeSize()).equal(312); // 6 * 52
+  });
+  
+  test("should create 8-deck shoe", () => {
+    const shoe = ShoeConfig.standard(8);
+    expect(shoe.numDecks).equal(8);
+    expect(shoe.deckConfig.totalCards).equal(52);
+    expect(shoe.getShoeSize()).equal(416); // 8 * 52
+  });
+  
+  test("should create custom number of decks", () => {
+    const shoe = ShoeConfig.standard(10);
+    expect(shoe.numDecks).equal(10);
+    expect(shoe.getShoeSize()).equal(520); // 10 * 52
+  });
+  
+  test("should create Spanish 21 with any number of decks", () => {
+    const shoe1 = ShoeConfig.spanish21(1);
+    expect(shoe1.numDecks).equal(1);
+    expect(shoe1.getShoeSize()).equal(48); // 1 * 48
+    
+    const shoe6 = ShoeConfig.spanish21(6);
+    expect(shoe6.numDecks).equal(6);
+    expect(shoe6.getShoeSize()).equal(288); // 6 * 48
+    
+    const shoe12 = ShoeConfig.spanish21(12);
+    expect(shoe12.numDecks).equal(12);
+    expect(shoe12.getShoeSize()).equal(576); // 12 * 48
+  });
+  
+  test("should create shoe with custom deck config using withDeck", () => {
+    const deckConfig = DeckConfig.standard();
+    const shoe = ShoeConfig.withDeck(deckConfig, 4);
+    expect(shoe.numDecks).equal(4);
+    expect(shoe.getShoeSize()).equal(208); // 4 * 52
+  });
+  
+  test("should create Spanish 21 shoe with withDeck", () => {
+    const spanishDeck = DeckConfig.spanish21();
+    const shoe = ShoeConfig.withDeck(spanishDeck, 6);
+    expect(shoe.numDecks).equal(6);
+    expect(shoe.deckConfig.totalCards).equal(48);
+    expect(shoe.getShoeSize()).equal(288); // 6 * 48
+  });
+  
+  test("should support backward compatibility with custom method", () => {
+    const deckConfig = DeckConfig.standard();
+    const shoe = ShoeConfig.custom(deckConfig, 4);
+    expect(shoe.numDecks).equal(4);
+    expect(shoe.getShoeSize()).equal(208); // 4 * 52
+  });
+  
+  test("should create shoe using constructor directly", () => {
+    const deckConfig = DeckConfig.standard();
+    const shoe = new ShoeConfig(deckConfig, 3);
+    expect(shoe.numDecks).equal(3);
+    expect(shoe.getShoeSize()).equal(156); // 3 * 52
+  });
+  
+  // Backward compatibility tests
+  test("should support deprecated convenience methods", () => {
+    const single = ShoeConfig.singleDeck();
+    expect(single.numDecks).equal(1);
+    
+    const six = ShoeConfig.sixDeck();
+    expect(six.numDecks).equal(6);
+    
+    const eight = ShoeConfig.eightDeck();
+    expect(eight.numDecks).equal(8);
+  });
+});
+
+// ============================================================================
+// createUnshuffledShoeIndices Tests
+// ============================================================================
+
+describe("createUnshuffledShoeIndices", () => {
+  test("should create indices for single deck shoe", () => {
+    const shoe = ShoeConfig.singleDeck();
+    const indices = CardIndexMapper.createUnshuffledShoeIndices(shoe);
+    
+    expect(indices.length).equal(52);
+    // First card should be 2 of Spades (index 0)
+    expect(indices[0]).equal(0);
+    // Last card should be Ace of Clubs (index 51)
+    expect(indices[51]).equal(51);
+  });
+  
+  test("should create indices for 6-deck shoe", () => {
+    const shoe = ShoeConfig.sixDeck();
+    const indices = CardIndexMapper.createUnshuffledShoeIndices(shoe);
+    
+    expect(indices.length).equal(312); // 6 * 52
+    
+    // Each deck should have the same card order
+    // First deck: indices 0-51
+    expect(indices[0]).equal(0); // 2♠
+    expect(indices[51]).equal(51); // A♣
+    
+    // Second deck: indices 52-103 (same order)
+    expect(indices[52]).equal(0); // 2♠
+    expect(indices[103]).equal(51); // A♣
+    
+    // Third deck: indices 104-155
+    expect(indices[104]).equal(0); // 2♠
+    expect(indices[155]).equal(51); // A♣
+    
+    // Sixth deck: indices 260-311
+    expect(indices[260]).equal(0); // 2♠
+    expect(indices[311]).equal(51); // A♣
+  });
+  
+  test("should create indices for 8-deck shoe", () => {
+    const shoe = ShoeConfig.eightDeck();
+    const indices = CardIndexMapper.createUnshuffledShoeIndices(shoe);
+    
+    expect(indices.length).equal(416); // 8 * 52
+    
+    // Verify each deck has same order
+    for (let deck = 0; deck < 8; deck++) {
+      const deckStart = deck * 52;
+      expect(indices[deckStart]).equal(0); // First card of each deck
+      expect(indices[deckStart + 51]).equal(51); // Last card of each deck
+    }
+  });
+  
+  test("should create indices for Spanish 21 6-deck shoe", () => {
+    const shoe = ShoeConfig.spanish21SixDeck();
+    const indices = CardIndexMapper.createUnshuffledShoeIndices(shoe);
+    
+    expect(indices.length).equal(288); // 6 * 48
+    
+    // Verify structure
+    for (let deck = 0; deck < 6; deck++) {
+      const deckStart = deck * 48;
+      expect(indices[deckStart]).equal(0); // First card of each deck
+      expect(indices[deckStart + 47]).equal(47); // Last card of each deck
+    }
+  });
+});
+
+// ============================================================================
+// dealCardFromShoe Tests
+// ============================================================================
+
+describe("dealCardFromShoe", () => {
+  test("should deal cards from 6-deck shoe", () => {
+    const shoe = ShoeConfig.sixDeck();
+    const shuffleId = "test-shuffle-6deck";
+    const shuffleSalt = "test-salt";
+    
+    // Deal first card
+    const card1 = dealCardFromShoe(shuffleId, shuffleSalt, 0, shoe);
+    expect(card1.suit.length).greaterThan(0); // Verify card is valid
+    
+    // Deal second card
+    const card2 = dealCardFromShoe(shuffleId, shuffleSalt, 1, shoe);
+    expect(card2.suit.length).greaterThan(0); // Verify card is valid
+    
+    // Cards should be different (shuffled)
+    expect(card1.equals(card2)).equal(false);
+  });
+  
+  test("should deal cards from 8-deck shoe", () => {
+    const shoe = ShoeConfig.eightDeck();
+    const shuffleId = "test-shuffle-8deck";
+    const shuffleSalt = "test-salt";
+    
+    // Deal multiple cards
+    const card1 = dealCardFromShoe(shuffleId, shuffleSalt, 0, shoe);
+    const card2 = dealCardFromShoe(shuffleId, shuffleSalt, 1, shoe);
+    const card3 = dealCardFromShoe(shuffleId, shuffleSalt, 2, shoe);
+    
+    expect(card1.suit.length).greaterThan(0);
+    expect(card2.suit.length).greaterThan(0);
+    expect(card3.suit.length).greaterThan(0);
+    
+    // All should be different
+    expect(card1.equals(card2)).equal(false);
+    expect(card2.equals(card3)).equal(false);
+  });
+  
+  test("should handle shoe exhaustion and reshuffle", () => {
+    const shoe = ShoeConfig.sixDeck();
+    const shuffleId = "test-shuffle-exhaust";
+    const shuffleSalt = "test-salt";
+    const shoeSize = shoe.getShoeSize(); // 312
+    
+    // Deal last card of first shoe
+    const lastCard = dealCardFromShoe(shuffleId, shuffleSalt, shoeSize - 1, shoe);
+    expect(lastCard.suit.length).greaterThan(0);
+    
+    // Deal first card of second shoe (reshuffled)
+    const firstCardNewShoe = dealCardFromShoe(shuffleId, shuffleSalt, shoeSize, shoe);
+    expect(firstCardNewShoe.suit.length).greaterThan(0);
+    
+    // The new shoe should be deterministically shuffled
+    // (same shuffleId/salt but different iteration)
+    const firstCardNewShoe2 = dealCardFromShoe(shuffleId, shuffleSalt, shoeSize, shoe);
+    expect(firstCardNewShoe.equals(firstCardNewShoe2)).equal(true);
+  });
+  
+  test("should deal deterministically from same position", () => {
+    const shoe = ShoeConfig.sixDeck();
+    const shuffleId = "test-deterministic";
+    const shuffleSalt = "test-salt";
+    
+    const card1 = dealCardFromShoe(shuffleId, shuffleSalt, 50, shoe);
+    const card2 = dealCardFromShoe(shuffleId, shuffleSalt, 50, shoe);
+    
+    // Same position should yield same card
+    expect(card1.equals(card2)).equal(true);
+  });
+  
+  test("should handle large shoe positions", () => {
+    const shoe = ShoeConfig.eightDeck();
+    const shuffleId = "test-large-position";
+    const shuffleSalt = "test-salt";
+    
+    // Deal from middle of shoe
+    const card1 = dealCardFromShoe(shuffleId, shuffleSalt, 200, shoe);
+    expect(card1.suit.length).greaterThan(0);
+    
+    // Deal from near end of shoe
+    const card2 = dealCardFromShoe(shuffleId, shuffleSalt, 410, shoe);
+    expect(card2.suit.length).greaterThan(0);
+    
+    // Deal from second shoe iteration
+    const card3 = dealCardFromShoe(shuffleId, shuffleSalt, 500, shoe);
+    expect(card3.suit.length).greaterThan(0);
+  });
+  
+  test("should work with Spanish 21 6-deck shoe", () => {
+    const shoe = ShoeConfig.spanish21SixDeck();
+    const shuffleId = "test-spanish-6deck";
+    const shuffleSalt = "test-salt";
+    
+    const card1 = dealCardFromShoe(shuffleId, shuffleSalt, 0, shoe);
+    const card2 = dealCardFromShoe(shuffleId, shuffleSalt, 100, shoe);
+    const card3 = dealCardFromShoe(shuffleId, shuffleSalt, 200, shoe);
+    
+    expect(card1.suit.length).greaterThan(0);
+    expect(card2.suit.length).greaterThan(0);
+    expect(card3.suit.length).greaterThan(0);
+    
+    // Verify no 10s in Spanish 21
+    expect(card1.rank == Rank.TEN).equal(false);
+    expect(card2.rank == Rank.TEN).equal(false);
+    expect(card3.rank == Rank.TEN).equal(false);
+  });
+  
+  test("should handle multiple shoe iterations", () => {
+    const shoe = ShoeConfig.sixDeck();
+    const shuffleId = "test-iterations";
+    const shuffleSalt = "test-salt";
+    const shoeSize = shoe.getShoeSize(); // 312
+    
+    // First shoe iteration
+    const card1 = dealCardFromShoe(shuffleId, shuffleSalt, 0, shoe);
+    const card2 = dealCardFromShoe(shuffleId, shuffleSalt, shoeSize - 1, shoe);
+    
+    // Second shoe iteration (reshuffled)
+    const card3 = dealCardFromShoe(shuffleId, shuffleSalt, shoeSize, shoe);
+    const card4 = dealCardFromShoe(shuffleId, shuffleSalt, shoeSize * 2 - 1, shoe);
+    
+    // Third shoe iteration
+    const card5 = dealCardFromShoe(shuffleId, shuffleSalt, shoeSize * 2, shoe);
+    
+    expect(card1.suit.length).greaterThan(0);
+    expect(card2.suit.length).greaterThan(0);
+    expect(card3.suit.length).greaterThan(0);
+    expect(card4.suit.length).greaterThan(0);
+    expect(card5.suit.length).greaterThan(0);
+    
+    // Each iteration should be deterministically shuffled
+    const card1Again = dealCardFromShoe(shuffleId, shuffleSalt, 0, shoe);
+    expect(card1.equals(card1Again)).equal(true);
+    
+    const card3Again = dealCardFromShoe(shuffleId, shuffleSalt, shoeSize, shoe);
+    expect(card3.equals(card3Again)).equal(true);
+  });
+  
+  test("should track position correctly across multiple deals", () => {
+    const shoe = ShoeConfig.eightDeck();
+    const shuffleId = "test-position-tracking";
+    const shuffleSalt = "test-salt";
+    
+    // Simulate dealing multiple cards in sequence
+    const cards = new Array<Card>(10);
+    for (let i = 0; i < 10; i++) {
+      cards[i] = dealCardFromShoe(shuffleId, shuffleSalt, i, shoe);
+    }
+    
+    // All cards should be different (shuffled shoe)
+    for (let i = 0; i < 10; i++) {
+      for (let j = i + 1; j < 10; j++) {
+        // Cards might be the same by chance, but very unlikely in shuffled shoe
+        // We just verify they're valid cards
+        expect(cards[i].suit.length).greaterThan(0);
+        expect(cards[j].suit.length).greaterThan(0);
+      }
+    }
+  });
+});
+
+// ============================================================================
+// Shoe Position Persistence Tests
+// ============================================================================
+
+describe("Shoe Position Persistence", () => {
+  test("should resume from saved position", () => {
+    const shoe = ShoeConfig.sixDeck();
+    const shuffleId = "test-resume";
+    const shuffleSalt = "test-salt";
+    
+    // Deal 100 cards
+    const cardsBefore = new Array<Card>(100);
+    for (let i = 0; i < 100; i++) {
+      cardsBefore[i] = dealCardFromShoe(shuffleId, shuffleSalt, i, shoe);
+    }
+    
+    // "Save" position at 100
+    const savedPosition = 100;
+    
+    // "Resume" from saved position
+    const cardsAfter = new Array<Card>(10);
+    for (let i = 0; i < 10; i++) {
+      cardsAfter[i] = dealCardFromShoe(shuffleId, shuffleSalt, savedPosition + i, shoe);
+    }
+    
+    // Cards after resume should match what we would have gotten
+    const expectedCards = new Array<Card>(10);
+    for (let i = 0; i < 10; i++) {
+      expectedCards[i] = dealCardFromShoe(shuffleId, shuffleSalt, 100 + i, shoe);
+    }
+    
+    for (let i = 0; i < 10; i++) {
+      expect(cardsAfter[i].equals(expectedCards[i])).equal(true);
+    }
+  });
+  
+  test("should handle position across shoe boundaries", () => {
+    const shoe = ShoeConfig.sixDeck();
+    const shuffleId = "test-boundary";
+    const shuffleSalt = "test-salt";
+    const shoeSize = shoe.getShoeSize(); // 312
+    
+    // Deal last few cards of first shoe
+    const lastCardShoe1 = dealCardFromShoe(shuffleId, shuffleSalt, shoeSize - 1, shoe);
+    
+    // Deal first card of second shoe
+    const firstCardShoe2 = dealCardFromShoe(shuffleId, shuffleSalt, shoeSize, shoe);
+    
+    // Deal second card of second shoe
+    const secondCardShoe2 = dealCardFromShoe(shuffleId, shuffleSalt, shoeSize + 1, shoe);
+    
+    expect(lastCardShoe1.suit.length).greaterThan(0);
+    expect(firstCardShoe2.suit.length).greaterThan(0);
+    expect(secondCardShoe2.suit.length).greaterThan(0);
+    
+    // All should be different
+    expect(lastCardShoe1.equals(firstCardShoe2)).equal(false);
+    expect(firstCardShoe2.equals(secondCardShoe2)).equal(false);
+  });
+});
+

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

@@ -0,0 +1,103 @@
+// @ts-nocheck
+/**
+ * Tests for BettingRoundState class
+ */
+
+import { describe, test, expect } from "assemblyscript-unittest-framework/assembly";
+import { BettingRoundState } from "../../poker/poker_game_types";
+
+// ============================================================================
+// BettingRoundState Tests
+// ============================================================================
+
+describe("BettingRoundState", () => {
+  test("should initialize with empty contributions", () => {
+    const state = new BettingRoundState();
+    
+    expect(state.getContributionThisRound(0)).equal(0);
+    expect(state.getTotalContribution(0)).equal(0);
+    expect(state.currentBetToMatch).equal(0);
+    expect(state.actingSeatId).equal(-1);
+  });
+
+  test("should track contributions this round", () => {
+    const state = new BettingRoundState();
+    
+    state.contribThisRound.set(0, 50);
+    state.contribThisRound.set(1, 100);
+    
+    expect(state.getContributionThisRound(0)).equal(50);
+    expect(state.getContributionThisRound(1)).equal(100);
+    expect(state.getContributionThisRound(2)).equal(0); // Not set
+  });
+
+  test("should track total contributions", () => {
+    const state = new BettingRoundState();
+    
+    state.contribTotal.set(0, 150);
+    state.contribTotal.set(1, 200);
+    
+    expect(state.getTotalContribution(0)).equal(150);
+    expect(state.getTotalContribution(1)).equal(200);
+  });
+
+  test("should calculate amount to call", () => {
+    const state = new BettingRoundState();
+    state.currentBetToMatch = 100;
+    state.contribThisRound.set(0, 50);
+    state.contribThisRound.set(1, 100);
+    
+    expect(state.calculateToCall(0)).equal(50); // 100 - 50
+    expect(state.calculateToCall(1)).equal(0); // Already matched
+    expect(state.calculateToCall(2)).equal(100); // Hasn't contributed
+  });
+
+  test("should reset round state", () => {
+    const state = new BettingRoundState();
+    state.currentBetToMatch = 100;
+    state.lastFullRaiseSize = 50;
+    state.lastAggressorSeatId = 2;
+    state.actingSeatId = 1;
+    state.contribThisRound.set(0, 50);
+    state.contribThisRound.set(1, 100);
+    // Set total contributions to verify they remain after reset
+    state.contribTotal.set(0, 50);
+    state.contribTotal.set(1, 100);
+    
+    state.resetRound();
+    
+    expect(state.currentBetToMatch).equal(0);
+    expect(state.lastFullRaiseSize).equal(0);
+    expect(state.lastAggressorSeatId).equal(-1);
+    expect(state.actingSeatId).equal(-1);
+    expect(state.getContributionThisRound(0)).equal(0);
+    expect(state.getContributionThisRound(1)).equal(0);
+    // Total contributions should remain (not cleared by resetRound)
+    expect(state.getTotalContribution(0)).equal(50);
+    expect(state.getTotalContribution(1)).equal(100);
+  });
+
+  test("should clone correctly", () => {
+    const state = new BettingRoundState();
+    state.currentBetToMatch = 100;
+    state.lastFullRaiseSize = 50;
+    state.lastAggressorSeatId = 2;
+    state.actingSeatId = 1;
+    state.contribThisRound.set(0, 50);
+    state.contribTotal.set(0, 150);
+    
+    const cloned = state.clone();
+    
+    expect(cloned.currentBetToMatch).equal(100);
+    expect(cloned.lastFullRaiseSize).equal(50);
+    expect(cloned.lastAggressorSeatId).equal(2);
+    expect(cloned.actingSeatId).equal(1);
+    expect(cloned.getContributionThisRound(0)).equal(50);
+    expect(cloned.getTotalContribution(0)).equal(150);
+    
+    // Modifying clone shouldn't affect original
+    cloned.currentBetToMatch = 200;
+    expect(state.currentBetToMatch).equal(100);
+  });
+});
+

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

@@ -0,0 +1,171 @@
+// @ts-nocheck
+/**
+ * Tests for Omaha Poker showdown evaluator
+ * 
+ * In Omaha, players receive 4 hole cards and must use exactly 2 of them
+ * combined with exactly 3 community cards to make their best 5-card hand.
+ */
+
+import { describe, test, expect } from "assemblyscript-unittest-framework/assembly";
+import { Card, Suit, Rank, HandType } from "../../cards";
+import { OmahaShowdownEvaluator } from "../../poker/omaha_evaluator";
+
+// Helper function to create cards
+function createCard(rank: string, suit: string): Card {
+  return new Card(suit, rank);
+}
+
+describe("OmahaShowdownEvaluator", () => {
+  test("should require exactly 2 hole cards and 3 community cards", () => {
+    const evaluator = new OmahaShowdownEvaluator();
+    
+    // 4 hole cards
+    const holeCards = new Array<Card>(4);
+    holeCards[0] = createCard(Rank.ACE, Suit.SPADES);
+    holeCards[1] = createCard(Rank.ACE, Suit.HEARTS);
+    holeCards[2] = createCard(Rank.SEVEN, Suit.SPADES);
+    holeCards[3] = createCard(Rank.SIX, Suit.HEARTS);
+    
+    // 5 community cards (mixed suits and non-consecutive ranks to avoid flush/straight)
+    const community = new Array<Card>(5);
+    community[0] = createCard(Rank.KING, Suit.DIAMONDS);
+    community[1] = createCard(Rank.QUEEN, Suit.CLUBS);
+    community[2] = createCard(Rank.JACK, Suit.HEARTS);
+    community[3] = createCard(Rank.NINE, Suit.DIAMONDS);
+    community[4] = createCard(Rank.EIGHT, Suit.CLUBS);
+    
+    const rank = evaluator.evaluateHand(holeCards, community);
+    
+    // Should evaluate using best combination of 2 hole + 3 community
+    // Best would be A♠ A♥ + K♦ Q♣ J♥ = Pair of Aces with K, Q, J kickers
+    expect(rank.handType).equal(HandType.PAIR);
+  });
+
+  test("should find best combination of 2 hole + 3 community", () => {
+    const evaluator = new OmahaShowdownEvaluator();
+    
+    // Hole cards: A♠ K♠ Q♥ J♥
+    const holeCards = new Array<Card>(4);
+    holeCards[0] = createCard(Rank.ACE, Suit.SPADES);
+    holeCards[1] = createCard(Rank.KING, Suit.SPADES);
+    holeCards[2] = createCard(Rank.QUEEN, Suit.HEARTS);
+    holeCards[3] = createCard(Rank.JACK, Suit.HEARTS);
+    
+    // Community: 10♠ 9♠ 8♠ 7♠ 6♠ (all spades)
+    const community = new Array<Card>(5);
+    community[0] = createCard(Rank.TEN, Suit.SPADES);
+    community[1] = createCard(Rank.NINE, Suit.SPADES);
+    community[2] = createCard(Rank.EIGHT, Suit.SPADES);
+    community[3] = createCard(Rank.SEVEN, Suit.SPADES);
+    community[4] = createCard(Rank.SIX, Suit.SPADES);
+    
+    // Best combination: A♠ K♠ + 10♠ 9♠ 8♠ = Flush (A♠ K♠ 10♠ 9♠ 8♠)
+    const rank = evaluator.evaluateHand(holeCards, community);
+    
+    expect(rank.handType).equal(HandType.FLUSH);
+  });
+
+  test("should return best 5 cards from 2 hole + 3 community", () => {
+    const evaluator = new OmahaShowdownEvaluator();
+    
+    const holeCards = new Array<Card>(4);
+    holeCards[0] = createCard(Rank.ACE, Suit.SPADES);
+    holeCards[1] = createCard(Rank.KING, Suit.SPADES);
+    holeCards[2] = createCard(Rank.QUEEN, Suit.HEARTS);
+    holeCards[3] = createCard(Rank.JACK, Suit.HEARTS);
+    
+    const community = new Array<Card>(5);
+    community[0] = createCard(Rank.TEN, Suit.SPADES);
+    community[1] = createCard(Rank.NINE, Suit.SPADES);
+    community[2] = createCard(Rank.EIGHT, Suit.SPADES);
+    community[3] = createCard(Rank.SEVEN, Suit.HEARTS);
+    community[4] = createCard(Rank.SIX, Suit.HEARTS);
+    
+    const bestHand = evaluator.getBestFiveCards(holeCards, community);
+    
+    expect(bestHand.length).equal(5);
+    // Should be A♠ K♠ 10♠ 9♠ 8♠ (flush) or A♠ K♠ Q♥ J♥ 10♠ (straight)
+  });
+
+  test("should compare multiple Omaha hands", () => {
+    const evaluator = new OmahaShowdownEvaluator();
+    
+    // Player 0: 4 hole cards that can make a flush
+    const holeCards0 = new Array<Card>(4);
+    holeCards0[0] = createCard(Rank.ACE, Suit.SPADES);
+    holeCards0[1] = createCard(Rank.KING, Suit.SPADES);
+    holeCards0[2] = createCard(Rank.QUEEN, Suit.HEARTS);
+    holeCards0[3] = createCard(Rank.JACK, Suit.HEARTS);
+    
+    // Player 1: 4 hole cards that can make a straight
+    const holeCards1 = new Array<Card>(4);
+    holeCards1[0] = createCard(Rank.ACE, Suit.HEARTS);
+    holeCards1[1] = createCard(Rank.KING, Suit.HEARTS);
+    holeCards1[2] = createCard(Rank.QUEEN, Suit.DIAMONDS);
+    holeCards1[3] = createCard(Rank.JACK, Suit.DIAMONDS);
+    
+    // Community: 10♠ 9♠ 8♠ 7♠ 6♠
+    const community = new Array<Card>(5);
+    community[0] = createCard(Rank.TEN, Suit.SPADES);
+    community[1] = createCard(Rank.NINE, Suit.SPADES);
+    community[2] = createCard(Rank.EIGHT, Suit.SPADES);
+    community[3] = createCard(Rank.SEVEN, Suit.SPADES);
+    community[4] = createCard(Rank.SIX, Suit.SPADES);
+    
+    const holeCardsMap = new Map<i32, Card[]>();
+    holeCardsMap.set(0, holeCards0);
+    holeCardsMap.set(1, holeCards1);
+    
+    const result = evaluator.compareHandsShowdown(holeCardsMap, community);
+    
+    // Player 0 should win with Flush (A♠ K♠ + 10♠ 9♠ 8♠)
+    expect(result.winners.length).equal(1);
+    expect(result.winners[0]).equal(0);
+  });
+
+  test("should handle full house in Omaha", () => {
+    const evaluator = new OmahaShowdownEvaluator();
+    
+    // Hole cards: A♠ A♥ K♠ Q♠ (two Aces, one King, one Queen)
+    const holeCards = new Array<Card>(4);
+    holeCards[0] = createCard(Rank.ACE, Suit.SPADES);
+    holeCards[1] = createCard(Rank.ACE, Suit.HEARTS);
+    holeCards[2] = createCard(Rank.KING, Suit.SPADES);
+    holeCards[3] = createCard(Rank.QUEEN, Suit.SPADES);
+    
+    // Community: A♦ K♦ K♣ J♠ 7♠ (one Ace, two Kings, mixed suits to avoid flush/straight)
+    const community = new Array<Card>(5);
+    community[0] = createCard(Rank.ACE, Suit.DIAMONDS);
+    community[1] = createCard(Rank.KING, Suit.DIAMONDS);
+    community[2] = createCard(Rank.KING, Suit.CLUBS); // Second King for full house
+    community[3] = createCard(Rank.JACK, Suit.CLUBS);
+    community[4] = createCard(Rank.SEVEN, Suit.HEARTS); // Non-consecutive to break straight
+    
+    // Best: A♠ A♥ (hole) + A♦ K♦ K♣ (community) = Full House (Aces over Kings)
+    const rank = evaluator.evaluateHand(holeCards, community);
+    
+    expect(rank.handType).equal(HandType.FULL_HOUSE);
+  });
+
+  test("should handle invalid hand structure gracefully", () => {
+    const evaluator = new OmahaShowdownEvaluator();
+    
+    // Wrong number of hole cards
+    const wrongHole = new Array<Card>(2);
+    wrongHole[0] = createCard(Rank.ACE, Suit.SPADES);
+    wrongHole[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 rank = evaluator.evaluateHand(wrongHole, community);
+    
+    // Should return high card as fallback
+    expect(rank.handType).equal(HandType.HIGH_CARD);
+  });
+});
+