Testing

import munit.FunSuite

class GameTest extends FunSuite:
  test("game creation"):
    val game = Game.make(...)
    assert(game.turns == 0)

import org.scalacheck.Prop.*

test("rating always increases after win"):
  forAll { (rating: Int) =>
    val newRating = Glicko.calculate(rating, win = true)
    newRating > rating
  }

./lila.sh
test

// In sbt console
game/test
user/test
rating/test

testOnly lila.game.GameTest
testOnly lila.rating.GlickoTest

testOnly *Game*
testOnly *Glicko*

testOnly lila.game.GameTest -- *creation*

modules/game/
├── src/
│   ├── main/
│   └── test/
│       ├── GameTest.scala
│       ├── PgnTest.scala
│       └── ...

lazy val game = module("game",
  Seq(tree, rating, memo),
  Seq(compression) ++ tests.bundle
)

.dependsOn(common % "test->test")

import { test } from 'node:test';
import assert from 'node:assert';

test('winningChances calculation', () => {
  const chances = winningChances(100);
  assert.strictEqual(chances, 0.95);
});

# Run all tests
ui/test

# Watch mode
ui/test -w

# Test specific module
ui/test winning

# Test multiple patterns
ui/test mod once

ui/lib/
├── src/
│   └── ...
└── tests/
    ├── winningChances.test.ts
    ├── once.test.ts
    └── ...

import { test, describe } from 'node:test';
import assert from 'node:assert';
import { winningChances } from '../src/winningChances';

describe('winningChances', () => {
  test('returns 50% for even positions', () => {
    assert.strictEqual(winningChances(0), 0.5);
  });
  
  test('returns 95% for +300 centipawns', () => {
    assert.strictEqual(winningChances(300), 0.95);
  });
  
  test('returns 5% for -300 centipawns', () => {
    assert.strictEqual(winningChances(-300), 0.05);
  });
});

ui/test -w

✓ ui/lib/tests/winningChances.test.ts (3 tests)
✓ ui/lib/tests/once.test.ts (2 tests)

Watching for changes...

# .github/workflows/test.yml
- name: Run Scala tests
  run: sbt test

- name: Run UI tests
  run: ui/test

# Install pre-commit hook
echo '#!/bin/bash\nsbt test && ui/test' > .git/hooks/pre-commit
chmod +x .git/hooks/pre-commit

test("debug example"):
  val result = MyClass.doSomething()
  println(s"Result: $result")  // Debug output
  assertEquals(result, expected)

testOnly lila.mymodule.MyTest -- -v

node --inspect ui/.test/runner.mjs

test('debug example', () => {
  const result = myFunction();
  console.log('Result:', result);  // Debug output
  assert.strictEqual(result, expected);
});

import scala.concurrent.duration.*

test("performance benchmark"):
  val start = System.nanoTime()
  
  (1 to 1000).foreach: _ =>
    MyClass.expensiveOperation()
  
  val duration = Duration.fromNanos(System.nanoTime() - start)
  assert(duration < 1.second, s"Too slow: $duration")

test('performance test', async () => {
  const start = performance.now();
  
  await expensiveOperation();
  
  const duration = performance.now() - start;
  assert(duration < 1000, `Too slow: ${duration}ms`);
});

// Run tests in parallel (if safe)
Test / parallelExecution := true

// Or disable for specific module
game / Test / parallelExecution := false