Unit tests that check a design

Python 3.14 · main.py

TESTS = """\
R4 60 minutes cost 40 | pay 60 | 40
R4 61 minutes cost 80 | pay 61 | 80
R5 paid only once | pay 45; pay 50 | refused: paid, not active
R6 no exit unpaid | exit | refused: active, not paid
R6 exit when paid | pay 30; exit | exited
"""


class Refused(Exception):
    pass


class Ticket:
    def __init__(self, entered_at: int) -> None:
        self.entered_at = entered_at
        self.state = "active"

    def pay(self, at: int) -> int:
        self._move("active", "paid")
        return max(1, (at - self.entered_at + 59) // 60) * 40  # rupees an hour

    def exit(self) -> None:
        self._move("paid", "exited")

    def _move(self, before: str, after: str) -> None:
        if self.state != before:
            raise Refused(f"{self.state}, not {before}")
        self.state = after


def step(ticket: Ticket, command: str) -> str:
    try:
        if command == "exit":
            ticket.exit()
            return "exited"
        return str(ticket.pay(int(command.removeprefix("pay "))))
    except Refused as refusal:
        return f"refused: {refusal}"


passed = 0
tests = TESTS.splitlines()
for test in tests:
    rule, steps, expected = test.split(" | ")
    ticket = Ticket(entered_at=0)  # a fresh ticket for every test
    got = [step(ticket, command) for command in steps.split("; ")][-1]
    if got == expected:
        passed += 1
        print(f"ok    {rule}")
    else:
        print(f"FAIL  {rule}: got {got}")
print(f"{passed} of {len(tests)} tests pass")

In Python: Refused is the program's own exception, so a test can tell a rule's refusal from a bug such as a TypeError. The list comprehension runs every step, and [-1] keeps the last outcome.

Recorded with CPython 3.14.8 on macOS 26 arm64. It runs in your browser with Pyodide 314.0.7 (CPython 3.14.2). To run it yourself: python3 main.py

JavaScript Node 24 · main.mjs

const TESTS = `R4 60 minutes cost 40 | pay 60 | 40
R4 61 minutes cost 80 | pay 61 | 80
R5 paid only once | pay 45; pay 50 | refused: paid, not active
R6 no exit unpaid | exit | refused: active, not paid
R6 exit when paid | pay 30; exit | exited`;

class Refused extends Error {}

class Ticket {
  #state = "active";

  constructor(enteredAt) {
    this.enteredAt = enteredAt;
  }

  pay(at) {
    this.#move("active", "paid");
    return Math.max(1, Math.floor((at - this.enteredAt + 59) / 60)) * 40; // rupees an hour
  }

  exit() {
    this.#move("paid", "exited");
  }

  #move(before, after) {
    if (this.#state !== before) {
      throw new Refused(`${this.#state}, not ${before}`);
    }
    this.#state = after;
  }
}

function step(ticket, command) {
  try {
    if (command === "exit") {
      ticket.exit();
      return "exited";
    }
    return String(ticket.pay(Number(command.slice("pay ".length))));
  } catch (error) {
    if (!(error instanceof Refused)) throw error;
    return `refused: ${error.message}`;
  }
}

let passed = 0;
const tests = TESTS.split("\n");
for (const test of tests) {
  const [rule, steps, expected] = test.split(" | ");
  const ticket = new Ticket(0); // a fresh ticket for every test
  const got = steps
    .split("; ")
    .map((command) => step(ticket, command))
    .at(-1);
  if (got === expected) {
    passed += 1;
    console.log(`ok    ${rule}`);
  } else {
    console.log(`FAIL  ${rule}: got ${got}`);
  }
}
console.log(`${passed} of ${tests.length} tests pass`);

In JavaScript: A refusal is a Refused, a subclass of Error, and step() throws anything else on, so a bug is never mistaken for a refusal.

Recorded with Node.js 24.21.0 LTS (V8 13.6) on macOS 26 arm64. It runs in your browser with QuickJS (quickjs-emscripten 0.32.0). To run it yourself: node main.mjs

