Can Claude Fable 5.2 write working Godot 4 code? 15 of 15 on the first try
Claude Fable 5.2 passed 15 of 15 Godot 4 tasks on the first try and 15 of 15 after one fix with the test's output, each run headless on Godot 4.7.2. It missed none.
The main page on this subject is The best LLM for Godot.
AppImage, x86_64. Ubuntu 22.04, Debian 12, Fedora 39 or newer.
Intel or AMD Chromebook, with Linux turned on.
Every model measured on the same Godot 4 tasks, each run headless on Godot 4.7.2 at a fixed 60 frames per second.
Measured by Flockbay: the same tasks, the same checks, one fix allowed with the test output.
| Model | First try | After one fix | Agent | Run on | Read from |
|---|---|---|---|---|---|
| Claude Opus 5.5 | 15 of 15 | 15 of 15 | Claude Code | 2026-10-06 | Claude Opus 5.5 results |
| Claude Sonnet 5.5 | 15 of 15 | 15 of 15 | Claude Code | 2026-10-06 | Claude Sonnet 5.5 results |
| GPT-6.1 Sol | 15 of 15 | 15 of 15 | Codex | 2026-10-06 | GPT-6.1 Sol results |
| DeepSeek V4.1 Flash | 15 of 15 | 15 of 15 | Hosted, by API | 2026-10-18 | DeepSeek V4.1 Flash results |
| Ember-1 | 15 of 15 | 15 of 15 | Hosted, by API | 2026-10-18 | Ember-1 results |
| Gemini 3.1 Pro Preview | 15 of 15 | 15 of 15 | Hosted, by API | 2026-10-18 | Gemini 3.1 Pro Preview results |
| Muse Wonder | 15 of 15 | 15 of 15 | Hosted, by API | 2026-10-18 | Muse Wonder results |
| Kimi K3 | 15 of 15 | 15 of 15 | Hosted, by API | 2026-10-18 | Kimi K3 results |
| GPT-5.6 Luna | 15 of 15 | 15 of 15 | Hosted, by API | 2026-10-18 | GPT-5.6 Luna results |
| GPT-6 Luna | 15 of 15 | 15 of 15 | Hosted, by API | 2026-10-18 | GPT-6 Luna results |
| Hy4 preview | 15 of 15 | 15 of 15 | Hosted, by API | 2026-10-18 | Hy4 preview results |
| Pareto 26.10 | 15 of 15 | 15 of 15 | Hosted, by API | 2026-10-18 | Pareto 26.10 results |
| Claude Fable 5.2 | 15 of 15 | 15 of 15 | Hosted, by API | 2026-11-09 | Claude Fable 5.2 results |
| Claude Haiku 5.5 | 14 of 15 | 15 of 15 | Hosted, by API | 2026-10-18 | Claude Haiku 5.5 results |
| MiMo-V2.6-Pro-UltraSpeed | 14 of 15 | 15 of 15 | Hosted, by API | 2026-10-18 | MiMo-V2.6-Pro-UltraSpeed results |
| GLM 5.2 | 14 of 15 | 15 of 15 | Hosted, by API | 2026-10-18 | GLM 5.2 results |
| DeepSeek V4 Pro 0813 | 14 of 15 | 14 of 15 | Hosted, by API | 2026-10-18 | DeepSeek V4 Pro 0813 results |
| GPT-5.4 | 14 of 15 | 14 of 15 | Hosted, by API | 2026-10-18 | GPT-5.4 results |
| MiniMax M3 | 13 of 15 | 14 of 15 | Hosted, by API | 2026-10-18 | MiniMax M3 results |
| Qwen3.7 Max | 13 of 15 | 14 of 15 | Hosted, by API | 2026-10-18 | Qwen3.7 Max results |
| Fugu Max | 13 of 15 | 14 of 15 | Hosted, by API | 2026-10-18 | Fugu Max results |
| Beam 1.0 501B A23B | 12 of 15 | 14 of 15 | Hosted, by API | 2026-10-18 | Beam 1.0 501B A23B results |
| Mistral Large 4 | 12 of 15 | 13 of 15 | Hosted, by API | 2026-10-18 | Mistral Large 4 results |
| Claude Haiku 4.5 | 11 of 15 | 14 of 15 | Claude Code | 2026-10-06 | Claude Haiku 4.5 results |
| Nemotron 3.5 Super VL | 11 of 15 | 14 of 15 | Hosted, by API | 2026-10-18 | Nemotron 3.5 Super VL results |
| LongCat 2.0 | 11 of 15 | 13 of 15 | Hosted, by API | 2026-10-18 | LongCat 2.0 results |
| Grok 4.3 | 11 of 15 | 13 of 15 | Hosted, by API | 2026-10-18 | Grok 4.3 results |
| Laguna S 2.1 | 9 of 15 | 12 of 15 | Hosted, by API | 2026-10-18 | Laguna S 2.1 results |
| Nova 2 Lite | 2 of 15 | 4 of 15 | Hosted, by API | 2026-10-18 | Nova 2 Lite results |
How the test works
Each task asks for one GDScript file with a stated API, in a fresh Godot project. Claude Fable 5.2 was asked through its API, the way Flockbay reaches its hosted models: the task in one request, no tools, and the whole file back in a code block. A check scene then loaded the file and drove it on Godot 4.7.2, headless, at a fixed 60 frames per second: it pressed input actions, stepped physics, waited on timers and signals, and compared the results.
When a task failed, the model got the check's output once and could fix its file. Every task touches an API that changed between Godot 3 and Godot 4, or was added since: move_and_slide and is_on_floor, FileAccess and JSON, signals, tweens, Timer nodes, PackedScene, TileMapLayer, ray queries, AStarGrid2D, AnimationLibrary, and lambdas, which capture local variables by value.
The checks themselves are tested first: each passes on a reference answer and fails on an empty script. Run on 2026-11-09.
Move a CharacterBody2D with an input action: pass
The task: Write res://player.gd for Godot 4: a script for a CharacterBody2D that moves right at 200 pixels per second while the input action "ui_right" is held, and stands still otherwise.
Passed on the first try.
extends CharacterBody2D
const SPEED: float = 200.0
func _physics_process(_delta: float) -> void:
if Input.is_action_pressed("ui_right"):
velocity = Vector2(SPEED, 0.0)
else:
velocity = Vector2.ZERO
move_and_slide()
Fall with gravity and land on the floor: pass
The task: Write res://ball.gd for Godot 4: a script for a CharacterBody2D that falls with a gravity of 980 pixels per second squared and stops when it lands on the floor. The scene gives it its collision shape.
Passed on the first try.
extends CharacterBody2D
## Downward acceleration in pixels per second squared.
const GRAVITY: float = 980.0
func _physics_process(delta: float) -> void:
if is_on_floor():
# Landed: stop completely and stay at rest on the floor.
velocity = Vector2.ZERO
else:
# Airborne: accelerate downward.
velocity.y += GRAVITY * delta
move_and_slide()
A score label: pass
The task: Write res://score_label.gd for Godot 4: a script for a Label that shows "Score: 0" when it enters the scene, and has a method add(points: int) that adds to the score and updates the text to "Score: <total>".
Passed on the first try.
extends Label
var score: int = 0
func _ready() -> void:
_update_text()
func add(points: int) -> void:
score += points
_update_text()
func _update_text() -> void:
text = "Score: %d" % score
Save and load a dictionary as JSON: pass
The task: Write res://save_game.gd for Godot 4: a script extending RefCounted with two static functions: save_data(data: Dictionary, path: String) -> void writes the dictionary to the file as JSON, and load_data(path: String) -> Dictionary reads it back.
Passed on the first try.
extends RefCounted
## Static helpers for saving and loading a Dictionary as JSON.
##
## Usage:
## const SaveGame = preload("res://save_game.gd")
## SaveGame.save_data({"level": 3}, "user://save.json")
## var data: Dictionary = SaveGame.load_data("user://save.json")
## Writes [param data] to the file at [param path] as JSON.
static func save_data(data: Dictionary, path: String) -> void:
# Make sure the target directory exists (e.g. "user://saves/").
var dir_path := path.get_base_dir()
if not dir_path.is_empty() and not DirAccess.dir_exists_absolute(dir_path):
DirAccess.make_dir_recursive_absolute(dir_path)
var file := FileAccess.open(path, FileAccess.WRITE)
if file == null:
push_error("save_data: cannot open '%s' for writing: %s" % [
path, error_string(FileAccess.get_open_error())
])
return
file.store_string(JSON.stringify(data, "\t"))
file.close()
## Reads the JSON file at [param path] and returns its contents as a Dictionary.
## Returns an empty Dictionary if the file is missing, unreadable, or invalid.
static func load_data(path: String) -> Dictionary:
if not FileAccess.file_exists(path):
return {}
var file := FileAccess.open(path, FileAccess.READ)
if file == null:
push_error("load_data: cannot open '%s' for reading: %s" % [
path, error_string(FileAccess.get_open_error())
])
return {}
var text := file.get_as_text()
file.close()
var json := JSON.new()
var err := json.parse(text)
if err != OK:
push_error("load_data: JSON parse error in '%s' at line %d: %s" % [
path, json.get_error_line(), json.get_error_message()
])
return {}
if typeof(json.data) != TYPE_DICTIONARY:
push_error("load_data: root of '%s' is not a JSON object" % path)
return {}
var result: Dictionary = json.data
return result
Health with signals: pass
The task: Write res://health.gd for Godot 4: a script extending Node with health starting at 100, a signal health_changed(old_value: int, new_value: int), a signal died, and a method take_damage(amount: int) that lowers health without going below 0, emits health_changed when health changes, and emits died once, when health reaches 0.
Passed on the first try.
extends Node
signal health_changed(old_value: int, new_value: int)
signal died
var health: int = 100
func take_damage(amount: int) -> void:
# Ignore non-positive damage, and do nothing once already dead
# (this also guarantees `died` is emitted only once).
if amount <= 0 or health <= 0:
return
var old_value: int = health
health = maxi(health - amount, 0)
if health != old_value:
health_changed.emit(old_value, health)
if health == 0:
died.emit()
Fade out with a tween: pass
The task: Write res://fader.gd for Godot 4: a script extending Node2D with a method fade_out(duration: float) that fades the node's modulate alpha from 1 to 0 over duration seconds with a tween, and a signal faded emitted when the fade ends.
Passed on the first try.
extends Node2D
## Fades this node out by tweening its modulate alpha from 1 to 0.
## Emitted when the fade has finished.
signal faded
var _tween: Tween
func fade_out(duration: float) -> void:
# Stop any fade already in progress so they don't fight each other.
if _tween != null and _tween.is_valid():
_tween.kill()
_tween = null
modulate.a = 1.0
# No time to animate (or no tree to run a tween in): finish immediately.
# The signal is deferred so `await faded` after calling fade_out() still works.
if duration <= 0.0 or not is_inside_tree():
modulate.a = 0.0
faded.emit.call_deferred()
return
_tween = create_tween()
_tween.tween_property(self, "modulate:a", 0.0, duration).from(1.0)
_tween.finished.connect(_on_fade_finished, CONNECT_ONE_SHOT)
func _on_fade_finished() -> void:
_tween = null
faded.emit()
Spawn on a timer, then stop: pass
The task: Write res://spawner.gd for Godot 4: a script extending Node that, once in the scene, adds a new child Node2D every 0.25 seconds, using a Timer, and stops after 4 children. It keeps the number spawned in a variable spawned_count.
Passed on the first try.
extends Node
const SPAWN_INTERVAL: float = 0.25
const MAX_SPAWNS: int = 4
var spawned_count: int = 0
var _timer: Timer
func _ready() -> void:
_timer = Timer.new()
_timer.wait_time = SPAWN_INTERVAL
_timer.one_shot = false
_timer.timeout.connect(_on_timer_timeout)
# Added as an internal child so that get_children() / get_child_count()
# only report the spawned Node2D children.
add_child(_timer, false, Node.INTERNAL_MODE_FRONT)
_timer.start()
func _on_timer_timeout() -> void:
if spawned_count >= MAX_SPAWNS:
_timer.stop()
return
var child := Node2D.new()
add_child(child)
spawned_count += 1
if spawned_count >= MAX_SPAWNS:
_timer.stop()
A door with states: pass
The task: Write res://door.gd for Godot 4: a script extending Node for a door with the states CLOSED, OPENING and OPEN. It starts CLOSED. A method interact() starts opening a closed door; 0.5 seconds of game time later it is OPEN. A method get_state_name() -> String returns "CLOSED", "OPENING" or "OPEN".
Passed on the first try.
extends Node
enum State { CLOSED, OPENING, OPEN }
const OPEN_DURATION: float = 0.5
var state: State = State.CLOSED
var _elapsed: float = 0.0
func interact() -> void:
# Only a closed door can start opening; ignore otherwise.
if state != State.CLOSED:
return
_elapsed = 0.0
state = State.OPENING
func _process(delta: float) -> void:
if state != State.OPENING:
return
# delta is game time (affected by pause and Engine.time_scale).
_elapsed += delta
if _elapsed >= OPEN_DURATION - 0.00001:
_elapsed = 0.0
state = State.OPEN
func get_state_name() -> String:
match state:
State.CLOSED:
return "CLOSED"
State.OPENING:
return "OPENING"
State.OPEN:
return "OPEN"
return "CLOSED"
An inventory with counts: pass
The task: Write res://inventory.gd for Godot 4: a script extending RefCounted with add_item(item_name: String, count: int), remove_item(item_name: String, count: int) -> bool that removes only when there are enough and returns whether it did, and get_count(item_name: String) -> int that is 0 for an item never added.
Passed on the first try.
extends RefCounted
# Maps item name -> count held. Only items with a positive count are stored.
var _items: Dictionary = {}
func add_item(item_name: String, count: int) -> void:
if count <= 0:
return
var current: int = _items.get(item_name, 0)
_items[item_name] = current + count
func remove_item(item_name: String, count: int) -> bool:
if count <= 0:
return false
var current: int = _items.get(item_name, 0)
if current < count:
return false
var remaining: int = current - count
if remaining == 0:
_items.erase(item_name)
else:
_items[item_name] = remaining
return true
func get_count(item_name: String) -> int:
var current: int = _items.get(item_name, 0)
return current
Load a level scene from a path: pass
The task: Write res://level_loader.gd for Godot 4: a script extending Node with a method load_level(path: String) -> Node that loads the scene file at path, creates an instance of it, adds it as a child, and returns it.
Passed on the first try.
extends Node
## Loads the scene file at `path`, instantiates it, adds the instance as a
## child of this node, and returns it. Returns null if loading fails.
func load_level(path: String) -> Node:
if path.is_empty():
push_error("load_level: path is empty.")
return null
if not ResourceLoader.exists(path):
push_error("load_level: no resource found at '%s'." % path)
return null
var packed_scene := load(path) as PackedScene
if packed_scene == null:
push_error("load_level: resource at '%s' is not a PackedScene." % path)
return null
if not packed_scene.can_instantiate():
push_error("load_level: scene at '%s' cannot be instantiated." % path)
return null
var level: Node = packed_scene.instantiate()
if level == null:
push_error("load_level: failed to instantiate scene at '%s'." % path)
return null
add_child(level)
return level
Paint cells on a TileMapLayer: pass
The task: Write res://grid_painter.gd for Godot 4.7: a script extending TileMapLayer with paint_row(y: int, from_x: int, to_x: int) that sets the cells from (from_x, y) to (to_x, y) inclusive to tile source 0, atlas coordinates (0, 0), and is_painted(cell: Vector2i) -> bool that says whether a cell has a tile.
Passed on the first try.
extends TileMapLayer
const PAINT_SOURCE_ID: int = 0
const PAINT_ATLAS_COORDS: Vector2i = Vector2i(0, 0)
## Paints every cell from (from_x, y) to (to_x, y), inclusive, with
## tile source 0 at atlas coordinates (0, 0).
## Works regardless of whether from_x is smaller or larger than to_x.
func paint_row(y: int, from_x: int, to_x: int) -> void:
var start_x: int = mini(from_x, to_x)
var end_x: int = maxi(from_x, to_x)
for x: int in range(start_x, end_x + 1):
set_cell(Vector2i(x, y), PAINT_SOURCE_ID, PAINT_ATLAS_COORDS)
## Returns true if the given cell has a tile.
func is_painted(cell: Vector2i) -> bool:
return get_cell_source_id(cell) != -1
Cast a physics ray: pass
The task: Write res://line_of_sight.gd for Godot 4: a script extending Node2D with first_hit(from: Vector2, to: Vector2) -> Vector2 that casts a physics ray through the 2D world from from to to and returns the point where it first hits a collider, or to when it hits nothing. It is called from physics processing.
Passed on the first try.
extends Node2D
## Physics layers the ray is tested against (all layers by default).
@export_flags_2d_physics var collision_mask: int = 0xFFFFFFFF
## Whether the ray detects physics bodies (static, rigid, character, tilemap colliders).
@export var collide_with_bodies: bool = true
## Whether the ray detects Area2D nodes.
@export var collide_with_areas: bool = false
## If true, a ray starting inside a shape reports a hit at its starting point.
@export var hit_from_inside: bool = false
## Casts a ray through the 2D physics world from `from` to `to` (global coordinates).
## Returns the point where the ray first hits a collider, or `to` if nothing is hit.
## Must be called during physics processing (e.g. from _physics_process).
func first_hit(from: Vector2, to: Vector2) -> Vector2:
if not is_inside_tree():
return to
var world: World2D = get_world_2d()
if world == null:
return to
var space_state: PhysicsDirectSpaceState2D = world.direct_space_state
if space_state == null:
return to
var query: PhysicsRayQueryParameters2D = PhysicsRayQueryParameters2D.create(from, to, collision_mask)
query.collide_with_bodies = collide_with_bodies
query.collide_with_areas = collide_with_areas
query.hit_from_inside = hit_from_inside
var result: Dictionary = space_state.intersect_ray(query)
if result.is_empty():
return to
var hit_position: Vector2 = result["position"]
return hit_position
A path on a grid around walls: pass
The task: Write res://path_finder.gd for Godot 4: a script extending RefCounted with find_path(size: Vector2i, walls: Array[Vector2i], from: Vector2i, to: Vector2i) -> Array[Vector2i] that returns the shortest path of grid cells from from to to, both included, on a grid of size cells, never entering a wall cell and moving only up, down, left or right.
Passed on the first try.
extends RefCounted
const _DIRECTIONS: Array[Vector2i] = [
Vector2i(0, -1), # up
Vector2i(0, 1), # down
Vector2i(-1, 0), # left
Vector2i(1, 0), # right
]
## Returns the shortest 4-directional path from `from` to `to` (both included)
## on a grid of `size` cells, avoiding `walls`.
## Returns an empty array if no path exists, or if either endpoint is
## outside the grid or on a wall. If `from == to`, returns [from].
func find_path(size: Vector2i, walls: Array[Vector2i], from: Vector2i, to: Vector2i) -> Array[Vector2i]:
var path: Array[Vector2i] = []
if size.x <= 0 or size.y <= 0:
return path
if not _in_bounds(size, from) or not _in_bounds(size, to):
return path
var width: int = size.x
var cell_count: int = size.x * size.y
# Wall lookup table (1 = wall).
var blocked := PackedByteArray()
blocked.resize(cell_count)
blocked.fill(0)
for wall in walls:
if _in_bounds(size, wall):
blocked[wall.y * width + wall.x] = 1
var start: int = from.y * width + from.x
var goal: int = to.y * width + to.x
if blocked[start] != 0 or blocked[goal] != 0:
return path
if start == goal:
path.append(from)
return path
# Breadth-first search starting at the goal, so that each visited cell
# stores the next cell on its way to the goal. The path can then be read
# forward from the start without reversing.
var toward_goal := PackedInt32Array()
toward_goal.resize(cell_count)
toward_goal.fill(-1)
var queue := PackedInt32Array()
queue.resize(cell_count)
var head: int = 0
var tail: int = 0
queue[tail] = goal
tail += 1
toward_goal[goal] = goal
var found := false
while head < tail and not found:
var current: int = queue[head]
head += 1
var cx: int = current % width
@warning_ignore("integer_division")
var cy: int = current / width
for dir in _DIRECTIONS:
var nx: int = cx + dir.x
var ny: int = cy + dir.y
if nx < 0 or ny < 0 or nx >= size.x or ny >= size.y:
continue
var idx: int = ny * width + nx
if blocked[idx] != 0 or toward_goal[idx] != -1:
continue
toward_goal[idx] = current
if idx == start:
found = true
break
queue[tail] = idx
tail += 1
if not found:
return path
var cell: int = start
while true:
@warning_ignore("integer_division")
var pos := Vector2i(cell % width, cell / width)
path.append(pos)
if cell == goal:
break
cell = toward_goal[cell]
return path
func _in_bounds(size: Vector2i, cell: Vector2i) -> bool:
return cell.x >= 0 and cell.y >= 0 and cell.x < size.x and cell.y < size.y
Build and play an animation in code: pass
The task: Write res://blinker.gd for Godot 4: a script extending Node2D that, when it enters the scene, creates an AnimationPlayer child and a looping animation named "blink", 1 second long, that keeps the node visible for the first half of each second and hidden for the second half, and plays it.
Passed on the first try.
extends Node2D
const BLINK_ANIMATION: StringName = &"blink"
var _animation_player: AnimationPlayer
func _ready() -> void:
# Create the AnimationPlayer as a child of this node.
_animation_player = AnimationPlayer.new()
_animation_player.name = "AnimationPlayer"
add_child(_animation_player)
# Build the 1-second looping "blink" animation.
var animation := Animation.new()
animation.length = 1.0
animation.loop_mode = Animation.LOOP_LINEAR
# The AnimationPlayer's root_node defaults to "..", i.e. this Node2D,
# so ".:visible" targets this node's "visible" property.
var track := animation.add_track(Animation.TYPE_VALUE)
animation.track_set_path(track, NodePath(".:visible"))
animation.value_track_set_update_mode(track, Animation.UPDATE_DISCRETE)
animation.track_set_interpolation_type(track, Animation.INTERPOLATION_NEAREST)
animation.track_insert_key(track, 0.0, true) # visible for the first half
animation.track_insert_key(track, 0.5, false) # hidden for the second half
# Godot 4 stores animations in libraries; "" is the global library.
var library := AnimationLibrary.new()
library.add_animation(BLINK_ANIMATION, animation)
_animation_player.add_animation_library(&"", library)
_animation_player.play(BLINK_ANIMATION)
Wait for a signal or a timeout: pass
The task: Write res://waiter.gd for Godot 4: a script extending Node with wait_for(sig: Signal, seconds: float) -> bool, a coroutine that waits until the signal is emitted or seconds of game time pass, whichever comes first, and returns true if the signal came first. The signal has no arguments.
Passed on the first try.
extends Node
## res://waiter.gd
##
## Usage:
## var got_it: bool = await $Waiter.wait_for(some_object.some_signal, 2.5)
## # true -> the signal was emitted before the timeout
## # false -> `seconds` of game time elapsed first
## Small helper object that turns "signal or timeout, whichever fires first"
## into one awaitable signal carrying the outcome.
class _Race extends RefCounted:
signal finished(by_signal: bool)
var _done: bool = false
func on_signal() -> void:
_finish(true)
func on_timeout() -> void:
_finish(false)
func _finish(by_signal: bool) -> void:
if _done:
return
_done = true
finished.emit(by_signal)
## Waits until `sig` (a signal with no arguments) is emitted or `seconds` of
## game time pass, whichever comes first.
## Returns true if the signal came first, false if the timeout did.
func wait_for(sig: Signal, seconds: float) -> bool:
var tree: SceneTree = null
if is_inside_tree():
tree = get_tree()
else:
tree = Engine.get_main_loop() as SceneTree
if tree == null:
push_error("waiter.gd: wait_for() needs a running SceneTree.")
return false
var race := _Race.new()
# process_always = false -> the timer does not advance while the tree is paused.
# ignore_time_scale = false -> the timer follows Engine.time_scale.
# Together this makes the timeout count game time rather than real time.
var timer: SceneTreeTimer = tree.create_timer(maxf(seconds, 0.0), false, false, false)
timer.timeout.connect(race.on_timeout)
var sig_valid: bool = is_instance_valid(sig.get_object())
if sig_valid:
sig.connect(race.on_signal)
var by_signal: bool = await race.finished
# Clean up whichever connection is still pending.
if sig_valid and is_instance_valid(sig.get_object()) and sig.is_connected(race.on_signal):
sig.disconnect(race.on_signal)
if timer.timeout.is_connected(race.on_timeout):
timer.timeout.disconnect(race.on_timeout)
return by_signal
Questions
- Is Claude Fable 5.2 good at Godot?
- On these 15 tasks it passed 15 on the first try and 15 after one fix. Each task is small and checked by running it, so the score says whether its Godot 4 code works, not how well it designs a game.
Flockbay runs your own agent, Claude or ChatGPT on the official Godot 4.7.2, and gives it Godot's errors the way this test does.
Download Flockbay free