Test generator: template and test improvements

exercises/practice/clock/clock.bats

@@ -1,7 +1,7 @@
 #!/usr/bin/env bats
 load bats-extra
 
-# generated on 2026-11-06T16:26:09+00:00
+# generated on 2026-11-08T06:23:17+00:00
 
 # * The canonical "Compare two clocks for equality" tests
 #   have not been included: for bash they will simply be 
@@ -202,7 +202,7 @@ test_add_minutes_add_across_midnight() { # @test
     assert_output "00:01"
 }
 
-test_add_minutes_add_more_than_one_day_1500_min_25_hrs_() { # @test
+test_add_minutes_add_more_than_one_day_1500_min_25_hrs() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash clock.sh 5 32 + 1500
     assert_success
@@ -258,7 +258,7 @@ test_subtract_minutes_subtract_more_than_two_hours_with_borrow() { # @test
     assert_output "03:35"
 }
 
-test_subtract_minutes_subtract_more_than_one_day_1500_min_25_hrs_() { # @test
+test_subtract_minutes_subtract_more_than_one_day_1500_min_25_hrs() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash clock.sh 5 32 - 1500
     assert_success

exercises/practice/knapsack/knapsack.bats

@@ -1,7 +1,7 @@
 #!/usr/bin/env bats
 load bats-extra
 
-# generated on 2026-11-07T07:50:02+00:00
+# generated on 2026-11-08T06:23:17+00:00
 
 # Usage: knapsack.sh max_wt [items ...]
 # where: items look like "weight:value"
@@ -25,14 +25,14 @@ test_one_item_too_heavy() { # @test
     assert_output "0"
 }
 
-test_five_items_cannot_be_greedy_by_weight_() { # @test
+test_five_items_cannot_be_greedy_by_weight() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash knapsack.sh 10 2:5 2:5 2:5 2:5 10:21
     assert_success
     assert_output "21"
 }
 
-test_five_items_cannot_be_greedy_by_value_() { # @test
+test_five_items_cannot_be_greedy_by_value() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash knapsack.sh 10 2:20 2:20 2:20 2:20 10:50
     assert_success

exercises/practice/ocr-numbers/ocr_numbers.bats

@@ -1,7 +1,7 @@
 #!/usr/bin/env bats
 load bats-extra
 
-# generated on 2026-11-07T07:50:02+00:00
+# generated on 2026-11-08T06:23:17+00:00
 
 test_recognizes_0() { # @test
     # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
@@ -194,7 +194,7 @@ INPUT
     assert_output "1234567890"
 }
 
-test_numbers_separated_by_empty_lines_are_recognized_lines_are_joined_by_commas_() { # @test
+test_numbers_separated_by_empty_lines_are_recognized_lines_are_joined_by_commas() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash ocr_numbers.sh << INPUT
     _  _ 

exercises/practice/variable-length-quantity/.meta/template.j2

@@ -5,20 +5,20 @@
 #
 
 {% for case in cases %}
-@test "{{ case["description"] }}" {
+{{ case.test_function_start }}
     {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
     {%- set hex_input = [] %}
-    {%- for num in case["input"]["integers"] %}
+    {%- for num in case.given %}
         {%- set _ = hex_input.append('%02X' % num) %}
     {%- endfor %}
-    run bash {{ solution }} {{ case["property"] }} {{ hex_input | join(" ") }}
-{%- if case["expect_error"] %}
+    run bash {{ solution }} {{ case.property }} {{ hex_input | join(" ") }}
+{%- if case.expect_error %}
     assert_failure
     {#- The error message from the canonical data is not used. #}
     assert_output --partial "incomplete byte sequence"
 {%- else %}
     {%- set hex_output = [] %}
-    {%- for num in case["expected"] %}
+    {%- for num in case.expected %}
         {%- set _ = hex_output.append('%02X' % num) %}
     {%- endfor %}
     assert_success
@@ -27,7 +27,7 @@
 }
 {% endfor %}
 
-@test "invalid subcommand" {
+test_invalid_subcommand() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash variable_length_quantity.sh hello 80
     assert_failure

exercises/practice/variable-length-quantity/variable_length_quantity.bats

@@ -1,232 +1,232 @@
 #!/usr/bin/env bats
 load bats-extra
 
-# generated on 2026-06-29T19:27:37+00:00
+# generated on 2026-11-08T06:49:56+00:00
 
 #
 # *** Input and Output numbers are expressed in hexadecimal.
 #
 
 
-@test "zero" {
+test_encode_a_series_of_integers_producing_a_series_of_bytes_zero() { # @test
     # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash variable_length_quantity.sh encode 00
     assert_success
     assert_output "00"
 }
 
-@test "arbitrary single byte" {
+test_encode_a_series_of_integers_producing_a_series_of_bytes_arbitrary_single_byte() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash variable_length_quantity.sh encode 40
     assert_success
     assert_output "40"
 }
 
-@test "asymmetric single byte" {
+test_encode_a_series_of_integers_producing_a_series_of_bytes_asymmetric_single_byte() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash variable_length_quantity.sh encode 53
     assert_success
     assert_output "53"
 }
 
-@test "largest single byte" {
+test_encode_a_series_of_integers_producing_a_series_of_bytes_largest_single_byte() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash variable_length_quantity.sh encode 7F
     assert_success
     assert_output "7F"
 }
 
-@test "smallest double byte" {
+test_encode_a_series_of_integers_producing_a_series_of_bytes_smallest_double_byte() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash variable_length_quantity.sh encode 80
     assert_success
     assert_output "81 00"
 }
 
-@test "arbitrary double byte" {
+test_encode_a_series_of_integers_producing_a_series_of_bytes_arbitrary_double_byte() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash variable_length_quantity.sh encode 2000
     assert_success
     assert_output "C0 00"
 }
 
-@test "asymmetric double byte" {
+test_encode_a_series_of_integers_producing_a_series_of_bytes_asymmetric_double_byte() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash variable_length_quantity.sh encode AD
     assert_success
     assert_output "81 2D"
 }
 
-@test "largest double byte" {
+test_encode_a_series_of_integers_producing_a_series_of_bytes_largest_double_byte() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash variable_length_quantity.sh encode 3FFF
     assert_success
     assert_output "FF 7F"
 }
 
-@test "smallest triple byte" {
+test_encode_a_series_of_integers_producing_a_series_of_bytes_smallest_triple_byte() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash variable_length_quantity.sh encode 4000
     assert_success
     assert_output "81 80 00"
 }
 
-@test "arbitrary triple byte" {
+test_encode_a_series_of_integers_producing_a_series_of_bytes_arbitrary_triple_byte() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash variable_length_quantity.sh encode 100000
     assert_success
     assert_output "C0 80 00"
 }
 
-@test "asymmetric triple byte" {
+test_encode_a_series_of_integers_producing_a_series_of_bytes_asymmetric_triple_byte() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash variable_length_quantity.sh encode 1D59C
     assert_success
     assert_output "87 AB 1C"
 }
 
-@test "largest triple byte" {
+test_encode_a_series_of_integers_producing_a_series_of_bytes_largest_triple_byte() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash variable_length_quantity.sh encode 1FFFFF
     assert_success
     assert_output "FF FF 7F"
 }
 
-@test "smallest quadruple byte" {
+test_encode_a_series_of_integers_producing_a_series_of_bytes_smallest_quadruple_byte() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash variable_length_quantity.sh encode 200000
     assert_success
     assert_output "81 80 80 00"
 }
 
-@test "arbitrary quadruple byte" {
+test_encode_a_series_of_integers_producing_a_series_of_bytes_arbitrary_quadruple_byte() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash variable_length_quantity.sh encode 8000000
     assert_success
     assert_output "C0 80 80 00"
 }
 
-@test "asymmetric quadruple byte" {
+test_encode_a_series_of_integers_producing_a_series_of_bytes_asymmetric_quadruple_byte() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash variable_length_quantity.sh encode 357704
     assert_success
     assert_output "81 D5 EE 04"
 }
 
-@test "largest quadruple byte" {
+test_encode_a_series_of_integers_producing_a_series_of_bytes_largest_quadruple_byte() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash variable_length_quantity.sh encode FFFFFFF
     assert_success
     assert_output "FF FF FF 7F"
 }
 
-@test "smallest quintuple byte" {
+test_encode_a_series_of_integers_producing_a_series_of_bytes_smallest_quintuple_byte() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash variable_length_quantity.sh encode 10000000
     assert_success
     assert_output "81 80 80 80 00"
 }
 
-@test "arbitrary quintuple byte" {
+test_encode_a_series_of_integers_producing_a_series_of_bytes_arbitrary_quintuple_byte() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash variable_length_quantity.sh encode FF000000
     assert_success
     assert_output "8F F8 80 80 00"
 }
 
-@test "asymmetric quintuple byte" {
+test_encode_a_series_of_integers_producing_a_series_of_bytes_asymmetric_quintuple_byte() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash variable_length_quantity.sh encode 86656105
     assert_success
     assert_output "88 B3 95 C2 05"
 }
 
-@test "maximum 32-bit integer input" {
+test_encode_a_series_of_integers_producing_a_series_of_bytes_maximum_32_bit_integer_input() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash variable_length_quantity.sh encode FFFFFFFF
     assert_success
     assert_output "8F FF FF FF 7F"
 }
 
-@test "two single-byte values" {
+test_encode_a_series_of_integers_producing_a_series_of_bytes_two_single_byte_values() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash variable_length_quantity.sh encode 40 7F
     assert_success
     assert_output "40 7F"
 }
 
-@test "two multi-byte values" {
+test_encode_a_series_of_integers_producing_a_series_of_bytes_two_multi_byte_values() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash variable_length_quantity.sh encode 4000 123456
     assert_success
     assert_output "81 80 00 C8 E8 56"
 }
 
-@test "many multi-byte values" {
+test_encode_a_series_of_integers_producing_a_series_of_bytes_many_multi_byte_values() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash variable_length_quantity.sh encode 2000 123456 FFFFFFF 00 3FFF 4000
     assert_success
     assert_output "C0 00 C8 E8 56 FF FF FF 7F 00 FF 7F 81 80 00"
 }
 
-@test "one byte" {
+test_decode_a_series_of_bytes_producing_a_series_of_integers_one_byte() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash variable_length_quantity.sh decode 7F
     assert_success
     assert_output "7F"
 }
 
-@test "two bytes" {
+test_decode_a_series_of_bytes_producing_a_series_of_integers_two_bytes() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash variable_length_quantity.sh decode C0 00
     assert_success
     assert_output "2000"
 }
 
-@test "three bytes" {
+test_decode_a_series_of_bytes_producing_a_series_of_integers_three_bytes() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash variable_length_quantity.sh decode FF FF 7F
     assert_success
     assert_output "1FFFFF"
 }
 
-@test "four bytes" {
+test_decode_a_series_of_bytes_producing_a_series_of_integers_four_bytes() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash variable_length_quantity.sh decode 81 80 80 00
     assert_success
     assert_output "200000"
 }
 
-@test "maximum 32-bit integer" {
+test_decode_a_series_of_bytes_producing_a_series_of_integers_maximum_32_bit_integer() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash variable_length_quantity.sh decode 8F FF FF FF 7F
     assert_success
     assert_output "FFFFFFFF"
 }
 
-@test "incomplete sequence causes error" {
+test_decode_a_series_of_bytes_producing_a_series_of_integers_incomplete_sequence_causes_error() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash variable_length_quantity.sh decode FF
     assert_failure
     assert_output --partial "incomplete byte sequence"
 }
 
-@test "incomplete sequence causes error, even if value is zero" {
+test_decode_a_series_of_bytes_producing_a_series_of_integers_incomplete_sequence_causes_error_even_if_value_is_zero() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash variable_length_quantity.sh decode 80
     assert_failure
     assert_output --partial "incomplete byte sequence"
 }
 
-@test "multiple values" {
+test_decode_a_series_of_bytes_producing_a_series_of_integers_multiple_values() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash variable_length_quantity.sh decode C0 00 C8 E8 56 FF FF FF 7F 00 FF 7F 81 80 00
     assert_success
     assert_output "2000 123456 FFFFFFF 00 3FFF 4000"
 }
 
 
-@test "invalid subcommand" {
+test_invalid_subcommand() { # @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash variable_length_quantity.sh hello 80
     assert_failure

exercises/practice/word-count/.meta/template.j2

@@ -1,20 +1,20 @@
 {{ header }}
 {% for case in cases %}
-@test "{{ case["description"] }}" {
+{{ case.test_function_start }}
     {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
-    run bash {{ solution }} "{{ case["input"]["sentence"] }}"
+    run bash {{ solution }} "{{ case.given }}"
     assert_success
-{%- for word, count in case["expected"].items() %}
+{%- for word, count in case.expected.items() %}
     assert_line "{{ word }}: {{ count }}"
 {%- endfor %}
-    assert_equal "${{ "{" }}#lines[@]}" {{ case["expected"] | length }}
+    assert_equal "${{ "{" }}#lines[@]}" {{ case.expected | length }}
 }
 {% endfor %}
 # bash-specific test: Focus the student's attention on the effects of 
 # word splitting and filename expansion:
 # https://www.gnu.org/software/bash/manual/bash.html#Shell-Expansions
 
-@test "contains shell globbing character" {
+test_contains_shell_globbing_character() { $ @test
     [[ $BATS_RUN_SKIPPED == "true" ]] || skip
     run bash {{ solution }} "two * words"
     assert_success