Java 25 LTS · Main.java

public class Main {
  static final String TESTS =
      """
      R4 60 minutes cost 40 | pay 60 | 40
      R4 61 minutes cost 80 | pay 61 | 80
      R5 paid only once | pay 45; pay 50 | refused: paid, not active
      R6 no exit unpaid | exit | refused: active, not paid
      R6 exit when paid | pay 30; exit | exited
      """;

  static final class Ticket {
    private final int enteredAt;
    private String state = "active";

    Ticket(int enteredAt) {
      this.enteredAt = enteredAt;
    }

    int pay(int at) {
      move("active", "paid");
      return Math.max(1, (at - enteredAt + 59) / 60) * 40; // rupees an hour
    }

    void exit() {
      move("paid", "exited");
    }

    private void move(String before, String after) {
      if (!state.equals(before)) {
        throw new IllegalStateException(state + ", not " + before);
      }
      state = after;
    }
  }

  static String step(Ticket ticket, String command) {
    try {
      if (command.equals("exit")) {
        ticket.exit();
        return "exited";
      }
      return String.valueOf(ticket.pay(Integer.parseInt(command.substring("pay ".length()))));
    } catch (IllegalStateException refusal) {
      return "refused: " + refusal.getMessage();
    }
  }

  public static void main(String[] args) {
    String[] tests = TESTS.split("\n");
    int passed = 0;
    for (String test : tests) {
      String[] part = test.split(" \\| ");
      Ticket ticket = new Ticket(0); // a fresh ticket for every test
      String got = "";
      for (String command : part[1].split("; ")) {
        got = step(ticket, command);
      }
      if (got.equals(part[2])) {
        passed++;
        System.out.println("ok    " + part[0]);
      } else {
        System.out.println("FAIL  " + part[0] + ": got " + got);
      }
    }
    System.out.println(passed + " of " + tests.length + " tests pass");
  }
}

In Java: A refusal is an IllegalStateException, the standard exception for a method called at the wrong time, so the program needs no exception class of its own.

Recorded with OpenJDK 25.0.4.1 LTS (Eclipse Temurin) on macOS 26 arm64. It runs in your browser with a TeaVM 0.16.0 build in QuickJS (quickjs-emscripten 0.32.0). To run it yourself: java Main.java

C++23 · main.cpp

#include <algorithm>
#include <expected>
#include <optional>
#include <print>
#include <ranges>
#include <string>
#include <string_view>
#include <utility>
#include <vector>

constexpr std::string_view tests = R"(R4 60 minutes cost 40 | pay 60 | 40
R4 61 minutes cost 80 | pay 61 | 80
R5 paid only once | pay 45; pay 50 | refused: paid, not active
R6 no exit unpaid | exit | refused: active, not paid
R6 exit when paid | pay 30; exit | exited)";

class Ticket {
public:
  explicit Ticket(int enteredAt) : enteredAt_(enteredAt) {}

  std::expected<int, std::string> pay(int at) {
    if (auto refused = move("active", "paid")) {
      return std::unexpected(*refused);
    }
    return std::max(1, (at - enteredAt_ + 59) / 60) * 40; // rupees an hour
  }
  std::optional<std::string> exit() { return move("paid", "exited"); }

private:
  std::optional<std::string> move(std::string_view before, std::string after) {
    if (state_ != before) {
      return state_ + ", not " + std::string(before);
    }
    state_ = std::move(after);
    return std::nullopt;
  }
  int enteredAt_;
  std::string state_ = "active";
};

std::string step(Ticket &ticket, std::string_view command) {
  if (command == "exit") {
    const auto refused = ticket.exit();
    return refused ? "refused: " + *refused : "exited";
  }
  const auto fee = ticket.pay(std::stoi(std::string(command.substr(4))));
  return fee ? std::to_string(*fee) : "refused: " + fee.error();
}

std::vector<std::string> split(std::string_view text, std::string_view by) {
  return text | std::views::split(by) |
         std::ranges::to<std::vector<std::string>>();
}

