diff --git a/config.json b/config.json
index 7e4095a1..286ef482 100644
--- a/config.json
+++ b/config.json
@@ -1059,6 +1059,14 @@
         "prerequisites": [],
         "difficulty": 5
       },
+      {
+        "slug": "bowling",
+        "name": "Bowling",
+        "uuid": "b31afb14-1bed-44f4-963c-f08d8e9a7b35",
+        "practices": [],
+        "prerequisites": [],
+        "difficulty": 6
+      },
       {
         "slug": "change",
         "name": "Change",
diff --git a/exercises/practice/bowling/.docs/instructions.md b/exercises/practice/bowling/.docs/instructions.md
new file mode 100644
index 00000000..60ccad1b
--- /dev/null
+++ b/exercises/practice/bowling/.docs/instructions.md
@@ -0,0 +1,56 @@
+# Instructions
+
+Score a bowling game.
+
+Bowling is a game where players roll a heavy ball to knock down pins arranged in a triangle.
+Write code to keep track of the score of a game of bowling.
+
+## Scoring Bowling
+
+The game consists of 10 frames.
+A frame is composed of one or two ball throws with 10 pins standing at frame initialization.
+There are three cases for the tabulation of a frame.
+
+- An open frame is where a score of less than 10 is recorded for the frame.
+  In this case the score for the frame is the number of pins knocked down.
+
+- A spare is where all ten pins are knocked down by the second throw.
+  The total value of a spare is 10 plus the number of pins knocked down in their next throw.
+
+- A strike is where all ten pins are knocked down by the first throw.
+  The total value of a strike is 10 plus the number of pins knocked down in the next two throws.
+  If a strike is immediately followed by a second strike, then the value of the first strike cannot be determined until the ball is thrown one more time.
+
+Here is a three frame example:
+
+|  Frame 1   |  Frame 2   |     Frame 3      |
+| :--------: | :--------: | :--------------: |
+| X (strike) | 5/ (spare) | 9 0 (open frame) |
+
+Frame 1 is (10 + 5 + 5) = 20
+
+Frame 2 is (5 + 5 + 9) = 19
+
+Frame 3 is (9 + 0) = 9
+
+This means the current running total is 48.
+
+The tenth frame in the game is a special case.
+If someone throws a spare or a strike then they get one or two fill balls respectively.
+Fill balls exist to calculate the total of the 10th frame.
+Scoring a strike or spare on the fill ball does not give the player more fill balls.
+The total value of the 10th frame is the total number of pins knocked down.
+
+For a tenth frame of X1/ (strike and a spare), the total value is 20.
+
+For a tenth frame of XXX (three strikes), the total value is 30.
+
+## Requirements
+
+Write code to keep track of the score of a game of bowling.
+It should support two operations:
+
+- `roll(pins : int)` is called each time the player rolls a ball.
+  The argument is the number of pins knocked down.
+- `score() : int` is called only at the very end of the game.
+  It returns the total score for that game.
diff --git a/exercises/practice/bowling/.meta/config.json b/exercises/practice/bowling/.meta/config.json
new file mode 100644
index 00000000..22bf2725
--- /dev/null
+++ b/exercises/practice/bowling/.meta/config.json
@@ -0,0 +1,19 @@
+{
+  "authors": [
+    "keiravillekode"
+  ],
+  "files": {
+    "solution": [
+      "bowling.zig"
+    ],
+    "test": [
+      "test_bowling.zig"
+    ],
+    "example": [
+      ".meta/example.zig"
+    ]
+  },
+  "blurb": "Score a bowling game.",
+  "source": "The Bowling Game Kata from UncleBob",
+  "source_url": "https://web.archive.org/web/20221001111000/http://butunclebob.com/ArticleS.UncleBob.TheBowlingGameKata"
+}
diff --git a/exercises/practice/bowling/.meta/example.zig b/exercises/practice/bowling/.meta/example.zig
new file mode 100644
index 00000000..22cadd06
--- /dev/null
+++ b/exercises/practice/bowling/.meta/example.zig
@@ -0,0 +1,100 @@
+pub const Error = error{ GameOver, PinCountExceeded, GameIncomplete };
+
+pub const Strikes = enum {
+    two,
+    one,
+    half,
+    zero,
+};
+
+pub const Game = struct {
+    total: u32,
+    frames: u32,
+    pins: u32,
+    strikes: Strikes,
+
+    /// Initializes a Game.
+    pub fn init() Game {
+        return .{
+            .total = 0,
+            .frames = 0,
+            .pins = 0,
+            .strikes = .zero,
+        };
+    }
+
+    pub fn isOver(self: Game) bool {
+        // After ten frames, the game continues while a strike or spare
+        // bonus is still owed.
+        return self.frames >= 10 and self.strikes == .zero;
+    }
+
+    /// Records a roll that knocks down `pins` pins.
+    pub fn roll(self: *Game, pins: u5) Error!void {
+        if (self.isOver()) {
+            return Error.GameOver;
+        }
+
+        const limit: u32 = if (self.pins == 0) 10 else self.pins;
+        if (pins > limit) {
+            return Error.PinCountExceeded;
+        }
+
+        if (self.frames < 10) {
+            self.total += pins;
+        }
+        switch (self.strikes) {
+            .two => {
+                self.total += 2 * pins;
+            },
+            .one, .half => {
+                self.total += pins;
+            },
+            .zero => {},
+        }
+
+        if (self.pins == 0) {
+            self.pins = 10 - pins;
+
+            if (pins == 10) {
+                if (self.frames < 10) {
+                    if ((self.strikes == .two) or (self.strikes == .one)) {
+                        self.strikes = .two;
+                    } else {
+                        self.strikes = .one;
+                    }
+                } else {
+                    if ((self.strikes == .two) or (self.strikes == .one)) {
+                        self.strikes = .half;
+                    } else {
+                        self.strikes = .zero;
+                    }
+                }
+                self.frames += 1;
+            } else {
+                if ((self.strikes == .two) or (self.strikes == .one)) {
+                    self.strikes = .half;
+                } else {
+                    self.strikes = .zero;
+                }
+            }
+        } else {
+            if (pins == self.pins) {
+                self.strikes = if (self.frames < 10) .half else .zero;
+            } else {
+                self.strikes = .zero;
+            }
+            self.frames += 1;
+            self.pins = 0;
+        }
+    }
+
+    /// Returns the score of a complete game.
+    pub fn score(self: Game) Error!u32 {
+        if (!self.isOver()) {
+            return Error.GameIncomplete;
+        }
+
+        return self.total;
+    }
+};
diff --git a/exercises/practice/bowling/.meta/tests.toml b/exercises/practice/bowling/.meta/tests.toml
new file mode 100644
index 00000000..f3b3cee3
--- /dev/null
+++ b/exercises/practice/bowling/.meta/tests.toml
@@ -0,0 +1,105 @@
+# This is an auto-generated file.
+#
+# Regenerating this file via `configlet sync` will:
+# - Recreate every `description` key/value pair
+# - Recreate every `reimplements` key/value pair, where they exist in problem-specifications
+# - Remove any `include = true` key/value pair (an omitted `include` key implies inclusion)
+# - Preserve any other key/value pair
+#
+# As user-added comments (using the # character) will be removed when this file
+# is regenerated, comments can be added via a `comment` key.
+
+[656ae006-25c2-438c-a549-f338e7ec7441]
+description = "should be able to score a game with all zeros"
+
+[f85dcc56-cd6b-4875-81b3-e50921e3597b]
+description = "should be able to score a game with no strikes or spares"
+
+[d1f56305-3ac2-4fe0-8645-0b37e3073e20]
+description = "a spare followed by zeros is worth ten points"
+
+[0b8c8bb7-764a-4287-801a-f9e9012f8be4]
+description = "points scored in the roll after a spare are counted twice"
+
+[4d54d502-1565-4691-84cd-f29a09c65bea]
+description = "consecutive spares each get a one roll bonus"
+
+[e5c9cf3d-abbe-4b74-ad48-34051b2b08c0]
+description = "a spare in the last frame gets a one roll bonus that is counted once"
+
+[75269642-2b34-4b72-95a4-9be28ab16902]
+description = "a strike earns ten points in a frame with a single roll"
+
+[037f978c-5d01-4e49-bdeb-9e20a2e6f9a6]
+description = "points scored in the two rolls after a strike are counted twice as a bonus"
+
+[1635e82b-14ec-4cd1-bce4-4ea14bd13a49]
+description = "consecutive strikes each get the two roll bonus"
+
+[e483e8b6-cb4b-4959-b310-e3982030d766]
+description = "a strike in the last frame gets a two roll bonus that is counted once"
+
+[9d5c87db-84bc-4e01-8e95-53350c8af1f8]
+description = "rolling a spare with the two roll bonus does not get a bonus roll"
+
+[576faac1-7cff-4029-ad72-c16bcada79b5]
+description = "strikes with the two roll bonus do not get bonus rolls"
+
+[efb426ec-7e15-42e6-9b96-b4fca3ec2359]
+description = "last two strikes followed by only last bonus with non strike points"
+
+[72e24404-b6c6-46af-b188-875514c0377b]
+description = "a strike with the one roll bonus after a spare in the last frame does not get a bonus"
+
+[62ee4c72-8ee8-4250-b794-234f1fec17b1]
+description = "all strikes is a perfect game"
+
+[1245216b-19c6-422c-b34b-6e4012d7459f]
+description = "rolls cannot score negative points"
+include = false
+comment = "a negative roll is unrepresentable: roll takes an unsigned integer"
+
+[5fcbd206-782c-4faa-8f3a-be5c538ba841]
+description = "a roll cannot score more than 10 points"
+
+[fb023c31-d842-422d-ad7e-79ce1db23c21]
+description = "two rolls in a frame cannot score more than 10 points"
+
+[6082d689-d677-4214-80d7-99940189381b]
+description = "bonus roll after a strike in the last frame cannot score more than 10 points"
+
+[e9565fe6-510a-4675-ba6b-733a56767a45]
+description = "two bonus rolls after a strike in the last frame cannot score more than 10 points"
+
+[2f6acf99-448e-4282-8103-0b9c7df99c3d]
+description = "two bonus rolls after a strike in the last frame can score more than 10 points if one is a strike"
+
+[6380495a-8bc4-4cdb-a59f-5f0212dbed01]
+description = "the second bonus rolls after a strike in the last frame cannot be a strike if the first one is not a strike"
+
+[2b2976ea-446c-47a3-9817-42777f09fe7e]
+description = "second bonus roll after a strike in the last frame cannot score more than 10 points"
+
+[29220245-ac8d-463d-bc19-98a94cfada8a]
+description = "an unstarted game cannot be scored"
+
+[4473dc5d-1f86-486f-bf79-426a52ddc955]
+description = "an incomplete game cannot be scored"
+
+[2ccb8980-1b37-4988-b7d1-e5701c317df3]
+description = "cannot roll if game already has ten frames"
+
+[4864f09b-9df3-4b65-9924-c595ed236f1b]
+description = "bonus rolls for a strike in the last frame must be rolled before score can be calculated"
+
+[537f4e37-4b51-4d1c-97e2-986eb37b2ac1]
+description = "both bonus rolls for a strike in the last frame must be rolled before score can be calculated"
+
+[8134e8c1-4201-4197-bf9f-1431afcde4b9]
+description = "bonus roll for a spare in the last frame must be rolled before score can be calculated"
+
+[9d4a9a55-134a-4bad-bae8-3babf84bd570]
+description = "cannot roll after bonus roll for spare"
+
+[d3e02652-a799-4ae3-b53b-68582cc604be]
+description = "cannot roll after bonus rolls for strike"
diff --git a/exercises/practice/bowling/bowling.zig b/exercises/practice/bowling/bowling.zig
new file mode 100644
index 00000000..475f68b1
--- /dev/null
+++ b/exercises/practice/bowling/bowling.zig
@@ -0,0 +1,23 @@
+pub const Error = error{ GameOver, PinCountExceeded, GameIncomplete };
+
+pub const Game = struct {
+    // This struct, as well as its fields and methods, needs to be implemented.
+
+    /// Initializes a Game.
+    pub fn init() Game {
+        @compileError("please implement the init function");
+    }
+
+    /// Records a roll that knocks down `pins` pins.
+    pub fn roll(self: *Game, pins: u4) Error!void {
+        _ = self;
+        _ = pins;
+        @compileError("please implement the roll function");
+    }
+
+    /// Returns the score of a complete game.
+    pub fn score(self: Game) Error!u32 {
+        _ = self;
+        @compileError("please implement the score function");
+    }
+};
diff --git a/exercises/practice/bowling/test_bowling.zig b/exercises/practice/bowling/test_bowling.zig
new file mode 100644
index 00000000..2cf9d4d7
--- /dev/null
+++ b/exercises/practice/bowling/test_bowling.zig
@@ -0,0 +1,240 @@
+const std = @import("std");
+const testing = std.testing;
+
+const bowling = @import("bowling.zig");
+const Game = bowling.Game;
+const Error = bowling.Error;
+
+test "should be able to score a game with all zeros" {
+    var game = Game.init();
+    for ([_]u4{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }) |pins| {
+        try game.roll(pins);
+    }
+    try testing.expectEqual(0, game.score());
+}
+
+test "should be able to score a game with no strikes or spares" {
+    var game = Game.init();
+    for ([_]u4{ 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6 }) |pins| {
+        try game.roll(pins);
+    }
+    try testing.expectEqual(90, game.score());
+}
+
+test "a spare followed by zeros is worth ten points" {
+    var game = Game.init();
+    for ([_]u4{ 6, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }) |pins| {
+        try game.roll(pins);
+    }
+    try testing.expectEqual(10, game.score());
+}
+
+test "points scored in the roll after a spare are counted twice" {
+    var game = Game.init();
+    for ([_]u4{ 6, 4, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }) |pins| {
+        try game.roll(pins);
+    }
+    try testing.expectEqual(16, game.score());
+}
+
+test "consecutive spares each get a one roll bonus" {
+    var game = Game.init();
+    for ([_]u4{ 5, 5, 3, 7, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }) |pins| {
+        try game.roll(pins);
+    }
+    try testing.expectEqual(31, game.score());
+}
+
+test "a spare in the last frame gets a one roll bonus that is counted once" {
+    var game = Game.init();
+    for ([_]u4{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 3, 7 }) |pins| {
+        try game.roll(pins);
+    }
+    try testing.expectEqual(17, game.score());
+}
+
+test "a strike earns ten points in a frame with a single roll" {
+    var game = Game.init();
+    for ([_]u4{ 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }) |pins| {
+        try game.roll(pins);
+    }
+    try testing.expectEqual(10, game.score());
+}
+
+test "points scored in the two rolls after a strike are counted twice as a bonus" {
+    var game = Game.init();
+    for ([_]u4{ 10, 5, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }) |pins| {
+        try game.roll(pins);
+    }
+    try testing.expectEqual(26, game.score());
+}
+
+test "consecutive strikes each get the two roll bonus" {
+    var game = Game.init();
+    for ([_]u4{ 10, 10, 10, 5, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }) |pins| {
+        try game.roll(pins);
+    }
+    try testing.expectEqual(81, game.score());
+}
+
+test "a strike in the last frame gets a two roll bonus that is counted once" {
+    var game = Game.init();
+    for ([_]u4{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 7, 1 }) |pins| {
+        try game.roll(pins);
+    }
+    try testing.expectEqual(18, game.score());
+}
+
+test "rolling a spare with the two roll bonus does not get a bonus roll" {
+    var game = Game.init();
+    for ([_]u4{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 7, 3 }) |pins| {
+        try game.roll(pins);
+    }
+    try testing.expectEqual(20, game.score());
+}
+
+test "strikes with the two roll bonus do not get bonus rolls" {
+    var game = Game.init();
+    for ([_]u4{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 10, 10 }) |pins| {
+        try game.roll(pins);
+    }
+    try testing.expectEqual(30, game.score());
+}
+
+test "last two strikes followed by only last bonus with non strike points" {
+    var game = Game.init();
+    for ([_]u4{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 10, 0, 1 }) |pins| {
+        try game.roll(pins);
+    }
+    try testing.expectEqual(31, game.score());
+}
+
+test "a strike with the one roll bonus after a spare in the last frame does not get a bonus" {
+    var game = Game.init();
+    for ([_]u4{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 3, 10 }) |pins| {
+        try game.roll(pins);
+    }
+    try testing.expectEqual(20, game.score());
+}
+
+test "all strikes is a perfect game" {
+    var game = Game.init();
+    for ([_]u4{ 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10 }) |pins| {
+        try game.roll(pins);
+    }
+    try testing.expectEqual(300, game.score());
+}
+
+test "a roll cannot score more than 10 points" {
+    var game = Game.init();
+    try testing.expectError(Error.PinCountExceeded, game.roll(11));
+}
+
+test "two rolls in a frame cannot score more than 10 points" {
+    var game = Game.init();
+    for ([_]u4{5}) |pins| {
+        try game.roll(pins);
+    }
+    try testing.expectError(Error.PinCountExceeded, game.roll(6));
+}
+
+test "bonus roll after a strike in the last frame cannot score more than 10 points" {
+    var game = Game.init();
+    for ([_]u4{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10 }) |pins| {
+        try game.roll(pins);
+    }
+    try testing.expectError(Error.PinCountExceeded, game.roll(11));
+}
+
+test "two bonus rolls after a strike in the last frame cannot score more than 10 points" {
+    var game = Game.init();
+    for ([_]u4{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 5 }) |pins| {
+        try game.roll(pins);
+    }
+    try testing.expectError(Error.PinCountExceeded, game.roll(6));
+}
+
+test "two bonus rolls after a strike in the last frame can score more than 10 points if one is a strike" {
+    var game = Game.init();
+    for ([_]u4{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 10, 6 }) |pins| {
+        try game.roll(pins);
+    }
+    try testing.expectEqual(26, game.score());
+}
+
+test "the second bonus rolls after a strike in the last frame cannot be a strike if the first one is not a strike" {
+    var game = Game.init();
+    for ([_]u4{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 6 }) |pins| {
+        try game.roll(pins);
+    }
+    try testing.expectError(Error.PinCountExceeded, game.roll(10));
+}
+
+test "second bonus roll after a strike in the last frame cannot score more than 10 points" {
+    var game = Game.init();
+    for ([_]u4{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 10 }) |pins| {
+        try game.roll(pins);
+    }
+    try testing.expectError(Error.PinCountExceeded, game.roll(11));
+}
+
+test "an unstarted game cannot be scored" {
+    const game = Game.init();
+    try testing.expectError(Error.GameIncomplete, game.score());
+}
+
+test "an incomplete game cannot be scored" {
+    var game = Game.init();
+    for ([_]u4{ 0, 0 }) |pins| {
+        try game.roll(pins);
+    }
+    try testing.expectError(Error.GameIncomplete, game.score());
+}
+
+test "cannot roll if game already has ten frames" {
+    var game = Game.init();
+    for ([_]u4{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }) |pins| {
+        try game.roll(pins);
+    }
+    try testing.expectError(Error.GameOver, game.roll(0));
+}
+
+test "bonus rolls for a strike in the last frame must be rolled before score can be calculated" {
+    var game = Game.init();
+    for ([_]u4{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10 }) |pins| {
+        try game.roll(pins);
+    }
+    try testing.expectError(Error.GameIncomplete, game.score());
+}
+
+test "both bonus rolls for a strike in the last frame must be rolled before score can be calculated" {
+    var game = Game.init();
+    for ([_]u4{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 10 }) |pins| {
+        try game.roll(pins);
+    }
+    try testing.expectError(Error.GameIncomplete, game.score());
+}
+
+test "bonus roll for a spare in the last frame must be rolled before score can be calculated" {
+    var game = Game.init();
+    for ([_]u4{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 3 }) |pins| {
+        try game.roll(pins);
+    }
+    try testing.expectError(Error.GameIncomplete, game.score());
+}
+
+test "cannot roll after bonus roll for spare" {
+    var game = Game.init();
+    for ([_]u4{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 3, 2 }) |pins| {
+        try game.roll(pins);
+    }
+    try testing.expectError(Error.GameOver, game.roll(2));
+}
+
+test "cannot roll after bonus rolls for strike" {
+    var game = Game.init();
+    for ([_]u4{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 3, 2 }) |pins| {
+        try game.roll(pins);
+    }
+    try testing.expectError(Error.GameOver, game.roll(2));
+}
diff --git a/generators/exercises/bowling.py b/generators/exercises/bowling.py
new file mode 100644
index 00000000..741cbe50
--- /dev/null
+++ b/generators/exercises/bowling.py
@@ -0,0 +1,33 @@
+HEADER = """const Game = bowling.Game;
+const Error = bowling.Error;
+"""
+
+ERRORS = {
+    "Cannot roll after game is over": "GameOver",
+    "Pin count exceeds pins on the lane": "PinCountExceeded",
+    "Score cannot be taken until the end of the game": "GameIncomplete",
+}
+
+
+def gen_case(case):
+    inp = case["input"]
+    exp = case["expected"]
+    rolls = inp["previousRolls"]
+
+    mutated = rolls or case["property"] == "roll"
+    out = f"{'var' if mutated else 'const'} game = Game.init();\n"
+    if rolls:
+        joined = ", ".join(map(str, rolls))
+        out += f"for ([_]u4{{ {joined} }}) |pins| {{\n"
+        out += "try game.roll(pins);\n"
+        out += "}\n"
+
+    if case["property"] == "roll":
+        error = ERRORS[exp["error"]]
+        out += f"try testing.expectError(Error.{error}, game.roll({inp['roll']}));\n"
+    elif isinstance(exp, dict):
+        error = ERRORS[exp["error"]]
+        out += f"try testing.expectError(Error.{error}, game.score());\n"
+    else:
+        out += f"try testing.expectEqual({exp}, game.score());\n"
+    return out