- PathSegment traegt element_type/element_code/element_level (D3) - Element-Werkzeug setzt Punktmarker per Tipp; Inspector fuer Typ, Kuerzel und Level; Marker per Griff verschiebbar - Darstellung auf Canvas und in Praesentation inkl. Ghosting, Labels-Schalter blendet Kuerzel aus - Sequenzbereiche sind getaggte Segmente, Tag ueber Inspector setzbar - SVG/PNG-Export mit Typform und Kuerzel - Timing-Leiste blendet irrelevante Regler im Element-Modus aus - Griff-Drag beginnt erst mit der ersten Bewegung (kein Undo bei Tipp) - Tests: 577 Assertions gruen; Findings, Architektur und Roadmap aktuell
327 lines
9.9 KiB
GDScript
327 lines
9.9 KiB
GDScript
extends SceneTree
|
|
|
|
## Headless tests for the touch gesture layer.
|
|
##
|
|
## Run with:
|
|
## godot --headless --path rinkplanner --script res://tests/run_touch_tests.gd
|
|
|
|
const WhiteboardScene := preload("res://scenes/whiteboard/whiteboard.tscn")
|
|
|
|
var _assertions: int = 0
|
|
var _failures: PackedStringArray = PackedStringArray()
|
|
|
|
|
|
func _init() -> void:
|
|
_run.call_deferred()
|
|
|
|
|
|
func _run() -> void:
|
|
var scene := WhiteboardScene.instantiate()
|
|
var controller := scene as WhiteboardController
|
|
if controller != null:
|
|
controller.restore_autosave = false
|
|
controller.autosave_enabled = false
|
|
root.add_child(scene)
|
|
await process_frame
|
|
|
|
_check(controller != null, "touch scene has a controller")
|
|
if controller == null:
|
|
_finish()
|
|
return
|
|
|
|
var canvas := controller.rink_canvas
|
|
var view := canvas.get_view_transform()
|
|
var section := controller.get_active_section()
|
|
_check(
|
|
canvas.size.x > 0.0 and canvas.size.y > 0.0,
|
|
"canvas receives a touch layout size"
|
|
)
|
|
|
|
# One-finger drawing.
|
|
controller.set_tool(WhiteboardController.Tool.LINE)
|
|
var count_before_draw := section.segments.size()
|
|
var draw_start := view.model_to_screen(Vector2(-10.0, 5.0))
|
|
var draw_end := view.model_to_screen(Vector2(0.0, 5.0))
|
|
_touch(canvas, 0, draw_start, true)
|
|
_drag(canvas, 0, draw_end, draw_end - draw_start)
|
|
_touch(canvas, 0, draw_end, false)
|
|
|
|
_check(
|
|
section.segments.size() == count_before_draw + 1,
|
|
"one-finger drag draws a segment"
|
|
)
|
|
var drawn := section.segments[section.segments.size() - 1]
|
|
_check(drawn.get_length_m() > 9.5, "touch-drawn segment has the drag length")
|
|
|
|
# Chrome emits a synthetic mouse press immediately before the touch press.
|
|
# The touch press must cancel that stray mouse segment.
|
|
canvas._ignore_mouse_until_msec = 0
|
|
controller.set_tool(WhiteboardController.Tool.LINE)
|
|
var count_before_combined := section.segments.size()
|
|
var combined_start := view.model_to_screen(Vector2(-8.0, -3.0))
|
|
var combined_end := view.model_to_screen(Vector2(2.0, -3.0))
|
|
_mouse_button(canvas, combined_start, true)
|
|
_touch(canvas, 0, combined_start, true)
|
|
_drag(canvas, 0, combined_end, combined_end - combined_start)
|
|
_touch(canvas, 0, combined_end, false)
|
|
_check(
|
|
section.segments.size() == count_before_combined + 1,
|
|
"touch replaces the preceding synthetic mouse segment"
|
|
)
|
|
controller.set_tool(WhiteboardController.Tool.LINE)
|
|
|
|
# Browsers may emit a synthetic mouse gesture after touchend. It must not
|
|
# create a second segment.
|
|
var count_after_touch := section.segments.size()
|
|
var mouse_start := view.model_to_screen(Vector2(-10.0, -5.0))
|
|
var mouse_end := view.model_to_screen(Vector2(0.0, -5.0))
|
|
_mouse_button(canvas, mouse_start, true)
|
|
_mouse_motion(canvas, mouse_end)
|
|
_mouse_button(canvas, mouse_end, false)
|
|
_check(
|
|
section.segments.size() == count_after_touch,
|
|
"synthetic mouse after touch is ignored"
|
|
)
|
|
|
|
# Element tool: a single tap drops a marker, a drag still pans.
|
|
controller.set_tool(WhiteboardController.Tool.ELEMENT)
|
|
var count_before_marker := section.segments.size()
|
|
var marker_screen := view.model_to_screen(Vector2(6.0, 6.0))
|
|
_touch(canvas, 0, marker_screen, true)
|
|
_touch(canvas, 0, marker_screen, false)
|
|
_check(
|
|
section.segments.size() == count_before_marker + 1,
|
|
"one tap places an element marker"
|
|
)
|
|
var placed_marker := section.segments[section.segments.size() - 1]
|
|
_check(
|
|
placed_marker.is_element_marker(),
|
|
"tapped marker is a zero-length element"
|
|
)
|
|
_check(
|
|
controller.get_selected_segment() == placed_marker,
|
|
"placed marker is selected for the inspector"
|
|
)
|
|
|
|
controller.set_tool(WhiteboardController.Tool.SELECT)
|
|
controller.clear_selection()
|
|
_check(
|
|
controller.get_selected_segment() == null,
|
|
"selection can be cleared before tapping"
|
|
)
|
|
var undo_before := controller.undo_button.disabled
|
|
_touch(canvas, 0, marker_screen, true)
|
|
_touch(canvas, 0, marker_screen, false)
|
|
_check(
|
|
controller.get_selected_segment() == placed_marker,
|
|
"tapping the marker selects it"
|
|
)
|
|
_check_vec(
|
|
placed_marker.curve.get_point_position(0),
|
|
Vector2(6.0, 6.0),
|
|
"tapping the marker does not move it"
|
|
)
|
|
_check(
|
|
controller.undo_button.disabled == undo_before,
|
|
"tapping a marker leaves the undo button state alone"
|
|
)
|
|
|
|
# Two-finger pan.
|
|
controller.set_tool(WhiteboardController.Tool.SELECT)
|
|
var count_before_pan := section.segments.size()
|
|
var origin_before := view.origin_px
|
|
var pan_a := view.model_to_screen(Vector2(20.0, -10.0))
|
|
var pan_b := view.model_to_screen(Vector2(20.0, -6.0))
|
|
_touch(canvas, 0, pan_a, true)
|
|
_touch(canvas, 1, pan_b, true)
|
|
_drag(canvas, 0, pan_a + Vector2(30.0, 0.0), Vector2(30.0, 0.0))
|
|
_drag(canvas, 1, pan_b + Vector2(30.0, 0.0), Vector2(30.0, 0.0))
|
|
_touch(canvas, 0, pan_a + Vector2(30.0, 0.0), false)
|
|
_touch(canvas, 1, pan_b + Vector2(30.0, 0.0), false)
|
|
_check(view.origin_px != origin_before, "two-finger drag pans the canvas")
|
|
_check(
|
|
section.segments.size() == count_before_pan,
|
|
"two-finger pan does not create a segment"
|
|
)
|
|
|
|
# Pinch zoom.
|
|
canvas.fit_rink()
|
|
var ppm_before := view.pixels_per_meter
|
|
var center := canvas.size * 0.5
|
|
var pinch_a := center + Vector2(-30.0, 0.0)
|
|
var pinch_b := center + Vector2(30.0, 0.0)
|
|
var pinch_a2 := center + Vector2(-60.0, 0.0)
|
|
var pinch_b2 := center + Vector2(60.0, 0.0)
|
|
_touch(canvas, 0, pinch_a, true)
|
|
_touch(canvas, 1, pinch_b, true)
|
|
_drag(canvas, 0, pinch_a2, pinch_a2 - pinch_a)
|
|
_drag(canvas, 1, pinch_b2, pinch_b2 - pinch_b)
|
|
_touch(canvas, 0, pinch_a2, false)
|
|
_touch(canvas, 1, pinch_b2, false)
|
|
_check(
|
|
view.pixels_per_meter > ppm_before,
|
|
"two-finger pinch zooms in"
|
|
)
|
|
|
|
# Tap selection.
|
|
canvas.fit_rink()
|
|
var target := section.segments[0]
|
|
var target_point := target.curve.sample_baked(target.get_length_m() * 0.5)
|
|
_touch(canvas, 0, view.model_to_screen(target_point), true)
|
|
_touch(canvas, 0, view.model_to_screen(target_point), false)
|
|
_check(
|
|
controller.get_selected_segment() == target,
|
|
"touch tap selects a segment"
|
|
)
|
|
|
|
# Touch handle editing.
|
|
var old_start := target.curve.get_point_position(0)
|
|
var new_start := old_start + Vector2(-2.0, 1.0)
|
|
_touch(canvas, 0, view.model_to_screen(old_start), true)
|
|
_drag(
|
|
canvas,
|
|
0,
|
|
view.model_to_screen(new_start),
|
|
view.model_to_screen(new_start) - view.model_to_screen(old_start)
|
|
)
|
|
_touch(canvas, 0, view.model_to_screen(new_start), false)
|
|
_check_vec(
|
|
target.curve.get_point_position(0),
|
|
new_start,
|
|
"touch handle drag moves the segment start"
|
|
)
|
|
|
|
# A second finger cancels an in-progress drawing gesture.
|
|
controller.set_tool(WhiteboardController.Tool.LINE)
|
|
var count_before_cancel := section.segments.size()
|
|
var inside := view.model_to_screen(Vector2(5.0, 5.0))
|
|
_touch(canvas, 0, inside, true)
|
|
_check(
|
|
section.segments.size() == count_before_cancel + 1,
|
|
"first finger starts a temporary segment"
|
|
)
|
|
_touch(canvas, 1, inside + Vector2(20.0, 0.0), true)
|
|
_check(
|
|
section.segments.size() == count_before_cancel,
|
|
"second finger cancels the temporary segment"
|
|
)
|
|
_drag(canvas, 0, inside + Vector2(40.0, 0.0), Vector2(40.0, 0.0))
|
|
_drag(canvas, 1, inside + Vector2(60.0, 0.0), Vector2(40.0, 0.0))
|
|
_touch(canvas, 0, inside + Vector2(40.0, 0.0), false)
|
|
_touch(canvas, 1, inside + Vector2(60.0, 0.0), false)
|
|
_check(
|
|
section.segments.size() == count_before_cancel,
|
|
"pinch after cancel does not leave a segment"
|
|
)
|
|
|
|
# Responsive toolbar: wide screens keep the full labels, tablet-landscape
|
|
# width switches to the compact labels and must not clip the bars.
|
|
root.size = Vector2i(1400, 900)
|
|
await process_frame
|
|
await process_frame
|
|
_check(controller.get_node("%Title").visible, "wide layout shows the app title")
|
|
_check(
|
|
controller.get_node("%UndoButton").text == "Rückgängig",
|
|
"wide layout uses the full undo label"
|
|
)
|
|
|
|
root.size = Vector2i(1024, 768)
|
|
await process_frame
|
|
await process_frame
|
|
_check(
|
|
not controller.get_node("%Title").visible,
|
|
"compact layout hides the app title"
|
|
)
|
|
_check(
|
|
controller.get_node("%UndoButton").text == "Undo",
|
|
"compact layout uses the short undo label"
|
|
)
|
|
var top_bar: Control = controller.get_node("Layout/TopBar")
|
|
var timing_bar: Control = controller.get_node("Layout/TimingBar")
|
|
var playback_bar: Control = controller.get_node("Layout/PlaybackBar")
|
|
_check(
|
|
top_bar.get_combined_minimum_size().x <= 1024.0,
|
|
"top bar fits a 1024 px landscape tablet (min %.0f)"
|
|
% top_bar.get_combined_minimum_size().x
|
|
)
|
|
_check(
|
|
timing_bar.get_combined_minimum_size().x <= 1024.0,
|
|
"timing bar fits a 1024 px landscape tablet"
|
|
)
|
|
_check(
|
|
playback_bar.get_combined_minimum_size().x <= 1024.0,
|
|
"playback bar fits a 1024 px landscape tablet"
|
|
)
|
|
|
|
scene.queue_free()
|
|
await process_frame
|
|
_finish()
|
|
|
|
|
|
func _touch(
|
|
canvas: RinkCanvas,
|
|
index: int,
|
|
position: Vector2,
|
|
pressed: bool
|
|
) -> void:
|
|
var event := InputEventScreenTouch.new()
|
|
event.index = index
|
|
event.position = position
|
|
event.pressed = pressed
|
|
canvas._gui_input(event)
|
|
|
|
|
|
func _drag(
|
|
canvas: RinkCanvas,
|
|
index: int,
|
|
position: Vector2,
|
|
relative: Vector2
|
|
) -> void:
|
|
var event := InputEventScreenDrag.new()
|
|
event.index = index
|
|
event.position = position
|
|
event.relative = relative
|
|
canvas._gui_input(event)
|
|
|
|
|
|
func _mouse_button(
|
|
canvas: RinkCanvas,
|
|
position: Vector2,
|
|
pressed: bool
|
|
) -> void:
|
|
var event := InputEventMouseButton.new()
|
|
event.button_index = MOUSE_BUTTON_LEFT
|
|
event.pressed = pressed
|
|
event.position = position
|
|
canvas._gui_input(event)
|
|
|
|
|
|
func _mouse_motion(canvas: RinkCanvas, position: Vector2) -> void:
|
|
var event := InputEventMouseMotion.new()
|
|
event.position = position
|
|
canvas._gui_input(event)
|
|
|
|
|
|
func _check(condition: bool, message: String) -> void:
|
|
_assertions += 1
|
|
if not condition:
|
|
_failures.append(message)
|
|
|
|
|
|
func _check_vec(actual: Vector2, expected: Vector2, message: String) -> void:
|
|
_check(
|
|
actual.distance_to(expected) <= 0.01,
|
|
"%s (expected %s, got %s)" % [message, expected, actual]
|
|
)
|
|
|
|
|
|
func _finish() -> void:
|
|
if _failures.is_empty():
|
|
print("PASS: %d assertions" % _assertions)
|
|
quit(0)
|
|
return
|
|
|
|
for failure: String in _failures:
|
|
printerr("FAIL: %s" % failure)
|
|
printerr("%d of %d assertions failed" % [_failures.size(), _assertions])
|
|
quit(1)
|