int main() {
  const auto lines = split(tests, "\n");
  int passed = 0;
  for (const auto &test : lines) {
    const auto part = split(test, " | ");
    Ticket ticket(0); // a fresh ticket for every test
    std::string got;
    for (const auto &command : split(part[1], "; ")) {
      got = step(ticket, command);
    }
    if (got == part[2]) {
      ++passed;
      std::println("ok    {}", part[0]);
    } else {
      std::println("FAIL  {}: got {}", part[0], got);
    }
  }
  std::println("{} of {} tests pass", passed, lines.size());
}

In C++: pay() returns std::expected, C++23's value-or-error type, and exit() an optional reason, so a refusal is a value that the test compares, as in Go and Rust; nothing is thrown.

Recorded with Apple clang 21.0.0 (C++23) and GCC 16.2.0 on macOS 26 arm64. It runs in your browser with Clang in WebAssembly (YoWASP) 22.0.0-git20542-10. To run it yourself: clang++ -std=c++23 -O2 -Wall -Wextra -Werror -pedantic -fsanitize=address,undefined main.cpp -o main && ./main

C# 14 · .NET 10 · app.cs

using System.Globalization;

const string Tests = """
    R4 60 minutes cost 40 | pay 60 | 40
    R4 61 minutes cost 80 | pay 61 | 80
    R5 paid only once | pay 45; pay 50 | refused: paid, not active
    R6 no exit unpaid | exit | refused: active, not paid
    R6 exit when paid | pay 30; exit | exited
    """;

string[] tests = Tests.Split('\n');
int passed = 0;
foreach (string test in tests)
{
    string[] part = test.Split(" | ");
    var ticket = new Ticket(0); // a fresh ticket for every test
    string got = "";
    foreach (string command in part[1].Split("; "))
    {
        got = Step(ticket, command);
    }
    if (got == part[2])
    {
        passed++;
        Console.WriteLine($"ok    {part[0]}");
    }
    else
    {
        Console.WriteLine($"FAIL  {part[0]}: got {got}");
    }
}
Console.WriteLine($"{passed} of {tests.Length} tests pass");

static string Step(Ticket ticket, string command)
{
    try
    {
        if (command == "exit")
        {
            ticket.Exit();
            return "exited";
        }
        int at = int.Parse(command["pay ".Length..], CultureInfo.InvariantCulture);
        return ticket.Pay(at).ToString(CultureInfo.InvariantCulture);
    }
    catch (InvalidOperationException refusal)
    {
        return $"refused: {refusal.Message}";
    }
}

class Ticket(int enteredAt)
{
    string state = "active";

    public int Pay(int at)
    {
        Move("active", "paid");
        return Math.Max(1, (at - enteredAt + 59) / 60) * 40; // rupees an hour
    }

    public void Exit() => Move("paid", "exited");

    void Move(string before, string after)
    {
        if (state != before)
        {
            throw new InvalidOperationException($"{state}, not {before}");
        }
        state = after;
    }
}

In C#: A refusal is an InvalidOperationException. The steps run in a foreach loop, because Select(...).Last() on an array would ask only the last element for its value, and the steps before it would never run.

Recorded with C# 14 on .NET 10.0.12 (SDK 10.0.401) on macOS 26 arm64. It runs in your browser with the .NET runtime for WebAssembly 10.0.12. To run it yourself: dotnet run app.cs

C23 · main.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

static const struct {
  const char *rule, *steps, *expected;
} TESTS[] = {
    {"R4 60 minutes cost 40", "pay 60", "40"},
    {"R4 61 minutes cost 80", "pay 61", "80"},
    {"R5 paid only once", "pay 45; pay 50", "refused: paid, not active"},
    {"R6 no exit unpaid", "exit", "refused: active, not paid"},
    {"R6 exit when paid", "pay 30; exit", "exited"},
};

typedef struct {
  int entered_at;
  const char *state;
} Ticket;

