GameLogicTest.java

import org.junit.Test;
import org.junit.Before;
import static org.junit.Assert.*;
import java.lang.reflect.Method;

public class GameLogicTest {
    private GuessTheNumberServer server;
    private Method findPrimeMethod;
    private Method reverseDigitsMethod;
    private Method transformGuessMethod;
    
    public void setUp() throws Exception {
        // Get access to private methods for testing
        findPrimeMethod = GuessTheNumberServer.class.getDeclaredMethod("findLargestPrimeLessThan17");
        findPrimeMethod.setAccessible(true);
        
        reverseDigitsMethod = GuessTheNumberServer.class.getDeclaredMethod("reverseDigits", int.class);
        reverseDigitsMethod.setAccessible(true);
        
        transformGuessMethod = GuessTheNumberServer.class.getDeclaredMethod("transformGuess", int.class);
        transformGuessMethod.setAccessible(true);
    }

    public void testPrimeNumberGeneration() throws Exception {
        int[] validPrimes = {2, 3, 5, 7, 11, 13};
        int result = (int) findPrimeMethod.invoke(null);
        
        boolean isValidPrime = false;
        for (int prime : validPrimes) {
            if (result == prime) {
                isValidPrime = true;
                break;
            }
        }
        
        assertTrue("Generated prime should be one of the valid primes less than 17", isValidPrime);
    }

    @Test
    public void testReverseDigits() throws Exception {
        // Test regular numbers
        assertEquals(21, (int) reverseDigitsMethod.invoke(null, 12));
        assertEquals(4321, (int) reverseDigitsMethod.invoke(null, 1234));
        
        // Test single digit
        assertEquals(5, (int) reverseDigitsMethod.invoke(null, 5));
        
        // Test with zeros
        assertEquals(1, (int) reverseDigitsMethod.invoke(null, 100));
        assertEquals(21, (int) reverseDigitsMethod.invoke(null, 120));
    }

    @Test
    public void testTransformGuess() throws Exception {
        // Test even number (should reverse digits)
        int evenResult = (int) transformGuessMethod.invoke(null, 42);
        assertEquals(24, evenResult); // 42 -> 24 (reversed)
        
        // Test number that gets doubled
        int doubledResult = (int) transformGuessMethod.invoke(null, 20);
        assertEquals(40, doubledResult); // 20 -> 02 (reversed) -> 2 -> 4 (doubled)
        
        // Test number that gets halved
        int halvedResult = (int) transformGuessMethod.invoke(null, 78);
        assertEquals(43, halvedResult); // 78 -> 87 (reversed) -> 43 (halved since > 100)
    }

    @Test
    public void testPrefixGeneration() {
        GuessTheNumberServer server = new GuessTheNumberServer();
        
        // Test even number in safe zone
        String evenSafePrefix = server.generatePrefix(20);
        assertTrue(evenSafePrefix.contains("20"));
        assertTrue(evenSafePrefix.contains("safe zone"));
        
        // Test odd number in uncertain range
        String oddUncertainPrefix = server.generatePrefix(75);
        assertTrue(oddUncertainPrefix.contains("75"));
        assertTrue(oddUncertainPrefix.contains("uncertain range"));
        
        // Test number in high risk zone
        String highRiskPrefix = server.generatePrefix(200);
        assertTrue(highRiskPrefix.contains("200"));
        assertTrue(highRiskPrefix.contains("high-risk zone"));
        
        // Test all possible format choices
        boolean foundEvenOdd = false;
        boolean foundSizeComparison = false;
        boolean foundRandomFact = false;
        
        // Run multiple times to cover all random cases
        for (int i = 0; i < 50; i++) {
            String prefix = server.generatePrefix(42);
            if (prefix.contains("even")) foundEvenOdd = true;
            if (prefix.contains("small number")) foundSizeComparison = true;
            if (prefix.contains("special fact")) foundRandomFact = true;
            
            if (foundEvenOdd && foundSizeComparison && foundRandomFact) break;
        }
        
        assertTrue("Should generate even/odd format", foundEvenOdd);
        assertTrue("Should generate size comparison format", foundSizeComparison);
        assertTrue("Should generate random fact format", foundRandomFact);
    }

    @Test
    public void testPrefixZoneRanges() {
        GuessTheNumberServer server = new GuessTheNumberServer();
        
        // Test safe zone boundary
        String safeLowerBound = server.generatePrefix(0);
        String safeUpperBound = server.generatePrefix(50);
        assertTrue(safeLowerBound.contains("safe zone"));
        assertTrue(safeUpperBound.contains("safe zone"));
        
        // Test uncertain range boundary
        String uncertainLowerBound = server.generatePrefix(51);
        String uncertainUpperBound = server.generatePrefix(150);
        assertTrue(uncertainLowerBound.contains("uncertain range"));
        assertTrue(uncertainUpperBound.contains("uncertain range"));
        
        // Test high risk zone
        String highRisk = server.generatePrefix(151);
        assertTrue(highRisk.contains("high-risk zone"));
    }
}