707 lines
21 KiB
Go
707 lines
21 KiB
Go
package main
|
|
|
|
import (
|
|
"testing"
|
|
)
|
|
|
|
func TestCalculateDiceStatistics_Multiplication(t *testing.T) {
|
|
expression := "5d10*3"
|
|
stats, err := CalculateDiceStatistics(expression)
|
|
if err != nil {
|
|
t.Errorf("CalculateDiceStatistics(%q) failed: %v", expression, err)
|
|
return
|
|
}
|
|
|
|
// For 5d10, min is 5, max is 50.
|
|
// With *3, min should be 15, max should be 150.
|
|
if stats.MinValue != 15 {
|
|
t.Errorf("Expected MinValue 15, got %d", stats.MinValue)
|
|
}
|
|
if stats.MaxValue != 150 {
|
|
t.Errorf("Expected MaxValue 150, got %d", stats.MaxValue)
|
|
}
|
|
}
|
|
|
|
func TestCalculateDiceStatistics_Basic(t *testing.T) {
|
|
// 2d6 -> 2-12
|
|
expression := "2d6"
|
|
stats, err := CalculateDiceStatistics(expression)
|
|
if err != nil {
|
|
t.Fatalf("Failed: %v", err)
|
|
}
|
|
if stats.MinValue != 2 || stats.MaxValue != 12 {
|
|
t.Errorf("Expected 2-12, got %d-%d", stats.MinValue, stats.MaxValue)
|
|
}
|
|
}
|
|
|
|
func TestCalculateDiceStatistics_Constant(t *testing.T) {
|
|
// 5 + 3 -> 8
|
|
expression := "5+3"
|
|
stats, err := CalculateDiceStatistics(expression)
|
|
if err != nil {
|
|
t.Fatalf("Failed: %v", err)
|
|
}
|
|
if stats.MinValue != 8 || stats.MaxValue != 8 {
|
|
t.Errorf("Expected 8-8, got %d-%d", stats.MinValue, stats.MaxValue)
|
|
}
|
|
}
|
|
|
|
func TestCalculateDiceStatistics_Mixed_ConstantMult(t *testing.T) {
|
|
// 1d4 + 2 * 3 -> 1d4 + 6 -> 7-10
|
|
expression := "1d4+2*3"
|
|
stats, err := CalculateDiceStatistics(expression)
|
|
if err != nil {
|
|
t.Fatalf("Failed: %v", err)
|
|
}
|
|
if stats.MinValue != 7 || stats.MaxValue != 10 {
|
|
t.Errorf("Expected 7-10, got %d-%d", stats.MinValue, stats.MaxValue)
|
|
}
|
|
}
|
|
|
|
func TestCalculateDiceStatistics_Mixed_DiceMult(t *testing.T) {
|
|
// 1d4*2 + 3 -> (1..4)*2 + 3 -> {2,4,6,8} + 3 -> {5,7,9,11}
|
|
expression := "1d4*2+3"
|
|
stats, err := CalculateDiceStatistics(expression)
|
|
if err != nil {
|
|
t.Fatalf("Failed: %v", err)
|
|
}
|
|
if stats.MinValue != 5 {
|
|
t.Errorf("Expected MinValue 5, got %d", stats.MinValue)
|
|
}
|
|
if stats.MaxValue != 11 {
|
|
t.Errorf("Expected MaxValue 11, got %d", stats.MaxValue)
|
|
}
|
|
// Check that 6 is NOT a possible outcome (since outcomes are 5, 7, 9, 11)
|
|
if _, exists := stats.Results[6]; exists {
|
|
t.Errorf("Did not expect outcome 6 to exist")
|
|
}
|
|
}
|
|
|
|
func TestCalculateDiceStatistics_ParenthesisAndDiceMult(t *testing.T) {
|
|
// (5d10+3)*d10
|
|
// 5d10 ranges 5-50. +3 ranges 8-53.
|
|
// d10 ranges 1-10.
|
|
// Min: 8 * 1 = 8.
|
|
// Max: 53 * 10 = 530.
|
|
expression := "(5d10+3)*d10"
|
|
stats, err := CalculateDiceStatistics(expression)
|
|
if err != nil {
|
|
t.Fatalf("Failed to calculate %s: %v", expression, err)
|
|
}
|
|
if stats.MinValue != 8 {
|
|
t.Errorf("Expected MinValue 8, got %d", stats.MinValue)
|
|
}
|
|
if stats.MaxValue != 530 {
|
|
t.Errorf("Expected MaxValue 530, got %d", stats.MaxValue)
|
|
}
|
|
}
|
|
|
|
func TestCalculateDiceStatistics_ComplexParentheses(t *testing.T) {
|
|
// 2 * (1d4 + 1) -> 2 * {2,3,4,5} -> {4,6,8,10}
|
|
expression := "2 * (1d4 + 1)"
|
|
stats, err := CalculateDiceStatistics(expression)
|
|
if err != nil {
|
|
t.Fatalf("Failed: %v", err)
|
|
}
|
|
if stats.MinValue != 4 {
|
|
t.Errorf("Expected MinValue 4, got %d", stats.MinValue)
|
|
}
|
|
if stats.MaxValue != 10 {
|
|
t.Errorf("Expected MaxValue 10, got %d", stats.MaxValue)
|
|
}
|
|
if _, exists := stats.Results[5]; exists {
|
|
t.Errorf("Outcome 5 should not exist")
|
|
}
|
|
}
|
|
|
|
func TestCalculateDiceStatistics_ImplicitMult_Dice(t *testing.T) {
|
|
// d203d10 -> 1d203 * 1d10
|
|
// Min: 1 * 1 = 1
|
|
// Max: 203 * 10 = 2030
|
|
expression := "d203d10"
|
|
stats, err := CalculateDiceStatistics(expression)
|
|
if err != nil {
|
|
t.Fatalf("Failed to calculate %s: %v", expression, err)
|
|
}
|
|
if stats.MinValue != 1 {
|
|
t.Errorf("Expected MinValue 1, got %d", stats.MinValue)
|
|
}
|
|
if stats.MaxValue != 2030 {
|
|
t.Errorf("Expected MaxValue 2030, got %d", stats.MaxValue)
|
|
}
|
|
}
|
|
|
|
func TestCalculateDiceStatistics_ImplicitMult_ConstantDice(t *testing.T) {
|
|
// 2d10 -> 2 * d10 -> 2,4,6...20?
|
|
// NO! 2d10 should be parsed as "2 dice of 10 sides".
|
|
// The parser MUST prioritize dice notation over implicit multiplication.
|
|
expression := "2d10"
|
|
stats, err := CalculateDiceStatistics(expression)
|
|
if err != nil {
|
|
t.Fatalf("Failed: %v", err)
|
|
}
|
|
// 2d10 is sum of 2 dice. Min 2, Max 20. All values 2..20 possible.
|
|
if stats.MinValue != 2 {
|
|
t.Errorf("Expected MinValue 2, got %d", stats.MinValue)
|
|
}
|
|
if stats.MaxValue != 20 {
|
|
t.Errorf("Expected MaxValue 20, got %d", stats.MaxValue)
|
|
}
|
|
if _, exists := stats.Results[3]; !exists {
|
|
t.Errorf("Expected outcome 3 to exist for 2d10")
|
|
}
|
|
}
|
|
|
|
func TestCalculateDiceStatistics_ImplicitMult_NumberDice(t *testing.T) {
|
|
// 3 d10 -> 3 * d10
|
|
expression := "3 d10"
|
|
stats, err := CalculateDiceStatistics(expression)
|
|
if err != nil {
|
|
t.Fatalf("Failed: %v", err)
|
|
}
|
|
if stats.MinValue != 3 {
|
|
t.Errorf("Expected MinValue 3, got %d", stats.MinValue)
|
|
}
|
|
if stats.MaxValue != 30 {
|
|
t.Errorf("Expected MaxValue 30, got %d", stats.MaxValue)
|
|
}
|
|
if _, exists := stats.Results[4]; exists {
|
|
t.Errorf("Did not expect outcome 4 to exist for 3 * d10")
|
|
}
|
|
}
|
|
|
|
func TestCalculateDiceStatistics_Division(t *testing.T) {
|
|
// 1d6 / 2
|
|
// Outcomes: 1/2=0, 2/2=1, 3/2=1, 4/2=2, 5/2=2, 6/2=3
|
|
// Expected: 0, 1, 2, 3
|
|
expression := "1d6/2"
|
|
stats, err := CalculateDiceStatistics(expression)
|
|
if err != nil {
|
|
t.Fatalf("Failed: %v", err)
|
|
}
|
|
if stats.MinValue != 0 {
|
|
t.Errorf("Expected MinValue 0, got %d", stats.MinValue)
|
|
}
|
|
if stats.MaxValue != 3 {
|
|
t.Errorf("Expected MaxValue 3, got %d", stats.MaxValue)
|
|
}
|
|
}
|
|
|
|
func TestCalculateDiceStatistics_Power(t *testing.T) {
|
|
// 1d4 ^ 2
|
|
// Outcomes: 1, 4, 9, 16
|
|
expression := "1d4^2"
|
|
stats, err := CalculateDiceStatistics(expression)
|
|
if err != nil {
|
|
t.Fatalf("Failed: %v", err)
|
|
}
|
|
if stats.MinValue != 1 {
|
|
t.Errorf("Expected MinValue 1, got %d", stats.MinValue)
|
|
}
|
|
if stats.MaxValue != 16 {
|
|
t.Errorf("Expected MaxValue 16, got %d", stats.MaxValue)
|
|
}
|
|
if _, exists := stats.Results[9]; !exists {
|
|
t.Errorf("Expected outcome 9 to exist")
|
|
}
|
|
}
|
|
|
|
func TestCalculateDiceStatistics_Decimal(t *testing.T) {
|
|
// 2.5 + 2.5 = 2 + 2 = 4 (floor logic)
|
|
expression := "2.5 + 2.5"
|
|
stats, err := CalculateDiceStatistics(expression)
|
|
if err != nil {
|
|
t.Fatalf("Failed: %v", err)
|
|
}
|
|
if stats.MinValue != 4 {
|
|
t.Errorf("Expected MinValue 4, got %d", stats.MinValue)
|
|
}
|
|
}
|
|
|
|
// TestCalculateDiceStatistics_SingleD20 tests a single d20 roll
|
|
func TestCalculateDiceStatistics_SingleD20(t *testing.T) {
|
|
stats, err := CalculateDiceStatistics("d20")
|
|
if err != nil {
|
|
t.Fatalf("Failed: %v", err)
|
|
}
|
|
if stats.MinValue != 1 {
|
|
t.Errorf("Expected MinValue 1, got %d", stats.MinValue)
|
|
}
|
|
if stats.MaxValue != 20 {
|
|
t.Errorf("Expected MaxValue 20, got %d", stats.MaxValue)
|
|
}
|
|
// All outcomes should be equally likely (1/20 probability)
|
|
expectedProb := 1.0 / 20.0
|
|
for value := 1; value <= 20; value++ {
|
|
prob, exists := stats.Results[value]
|
|
if !exists {
|
|
t.Errorf("Expected outcome %d to exist", value)
|
|
}
|
|
if prob < expectedProb-0.01 || prob > expectedProb+0.01 {
|
|
t.Errorf("d20 outcome %d has probability %f, expected %f", value, prob, expectedProb)
|
|
}
|
|
}
|
|
}
|
|
|
|
// TestCalculateDiceStatistics_AverageValue tests average calculation
|
|
func TestCalculateDiceStatistics_AverageValue(t *testing.T) {
|
|
stats, err := CalculateDiceStatistics("1d6")
|
|
if err != nil {
|
|
t.Fatalf("Failed: %v", err)
|
|
}
|
|
// Average of 1d6 should be 3.5
|
|
expectedAvg := 3.5
|
|
if stats.Average < expectedAvg-0.1 || stats.Average > expectedAvg+0.1 {
|
|
t.Errorf("Expected average ~3.5, got %f", stats.Average)
|
|
}
|
|
}
|
|
|
|
// TestCalculateDiceStatistics_MostCommonValue tests most common outcome
|
|
func TestCalculateDiceStatistics_MostCommonValue(t *testing.T) {
|
|
stats, err := CalculateDiceStatistics("2d6")
|
|
if err != nil {
|
|
t.Fatalf("Failed: %v", err)
|
|
}
|
|
// Most common roll for 2d6 should be 7
|
|
if stats.MostCommon != 7 {
|
|
t.Errorf("Expected MostCommon 7, got %d", stats.MostCommon)
|
|
}
|
|
}
|
|
|
|
// TestCalculateDiceStatistics_SortedOutcomes tests sorted outcomes
|
|
func TestCalculateDiceStatistics_SortedOutcomes(t *testing.T) {
|
|
stats, err := CalculateDiceStatistics("1d4")
|
|
if err != nil {
|
|
t.Fatalf("Failed: %v", err)
|
|
}
|
|
expected := []int{1, 2, 3, 4}
|
|
if len(stats.SortedOutcomes) != len(expected) {
|
|
t.Errorf("Expected %d outcomes, got %d", len(expected), len(stats.SortedOutcomes))
|
|
}
|
|
for i, outcome := range stats.SortedOutcomes {
|
|
if outcome != expected[i] {
|
|
t.Errorf("Expected outcome[%d] = %d, got %d", i, expected[i], outcome)
|
|
}
|
|
}
|
|
}
|
|
|
|
// TestCalculateDiceStatistics_Percentages tests percentage calculations
|
|
func TestCalculateDiceStatistics_Percentages(t *testing.T) {
|
|
stats, err := CalculateDiceStatistics("d20")
|
|
if err != nil {
|
|
t.Fatalf("Failed: %v", err)
|
|
}
|
|
// Each outcome should be 5% (1/20)
|
|
expectedPercentage := 5.0
|
|
for value := 1; value <= 20; value++ {
|
|
pct, exists := stats.Percentages[value]
|
|
if !exists {
|
|
t.Errorf("Expected percentage for outcome %d", value)
|
|
}
|
|
if pct < expectedPercentage-0.1 || pct > expectedPercentage+0.1 {
|
|
t.Errorf("d20 outcome %d has percentage %f%%, expected %f%%", value, pct, expectedPercentage)
|
|
}
|
|
}
|
|
}
|
|
|
|
// TestCalculateDiceStatistics_TotalOutcomes tests total outcomes calculation
|
|
func TestCalculateDiceStatistics_TotalOutcomes(t *testing.T) {
|
|
stats, err := CalculateDiceStatistics("2d6")
|
|
if err != nil {
|
|
t.Fatalf("Failed: %v", err)
|
|
}
|
|
// 2d6 should have 6*6 = 36 total outcomes
|
|
if stats.TotalOutcomes.Int64() != 36 {
|
|
t.Errorf("Expected 36 total outcomes for 2d6, got %d", stats.TotalOutcomes.Int64())
|
|
}
|
|
}
|
|
|
|
// TestCalculateDiceStatistics_Subtraction tests subtraction in statistics
|
|
func TestCalculateDiceStatistics_Subtraction(t *testing.T) {
|
|
expression := "1d6-1d4"
|
|
stats, err := CalculateDiceStatistics(expression)
|
|
if err != nil {
|
|
t.Fatalf("Failed to calculate %s: %v", expression, err)
|
|
}
|
|
// 1d6 (1-6) - 1d4 (1-4) gives range -3 to 5
|
|
if stats.MinValue != -3 {
|
|
t.Errorf("Expected MinValue -3, got %d", stats.MinValue)
|
|
}
|
|
if stats.MaxValue != 5 {
|
|
t.Errorf("Expected MaxValue 5, got %d", stats.MaxValue)
|
|
}
|
|
}
|
|
|
|
// TestCalculateDiceStatistics_MultiplyConstants tests multiplying constants
|
|
func TestCalculateDiceStatistics_MultiplyConstants(t *testing.T) {
|
|
expression := "3 * 4"
|
|
stats, err := CalculateDiceStatistics(expression)
|
|
if err != nil {
|
|
t.Fatalf("Failed: %v", err)
|
|
}
|
|
if stats.MinValue != 12 || stats.MaxValue != 12 {
|
|
t.Errorf("Expected 12-12, got %d-%d", stats.MinValue, stats.MaxValue)
|
|
}
|
|
}
|
|
|
|
// TestCalculateDiceStatistics_DiceMultiplication tests dice multiplication
|
|
func TestCalculateDiceStatistics_DiceMultiplication(t *testing.T) {
|
|
expression := "1d4 * 1d3"
|
|
stats, err := CalculateDiceStatistics(expression)
|
|
if err != nil {
|
|
t.Fatalf("Failed: %v", err)
|
|
}
|
|
// Min: 1*1 = 1, Max: 4*3 = 12
|
|
if stats.MinValue != 1 {
|
|
t.Errorf("Expected MinValue 1, got %d", stats.MinValue)
|
|
}
|
|
if stats.MaxValue != 12 {
|
|
t.Errorf("Expected MaxValue 12, got %d", stats.MaxValue)
|
|
}
|
|
}
|
|
|
|
// TestCalculateDiceStatistics_HighestModifier tests highest die modifier
|
|
func TestCalculateDiceStatistics_HighestModifier(t *testing.T) {
|
|
stats, err := CalculateDiceStatistics("4d6H")
|
|
if err != nil {
|
|
t.Fatalf("Failed: %v", err)
|
|
}
|
|
// 4d6H returns highest die (1-6)
|
|
if stats.MinValue != 1 {
|
|
t.Errorf("Expected MinValue 1, got %d", stats.MinValue)
|
|
}
|
|
if stats.MaxValue != 6 {
|
|
t.Errorf("Expected MaxValue 6, got %d", stats.MaxValue)
|
|
}
|
|
}
|
|
|
|
// TestCalculateDiceStatistics_LowestModifier tests lowest die modifier
|
|
func TestCalculateDiceStatistics_LowestModifier(t *testing.T) {
|
|
stats, err := CalculateDiceStatistics("4d6L")
|
|
if err != nil {
|
|
t.Fatalf("Failed: %v", err)
|
|
}
|
|
// 4d6L returns lowest die (1-6)
|
|
if stats.MinValue != 1 {
|
|
t.Errorf("Expected MinValue 1, got %d", stats.MinValue)
|
|
}
|
|
if stats.MaxValue != 6 {
|
|
t.Errorf("Expected MaxValue 6, got %d", stats.MaxValue)
|
|
}
|
|
}
|
|
|
|
// TestCalculateDiceStatistics_EmptyExpression tests error handling
|
|
func TestCalculateDiceStatistics_EmptyExpression(t *testing.T) {
|
|
_, err := CalculateDiceStatistics("")
|
|
if err == nil {
|
|
t.Errorf("Empty expression should return error")
|
|
}
|
|
}
|
|
|
|
// TestCalculateDiceStatistics_InvalidDiceCount tests invalid dice count
|
|
func TestCalculateDiceStatistics_InvalidDiceCount(t *testing.T) {
|
|
_, err := CalculateDiceStatistics("0d6")
|
|
if err == nil {
|
|
t.Errorf("0d6 should return error")
|
|
}
|
|
}
|
|
|
|
// TestCalculateDiceStatistics_InvalidDiceSides tests invalid dice sides
|
|
func TestCalculateDiceStatistics_InvalidDiceSides(t *testing.T) {
|
|
_, err := CalculateDiceStatistics("1d0")
|
|
if err == nil {
|
|
t.Errorf("1d0 should return error")
|
|
}
|
|
}
|
|
|
|
// TestCalculateDiceStatistics_UnexpectedCharacter tests invalid character
|
|
func TestCalculateDiceStatistics_UnexpectedCharacter(t *testing.T) {
|
|
_, err := CalculateDiceStatistics("1d6@")
|
|
if err == nil {
|
|
t.Errorf("Invalid character should return error")
|
|
}
|
|
}
|
|
|
|
// TestCalculateDiceStatistics_LargeNumberOfDice tests statistics with many dice
|
|
func TestCalculateDiceStatistics_LargeNumberOfDice(t *testing.T) {
|
|
stats, err := CalculateDiceStatistics("10d6")
|
|
if err != nil {
|
|
t.Fatalf("Failed: %v", err)
|
|
}
|
|
// 10d6 ranges from 10 to 60
|
|
if stats.MinValue != 10 {
|
|
t.Errorf("Expected MinValue 10, got %d", stats.MinValue)
|
|
}
|
|
if stats.MaxValue != 60 {
|
|
t.Errorf("Expected MaxValue 60, got %d", stats.MaxValue)
|
|
}
|
|
// Average of 10d6 should be around 35 (10 * 3.5)
|
|
expectedAvg := 35.0
|
|
if stats.Average < expectedAvg-1 || stats.Average > expectedAvg+1 {
|
|
t.Errorf("Expected average ~35, got %f", stats.Average)
|
|
}
|
|
}
|
|
|
|
// TestCalculateDiceStatistics_DiceDivision tests dice division
|
|
func TestCalculateDiceStatistics_DiceDivision(t *testing.T) {
|
|
expression := "1d10 / 2"
|
|
stats, err := CalculateDiceStatistics(expression)
|
|
if err != nil {
|
|
t.Fatalf("Failed: %v", err)
|
|
}
|
|
// 1d10 (1-10) / 2: floor division gives 0-5
|
|
if stats.MinValue != 0 {
|
|
t.Errorf("Expected MinValue 0, got %d", stats.MinValue)
|
|
}
|
|
if stats.MaxValue != 5 {
|
|
t.Errorf("Expected MaxValue 5, got %d", stats.MaxValue)
|
|
}
|
|
}
|
|
|
|
// TestCalculateDiceStatistics_NegativeResults tests expressions with negative results
|
|
func TestCalculateDiceStatistics_NegativeResults(t *testing.T) {
|
|
expression := "1d4 - 10"
|
|
stats, err := CalculateDiceStatistics(expression)
|
|
if err != nil {
|
|
t.Fatalf("Failed: %v", err)
|
|
}
|
|
// 1d4 (1-4) - 10 = -9 to -6
|
|
if stats.MinValue != -9 {
|
|
t.Errorf("Expected MinValue -9, got %d", stats.MinValue)
|
|
}
|
|
if stats.MaxValue != -6 {
|
|
t.Errorf("Expected MaxValue -6, got %d", stats.MaxValue)
|
|
}
|
|
}
|
|
|
|
// TestCalculateDiceStatistics_Parentheses tests parentheses in expressions
|
|
func TestCalculateDiceStatistics_Parentheses(t *testing.T) {
|
|
expression := "(1d4 + 2) * 3"
|
|
stats, err := CalculateDiceStatistics(expression)
|
|
if err != nil {
|
|
t.Fatalf("Failed: %v", err)
|
|
}
|
|
// (1d4 + 2) * 3 = (3-6) * 3 = 9-18
|
|
if stats.MinValue != 9 {
|
|
t.Errorf("Expected MinValue 9, got %d", stats.MinValue)
|
|
}
|
|
if stats.MaxValue != 18 {
|
|
t.Errorf("Expected MaxValue 18, got %d", stats.MaxValue)
|
|
}
|
|
}
|
|
|
|
// TestCalculateDiceStatistics_Exponentiation tests exponentiation in expressions
|
|
func TestCalculateDiceStatistics_Exponentiation(t *testing.T) {
|
|
expression := "1d4 ^ 2"
|
|
stats, err := CalculateDiceStatistics(expression)
|
|
if err != nil {
|
|
t.Fatalf("Failed: %v", err)
|
|
}
|
|
// 1d4 ^ 2: outcomes 1, 4, 9, 16
|
|
if stats.MinValue != 1 {
|
|
t.Errorf("Expected MinValue 1, got %d", stats.MinValue)
|
|
}
|
|
if stats.MaxValue != 16 {
|
|
t.Errorf("Expected MaxValue 16, got %d", stats.MaxValue)
|
|
}
|
|
// Check that 2 is NOT in results
|
|
if _, exists := stats.Results[2]; exists {
|
|
t.Errorf("Outcome 2 should not exist for 1d4^2")
|
|
}
|
|
}
|
|
|
|
// TestCalculateDiceStatistics_MaxPercentage tests max percentage calculation
|
|
func TestCalculateDiceStatistics_MaxPercentage(t *testing.T) {
|
|
stats, err := CalculateDiceStatistics("d6")
|
|
if err != nil {
|
|
t.Fatalf("Failed: %v", err)
|
|
}
|
|
// For d6, all outcomes equally likely: 1/6 ≈ 16.67%
|
|
expectedMaxPct := (1.0 / 6.0) * 100
|
|
if stats.MaxPercentage < expectedMaxPct-1 || stats.MaxPercentage > expectedMaxPct+1 {
|
|
t.Errorf("Expected MaxPercentage ~16.67%%, got %f%%", stats.MaxPercentage)
|
|
}
|
|
}
|
|
|
|
// TestCalculateDiceStatistics_DistributionSum tests that distribution probabilities sum to 1
|
|
func TestCalculateDiceStatistics_DistributionSum(t *testing.T) {
|
|
stats, err := CalculateDiceStatistics("2d6")
|
|
if err != nil {
|
|
t.Fatalf("Failed: %v", err)
|
|
}
|
|
sum := 0.0
|
|
for _, prob := range stats.Results {
|
|
sum += prob
|
|
}
|
|
// Probabilities should sum to ~1.0
|
|
if sum < 0.999 || sum > 1.001 {
|
|
t.Errorf("Probabilities should sum to 1.0, got %f", sum)
|
|
}
|
|
}
|
|
|
|
// TestCalculateDiceStatistics_GetSortedOutcomes tests GetSortedOutcomes method
|
|
func TestCalculateDiceStatistics_GetSortedOutcomes(t *testing.T) {
|
|
stats, err := CalculateDiceStatistics("1d6")
|
|
if err != nil {
|
|
t.Fatalf("Failed: %v", err)
|
|
}
|
|
outcomes := stats.GetSortedOutcomes()
|
|
if len(outcomes) != 6 {
|
|
t.Errorf("Expected 6 outcomes, got %d", len(outcomes))
|
|
}
|
|
// Check they're sorted
|
|
for i := 1; i < len(outcomes); i++ {
|
|
if outcomes[i] <= outcomes[i-1] {
|
|
t.Errorf("Outcomes not properly sorted: %v", outcomes)
|
|
}
|
|
}
|
|
}
|
|
|
|
// TestCalculateDiceStatistics_GetMaxPercentage tests GetMaxPercentage method
|
|
func TestCalculateDiceStatistics_GetMaxPercentage(t *testing.T) {
|
|
stats, err := CalculateDiceStatistics("d20")
|
|
if err != nil {
|
|
t.Fatalf("Failed: %v", err)
|
|
}
|
|
maxPct := stats.GetMaxPercentage()
|
|
expectedMaxPct := 5.0 // 1/20 = 0.05 = 5%
|
|
if maxPct < expectedMaxPct-0.1 || maxPct > expectedMaxPct+0.1 {
|
|
t.Errorf("Expected MaxPercentage 5%%, got %f%%", maxPct)
|
|
}
|
|
}
|
|
|
|
// TestCalculateDiceStatistics_ComplexExpression tests complex expression
|
|
func TestCalculateDiceStatistics_ComplexExpression(t *testing.T) {
|
|
expression := "2d6 + 1d4 + 3"
|
|
stats, err := CalculateDiceStatistics(expression)
|
|
if err != nil {
|
|
t.Fatalf("Failed: %v", err)
|
|
}
|
|
// 2d6 (2-12) + 1d4 (1-4) + 3 = 6-19
|
|
if stats.MinValue != 6 {
|
|
t.Errorf("Expected MinValue 6, got %d", stats.MinValue)
|
|
}
|
|
if stats.MaxValue != 19 {
|
|
t.Errorf("Expected MaxValue 19, got %d", stats.MaxValue)
|
|
}
|
|
}
|
|
|
|
// TestCalculateDiceStatistics_ThreeDiceSum tests sum of three different dice
|
|
func TestCalculateDiceStatistics_ThreeDiceSum(t *testing.T) {
|
|
expression := "1d4 + 1d6 + 1d8"
|
|
stats, err := CalculateDiceStatistics(expression)
|
|
if err != nil {
|
|
t.Fatalf("Failed: %v", err)
|
|
}
|
|
// Min: 1+1+1 = 3, Max: 4+6+8 = 18
|
|
if stats.MinValue != 3 {
|
|
t.Errorf("Expected MinValue 3, got %d", stats.MinValue)
|
|
}
|
|
if stats.MaxValue != 18 {
|
|
t.Errorf("Expected MaxValue 18, got %d", stats.MaxValue)
|
|
}
|
|
}
|
|
|
|
// TestCalculateDiceStatistics_ImplicitMultiplication tests implicit multiplication
|
|
func TestCalculateDiceStatistics_ImplicitMultiplication(t *testing.T) {
|
|
// 2d10 should be treated as 2 dice of 10 sides, not 2 * d10
|
|
stats, err := CalculateDiceStatistics("2d10")
|
|
if err != nil {
|
|
t.Fatalf("Failed: %v", err)
|
|
}
|
|
if stats.MinValue != 2 {
|
|
t.Errorf("Expected MinValue 2, got %d", stats.MinValue)
|
|
}
|
|
if stats.MaxValue != 20 {
|
|
t.Errorf("Expected MaxValue 20, got %d", stats.MaxValue)
|
|
}
|
|
}
|
|
|
|
// TestCalculateDiceStatistics_OutcomeAtBoundary tests outcomes at boundaries
|
|
func TestCalculateDiceStatistics_OutcomeAtBoundary(t *testing.T) {
|
|
stats, err := CalculateDiceStatistics("1d20")
|
|
if err != nil {
|
|
t.Fatalf("Failed: %v", err)
|
|
}
|
|
// Check minimum boundary
|
|
if _, exists := stats.Results[1]; !exists {
|
|
t.Errorf("Expected outcome 1 for d20")
|
|
}
|
|
// Check maximum boundary
|
|
if _, exists := stats.Results[20]; !exists {
|
|
t.Errorf("Expected outcome 20 for d20")
|
|
}
|
|
// Check just outside boundaries
|
|
if _, exists := stats.Results[0]; exists {
|
|
t.Errorf("Outcome 0 should not exist for d20")
|
|
}
|
|
if _, exists := stats.Results[21]; exists {
|
|
t.Errorf("Outcome 21 should not exist for d20")
|
|
}
|
|
}
|
|
|
|
// TestCalculateDiceStatistics_SortedOutcomesAreUnique tests that sorted outcomes are unique
|
|
func TestCalculateDiceStatistics_SortedOutcomesAreUnique(t *testing.T) {
|
|
stats, err := CalculateDiceStatistics("2d6")
|
|
if err != nil {
|
|
t.Fatalf("Failed: %v", err)
|
|
}
|
|
seen := make(map[int]bool)
|
|
for _, outcome := range stats.SortedOutcomes {
|
|
if seen[outcome] {
|
|
t.Errorf("Outcome %d appears more than once in SortedOutcomes", outcome)
|
|
}
|
|
seen[outcome] = true
|
|
}
|
|
}
|
|
|
|
// TestCalculateDiceStatistics_AverageInRange tests that average is within min/max
|
|
func TestCalculateDiceStatistics_AverageInRange(t *testing.T) {
|
|
stats, err := CalculateDiceStatistics("1d20")
|
|
if err != nil {
|
|
t.Fatalf("Failed: %v", err)
|
|
}
|
|
if stats.Average < float64(stats.MinValue) || stats.Average > float64(stats.MaxValue) {
|
|
t.Errorf("Average %f should be between min %d and max %d", stats.Average, stats.MinValue, stats.MaxValue)
|
|
}
|
|
}
|
|
|
|
// TestCalculateDiceStatistics_MostCommonInResults tests that MostCommon is in Results
|
|
func TestCalculateDiceStatistics_MostCommonInResults(t *testing.T) {
|
|
stats, err := CalculateDiceStatistics("2d6")
|
|
if err != nil {
|
|
t.Fatalf("Failed: %v", err)
|
|
}
|
|
if _, exists := stats.Results[stats.MostCommon]; !exists {
|
|
t.Errorf("MostCommon value %d should exist in Results", stats.MostCommon)
|
|
}
|
|
}
|
|
|
|
// TestCalculateDiceStatistics_WhitespaceHandling tests whitespace in expressions
|
|
func TestCalculateDiceStatistics_WhitespaceHandling(t *testing.T) {
|
|
expression := " 1d6 + 2 "
|
|
stats, err := CalculateDiceStatistics(expression)
|
|
if err != nil {
|
|
t.Fatalf("Failed: %v", err)
|
|
}
|
|
if stats.MinValue != 3 {
|
|
t.Errorf("Expected MinValue 3, got %d", stats.MinValue)
|
|
}
|
|
if stats.MaxValue != 8 {
|
|
t.Errorf("Expected MaxValue 8, got %d", stats.MaxValue)
|
|
}
|
|
}
|
|
|
|
// TestCalculateDiceStatistics_ZeroOutcome tests expressions that can produce zero
|
|
func TestCalculateDiceStatistics_ZeroOutcome(t *testing.T) {
|
|
expression := "1d4 - 1d4"
|
|
stats, err := CalculateDiceStatistics(expression)
|
|
if err != nil {
|
|
t.Fatalf("Failed: %v", err)
|
|
}
|
|
// Should include zero outcome
|
|
if _, exists := stats.Results[0]; !exists {
|
|
t.Errorf("Expected outcome 0 for 1d4 - 1d4")
|
|
}
|
|
}
|