// Moves the ticket on, or writes why it refuses and returns false.
static bool move(Ticket *ticket, const char *before, const char *after,
                 char *out, size_t size) {
  if (strcmp(ticket->state, before) != 0) {
    snprintf(out, size, "refused: %s, not %s", ticket->state, before);
    return false;
  }
  ticket->state = after;
  return true;
}

static void step(Ticket *ticket, const char *command, char *out, size_t size) {
  if (strcmp(command, "exit") == 0) {
    if (move(ticket, "paid", "exited", out, size)) {
      snprintf(out, size, "exited");
    }
  } else if (move(ticket, "active", "paid", out, size)) {
    int minutes = atoi(command + strlen("pay ")) - ticket->entered_at;
    int hours = (minutes + 59) / 60;
    snprintf(out, size, "%d", (hours > 1 ? hours : 1) * 40); // rupees an hour
  }
}

int main(void) {
  const size_t count = sizeof TESTS / sizeof TESTS[0];
  size_t passed = 0;
  for (size_t i = 0; i < count; i++) {
    Ticket ticket = {.entered_at = 0, .state = "active"}; // a fresh ticket
    char steps[64], got[64] = "";
    snprintf(steps, sizeof steps, "%s", TESTS[i].steps);
    for (char *command = strtok(steps, ";"); command;
         command = strtok(NULL, ";")) {
      step(&ticket, command + (command[0] == ' '), got, sizeof got);
    }
    if (strcmp(got, TESTS[i].expected) == 0) {
      passed++;
      printf("ok    %s\n", TESTS[i].rule);
    } else {
      printf("FAIL  %s: got %s\n", TESTS[i].rule, got);
    }
  }
  printf("%zu of %zu tests pass\n", passed, count);
  return 0;
}

In C: C has no exceptions, so move() writes the refusal into the caller's buffer and returns false. With no string split in the standard library, each test is a struct of three strings, and strtok walks the steps.

Recorded with Apple clang 21.0.0 (C23) and GCC 16.2.0 on macOS 26 arm64. It runs in your browser with Clang in WebAssembly (YoWASP) 22.0.0-git20542-10. To run it yourself: clang -std=c23 -O2 -Wall -Wextra -Werror -pedantic -fsanitize=address,undefined main.c -o main && ./main

PHP 8.5 · main.php

<?php

declare(strict_types=1);

const TESTS = <<<'TXT'
    R4 60 minutes cost 40 | pay 60 | 40
    R4 61 minutes cost 80 | pay 61 | 80
    R5 paid only once | pay 45; pay 50 | refused: paid, not active
    R6 no exit unpaid | exit | refused: active, not paid
    R6 exit when paid | pay 30; exit | exited
    TXT;

final class Refused extends RuntimeException {}

final class Ticket
{
    private string $state = 'active';

    public function __construct(private int $enteredAt) {}

    public function pay(int $at): int
    {
        $this->move('active', 'paid');
        return max(1, intdiv($at - $this->enteredAt + 59, 60)) * 40; // rupees an hour
    }

    public function exit(): void
    {
        $this->move('paid', 'exited');
    }

    private function move(string $before, string $after): void
    {
        if ($this->state !== $before) {
            throw new Refused("{$this->state}, not {$before}");
        }
        $this->state = $after;
    }
}

function step(Ticket $ticket, string $command): string
{
    try {
        if ($command === 'exit') {
            $ticket->exit();
            return 'exited';
        }
        return (string) $ticket->pay((int) substr($command, strlen('pay ')));
    } catch (Refused $refusal) {
        return "refused: {$refusal->getMessage()}";
    }
}

$tests = explode("\n", TESTS);
$passed = 0;
foreach ($tests as $test) {
    [$rule, $steps, $expected] = explode(' | ', $test);
    $ticket = new Ticket(0); // a fresh ticket for every test
    $outcomes = array_map(fn(string $command) => step($ticket, $command), explode('; ', $steps));
    $got = end($outcomes);
    if ($got === $expected) {
        $passed++;
        echo "ok    {$rule}\n";
    } else {
        echo "FAIL  {$rule}: got {$got}\n";
    }
}
echo "{$passed} of " . count($tests) . " tests pass\n";

In PHP: The table is a nowdoc, which PHP never interpolates, and the indentation of its closing marker is removed from every line. array_map runs every step, and end() returns the last outcome.

Recorded with PHP 8.5.11 (CLI) on macOS 26 arm64. It runs in your browser with php-wasm 0.2.0 (PHP 8.5.2). To run it yourself: php main.php

Rust 1.99 · main.rs

const TESTS: &str = "\
R4 60 minutes cost 40 | pay 60 | 40
R4 61 minutes cost 80 | pay 61 | 80
R5 paid only once | pay 45; pay 50 | refused: paid, not active
R6 no exit unpaid | exit | refused: active, not paid
R6 exit when paid | pay 30; exit | exited";

struct Ticket {
    entered_at: u32,
    state: &'static str,
}

impl Ticket {
    fn new(entered_at: u32) -> Self {
        Ticket {
            entered_at,
            state: "active",
        }
    }

    fn pay(&mut self, at: u32) -> Result<u32, String> {
        self.advance("active", "paid")?;
        Ok(((at - self.entered_at + 59) / 60).max(1) * 40) // rupees an hour
    }

    fn exit(&mut self) -> Result<(), String> {
        self.advance("paid", "exited")
    }

    fn advance(&mut self, before: &str, after: &'static str) -> Result<(), String> {
        if self.state != before {
            return Err(format!("{}, not {before}", self.state));
        }
        self.state = after;
        Ok(())
    }
}

fn step(ticket: &mut Ticket, command: &str) -> String {
    let outcome = match command.strip_prefix("pay ") {
        Some(at) => ticket
            .pay(at.parse().unwrap_or(0))
            .map(|fee| fee.to_string()),
        None => ticket.exit().map(|()| "exited".to_string()),
    };
    outcome.unwrap_or_else(|refusal| format!("refused: {refusal}"))
}

fn main() {
    let mut passed = 0;
    for test in TESTS.lines() {
        let parts: Vec<&str> = test.split(" | ").collect();
        let [rule, steps, expected] = parts[..] else {
            continue;
        };
        let mut ticket = Ticket::new(0); // a fresh ticket for every test
        let got = steps
            .split("; ")
            .map(|c| step(&mut ticket, c))
            .last()
            .unwrap_or_default();
        if got == expected {
            passed += 1;
            println!("ok    {rule}");
        } else {
            println!("FAIL  {rule}: got {got}");
        }
    }
    println!("{passed} of {} tests pass", TESTS.lines().count());
}

In Rust: pay() and exit() return a Result, so a refusal is an Err value that the ? operator passes on, and step turns it into the refusal's text with unwrap_or_else.

Recorded with rustc 1.99.0 (edition 2024) on macOS 26 arm64. It runs in your browser with a WebAssembly build on the WASI runner (browser_wasi_shim 0.4.2). To run it yourself: rustc --edition 2024 -O main.rs && ./main

TypeScript 6.0 · main.ts

const TESTS = `R4 60 minutes cost 40 | pay 60 | 40
R4 61 minutes cost 80 | pay 61 | 80
R5 paid only once | pay 45; pay 50 | refused: paid, not active
R6 no exit unpaid | exit | refused: active, not paid
R6 exit when paid | pay 30; exit | exited`;

type State = "active" | "paid" | "exited";

class Refused extends Error {}

class Ticket {
  readonly enteredAt: number;
  #state: State = "active";

  constructor(enteredAt: number) {
    this.enteredAt = enteredAt;
  }

  pay(at: number): number {
    this.#move("active", "paid");
    return Math.max(1, Math.floor((at - this.enteredAt + 59) / 60)) * 40; // rupees an hour
  }

  exit(): void {
    this.#move("paid", "exited");
  }

  #move(before: State, after: State): void {
    if (this.#state !== before) {
      throw new Refused(`${this.#state}, not ${before}`);
    }
    this.#state = after;
  }
}

function step(ticket: Ticket, command: string): string {
  try {
    if (command === "exit") {
      ticket.exit();
      return "exited";
    }
    return String(ticket.pay(Number(command.slice("pay ".length))));
  } catch (error) {
    if (!(error instanceof Refused)) throw error;
    return `refused: ${error.message}`;
  }
}

let passed = 0;
const tests = TESTS.split("\n");
for (const test of tests) {
  const [rule, steps, expected] = test.split(" | ");
  const ticket = new Ticket(0); // a fresh ticket for every test
  const got = steps
    .split("; ")
    .map((command) => step(ticket, command))
    .at(-1);
  if (got === expected) {
    passed += 1;
    console.log(`ok    ${rule}`);
  } else {
    console.log(`FAIL  ${rule}: got ${got}`);
  }
}
console.log(`${passed} of ${tests.length} tests pass`);

In TypeScript: State is a union of three string literals, so the compiler refuses a misspelt state such as "payed". There is no enum, because an enum is not erasable syntax.

Recorded with TypeScript 6.0.3 (strict), run by Node.js 24.21.0 on macOS 26 arm64. It runs in your browser with QuickJS (quickjs-emscripten 0.32.0) after Sucrase 3.35.1. To run it yourself: npx -p typescript@6.0.3 tsc --noEmit --strict main.ts && node main.ts

Go 1.27 · main.go

package main

import (
	"fmt"
	"strconv"
	"strings"
)

const tests = `R4 60 minutes cost 40 | pay 60 | 40
R4 61 minutes cost 80 | pay 61 | 80
R5 paid only once | pay 45; pay 50 | refused: paid, not active
R6 no exit unpaid | exit | refused: active, not paid
R6 exit when paid | pay 30; exit | exited`

type Ticket struct {
	enteredAt int
	state     string
}

func (t *Ticket) Pay(at int) (int, error) {
	if err := t.move("active", "paid"); err != nil {
		return 0, err
	}
	return max(1, (at-t.enteredAt+59)/60) * 40, nil // rupees an hour
}

func (t *Ticket) Exit() error {
	return t.move("paid", "exited")
}

func (t *Ticket) move(before, after string) error {
	if t.state != before {
		return fmt.Errorf("%s, not %s", t.state, before)
	}
	t.state = after
	return nil
}

func step(ticket *Ticket, command string) string {
	if command == "exit" {
		if err := ticket.Exit(); err != nil {
			return "refused: " + err.Error()
		}
		return "exited"
	}
	at, err := strconv.Atoi(strings.TrimPrefix(command, "pay "))
	if err != nil {
		return "refused: " + err.Error()
	}
	fee, err := ticket.Pay(at)
	if err != nil {
		return "refused: " + err.Error()
	}
	return strconv.Itoa(fee)
}

func main() {
	lines := strings.Split(tests, "\n")
	passed := 0
	for _, test := range lines {
		part := strings.Split(test, " | ")
		ticket := &Ticket{enteredAt: 0, state: "active"} // a fresh ticket for every test
		got := ""
		for _, command := range strings.Split(part[1], "; ") {
			got = step(ticket, command)
		}
		if got == part[2] {
			passed++
			fmt.Println("ok    " + part[0])
		} else {
			fmt.Printf("FAIL  %s: got %s\n", part[0], got)
		}
	}
	fmt.Printf("%d of %d tests pass\n", passed, len(lines))
}

In Go: Pay and Exit return an error as their last result, the way Go functions report failure, and step turns a non-nil error into the refusal's text.

Recorded with Go 1.27.1 on macOS 26 arm64. It runs in your browser with the Go compiler in WebAssembly 1.27.1. To run it yourself: go run main.go

Swift 6.4 · main.swift

let tests = """
  R4 60 minutes cost 40 | pay 60 | 40
  R4 61 minutes cost 80 | pay 61 | 80
  R5 paid only once | pay 45; pay 50 | refused: paid, not active
  R6 no exit unpaid | exit | refused: active, not paid
  R6 exit when paid | pay 30; exit | exited
  """

struct Refused: Error {
  let reason: String
}

struct Ticket {
  let enteredAt: Int
  private(set) var state = "active"

  mutating func pay(at: Int) throws(Refused) -> Int {
    try move(from: "active", to: "paid")
    return max(1, (at - enteredAt + 59) / 60) * 40  // rupees an hour
  }

  mutating func exit() throws(Refused) {
    try move(from: "paid", to: "exited")
  }

  private mutating func move(from before: String, to after: String) throws(Refused) {
    guard state == before else {
      throw Refused(reason: "\(state), not \(before)")
    }
    state = after
  }
}

func step(_ ticket: inout Ticket, _ command: String) -> String {
  do {
    if command == "exit" {
      try ticket.exit()
      return "exited"
    }
    return String(try ticket.pay(at: Int(command.dropFirst("pay ".count)) ?? 0))
  } catch {
    return "refused: \(error.reason)"
  }
}

extension Substring {
  /// The text without the spaces around it.
  var trimmed: String { String(drop { $0 == " " }.reversed().drop { $0 == " " }.reversed()) }
}

let lines = tests.split(separator: "\n")
var passed = 0
for test in lines {
  let part = test.split(separator: "|").map(\.trimmed)
  var ticket = Ticket(enteredAt: 0)  // a fresh ticket for every test
  var got = ""
  for command in Substring(part[1]).split(separator: ";") {
    got = step(&ticket, command.trimmed)
  }
  if got == part[2] {
    passed += 1
    print("ok    \(part[0])")
  } else {
    print("FAIL  \(part[0]): got \(got)")
  }
}
print("\(passed) of \(lines.count) tests pass")

In Swift: pay and exit use typed throws, throws(Refused), so the catch block knows the error is a Refused and reads its reason without a cast. Ticket is a struct, so step takes it inout.

Recorded with Apple Swift 6.4 on macOS 26 arm64. It runs in your browser with a WebAssembly build on the WASI runner (browser_wasi_shim 0.4.2). To run it yourself: swiftc -O main.swift -o main && ./main

Ruby 4.0 · main.rb

# frozen_string_literal: true

TESTS = <<~TXT
  R4 60 minutes cost 40 | pay 60 | 40
  R4 61 minutes cost 80 | pay 61 | 80
  R5 paid only once | pay 45; pay 50 | refused: paid, not active
  R6 no exit unpaid | exit | refused: active, not paid
  R6 exit when paid | pay 30; exit | exited
TXT

# A refusal that a rule of the ticket makes.
class Refused < StandardError; end

# A parking ticket, whose state moves from active to paid to exited.
class Ticket
  def initialize(entered_at)
    @entered_at = entered_at
    @state = 'active'
  end

  def pay(at)
    move('active', 'paid')
    [1, (at - @entered_at + 59) / 60].max * 40 # rupees an hour
  end

  def exit
    move('paid', 'exited')
  end

  private

  def move(before, after)
    raise Refused, "#{@state}, not #{before}" unless @state == before

    @state = after
  end
end

def step(ticket, command)
  return ticket.pay(Integer(command.delete_prefix('pay '))).to_s unless command == 'exit'

  ticket.exit
  'exited'
rescue Refused => e
  "refused: #{e.message}"
end

tests = TESTS.lines(chomp: true)
passed = 0
tests.each do |test|
  rule, steps, expected = test.split(' | ')
  ticket = Ticket.new(0) # a fresh ticket for every test
  got = steps.split('; ').map { |command| step(ticket, command) }.last
  if got == expected
    passed += 1
    puts "ok    #{rule}"
  else
    puts "FAIL  #{rule}: got #{got}"
  end
end
puts "#{passed} of #{tests.size} tests pass"

In Ruby: A refusal is a Refused, a StandardError of the program's own, and the rescue in step catches only that kind. The squiggly heredoc, <<~, removes the table's indentation.

Recorded with CRuby 4.0.7 on macOS 26 arm64. It runs in your browser with ruby.wasm 2.10.1 (Ruby 4.0.0). To run it yourself: ruby main.rb

Kotlin 2.4 · Main.kt

val tests =
    """
    R4 60 minutes cost 40 | pay 60 | 40
    R4 61 minutes cost 80 | pay 61 | 80
    R5 paid only once | pay 45; pay 50 | refused: paid, not active
    R6 no exit unpaid | exit | refused: active, not paid
    R6 exit when paid | pay 30; exit | exited
    """.trimIndent()

class Ticket(
    private val enteredAt: Int,
) {
    private var state = "active"

    fun pay(at: Int): Int {
        move("active", "paid")
        return maxOf(1, (at - enteredAt + 59) / 60) * 40 // rupees an hour
    }

    fun exit() = move("paid", "exited")

    private fun move(
        before: String,
        after: String,
    ) {
        check(state == before) { "$state, not $before" }
        state = after
    }
}

fun step(
    ticket: Ticket,
    command: String,
): String =
    try {
        if (command == "exit") {
            ticket.exit()
            "exited"
        } else {
            ticket.pay(command.removePrefix("pay ").toInt()).toString()
        }
    } catch (refusal: IllegalStateException) {
        "refused: ${refusal.message}"
    }

fun main() {
    val lines = tests.lines()
    var passed = 0
    for (test in lines) {
        val (rule, steps, expected) = test.split(" | ")
        val ticket = Ticket(0) // a fresh ticket for every test
        val got = steps.split("; ").map { step(ticket, it) }.last()
        if (got == expected) {
            passed++
            println("ok    $rule")
        } else {
            println("FAIL  $rule: got $got")
        }
    }
    println("$passed of ${lines.size} tests pass")
}

In Kotlin: check(condition) { message } throws an IllegalStateException with that message, the standard library's way to refuse a call made in the wrong state.

Recorded with Kotlin 2.4.20 on Java 25.0.4.1 on macOS 26 arm64. It runs in your browser with a WebAssembly build on the WASI runner (browser_wasi_shim 0.4.2). To run it yourself: kotlinc Main.kt -include-runtime -d main.jar && java -jar main.jar

Dart 3.13 · main.dart

const tests = '''
R4 60 minutes cost 40 | pay 60 | 40
R4 61 minutes cost 80 | pay 61 | 80
R5 paid only once | pay 45; pay 50 | refused: paid, not active
R6 no exit unpaid | exit | refused: active, not paid
R6 exit when paid | pay 30; exit | exited''';

class Ticket {
  Ticket(this.enteredAt);

  final int enteredAt;
  String _state = 'active';

  int pay(int at) {
    _move('active', 'paid');
    final hours = (at - enteredAt + 59) ~/ 60;
    return (hours < 1 ? 1 : hours) * 40; // rupees an hour
  }

  void exit() => _move('paid', 'exited');

  void _move(String before, String after) {
    if (_state != before) {
      throw StateError('$_state, not $before');
    }
    _state = after;
  }
}

String step(Ticket ticket, String command) {
  try {
    if (command == 'exit') {
      ticket.exit();
      return 'exited';
    }
    return '${ticket.pay(int.parse(command.substring('pay '.length)))}';
  } on StateError catch (refusal) {
    return 'refused: ${refusal.message}';
  }
}

void main() {
  final lines = tests.split('\n');
  var passed = 0;
  for (final test in lines) {
    final [rule, steps, expected] = test.split(' | ');
    final ticket = Ticket(0); // a fresh ticket for every test
    var got = '';
    for (final command in steps.split('; ')) {
      got = step(ticket, command);
    }
    if (got == expected) {
      passed++;
      print('ok    $rule');
    } else {
      print('FAIL  $rule: got $got');
    }
  }
  print('$passed of ${lines.length} tests pass');
}

In Dart: A refusal is a StateError. The steps run in a for loop, because map(...).last would call the function for the last step only, since map is lazy and last asks for the last element alone.

Recorded with Dart 3.13.5 on macOS 26 arm64. It runs in your browser with a WebAssembly build by dart2wasm 3.13.5. To run it yourself: dart run main.dart