Migrate tests to proper three-layer format per TESTING_GUIDE.md

Replace ad-hoc issue_3172_*.in tests with proper test framework integration:

- Add iso_syntax_errors.pl: Tests for ISO TC2 C.2 bar operator restrictions
  (single bar in parens, list notation without head/tail, op restrictions)
- Add double_bar_syntax_errors.pl: Tests for WG17 2025 || operator
  (only valid after double-quoted string per ISO 6.3.7)
- Add CLI test config for double_bar_syntax_errors
- Remove old issue_3172_brackets/doublebar/operator_bar test directories

Tests now follow the standard test_framework.pl pattern with test/2 predicates
and main_quiet/1 for CI integration.

Author: jjtolton

src/tests/double_bar_syntax_errors.pl

@@ -0,0 +1,79 @@
+:- module(double_bar_syntax_errors_tests, []).
+:- use_module(test_framework).
+:- use_module(library(charsio)).
+
+% WG17 2025 double bar syntax error tests
+% Reference: https://www.complang.tuwien.ac.at/ulrich/iso-prolog/double_bar
+% The || operator only valid directly after double-quoted string token
+% term = double quoted list, bar, bar, term ;
+
+% Invalid || usage - list before || violates WG17 grammar
+% ISO 6.3.5: [] is list notation, not double quoted list (6.3.7)
+
+test("[]||X list before || should error", (
+    catch(
+        (read_from_chars("[]||X.", _), false),
+        error(syntax_error(_), _),
+        true
+    )
+)).
+
+test("[a,b]||X non-empty list before || should error", (
+    catch(
+        (read_from_chars("[a,b]||X.", _), false),
+        error(syntax_error(_), _),
+        true
+    )
+)).
+
+test("X||[] variable before || should error", (
+    % ISO 6.3.2: Variables have priority 0, are not double quoted lists
+    catch(
+        (read_from_chars("X||[].", _), false),
+        error(syntax_error(_), _),
+        true
+    )
+)).
+
+test("foo||X atom before || should error", (
+    % ISO 6.3.1.3: Atoms are atomic terms, not double quoted lists
+    catch(
+        (read_from_chars("foo||X.", _), false),
+        error(syntax_error(_), _),
+        true
+    )
+)).
+
+test("123||X number before || should error", (
+    % ISO 6.3.1.1: Numbers are atomic terms, not double quoted lists
+    catch(
+        (read_from_chars("123||X.", _), false),
+        error(syntax_error(_), _),
+        true
+    )
+)).
+
+test("{foo||bar} atoms in curly brackets should error", (
+    % ISO 6.3.6: {term} wraps term, but foo is atom not double-quoted string
+    catch(
+        (read_from_chars("{foo||bar}.", _), false),
+        error(syntax_error(_), _),
+        true
+    )
+)).
+
+test("[[]||X] nested list context should error", (
+    catch(
+        (read_from_chars("[[]||X].", _), false),
+        error(syntax_error(_), _),
+        true
+    )
+)).
+
+test("{[]||!} list before || in curly should error", (
+    catch(
+        (read_from_chars("{[]||!}.", _), false),
+        error(syntax_error(_), _),
+        true
+    )
+)).

src/tests/iso_syntax_errors.pl

@@ -0,0 +1,148 @@
+:- module(iso_syntax_errors_tests, []).
+:- use_module(test_framework).
+:- use_module(library(charsio)).
+
+% ISO/IEC 13211-1 Technical Corrigendum 2, Section C2
+% See https://www.complang.tuwien.ac.at/ulrich/iso-prolog/dtc2#C2
+
+test("single_bar_in_parens_should_error", (
+    % see https://github.com/mthom/scryer-prolog/issues/3140
+    % (|) should cause a syntax error when | is declared as an operator
+    % ISO TC2 C.2: | cannot be both operator and head-tail separator
+    op(1105, xfy, '|'),
+    catch(
+        (read_from_chars("(|).", _), false),
+        error(syntax_error(_), _),
+        true
+    ),
+    op(0, xfy, '|')
+)).
+
+test("op_create_empty_curly_should_error", (
+    catch(
+        op(500, xfy, {}),
+        error(permission_error(create, operator, {}), _),
+        true
+    )
+)).
+
+test("op_create_empty_curly_in_list_should_error", (
+    catch(
+        op(500, xfy, [{}]),
+        error(permission_error(create, operator, {}), _),
+        true
+    )
+)).
+
+test("op_create_bar_priority_1000_should_error", (
+    catch(
+        op(1000, xfy, '|'),
+        error(permission_error(create, operator, '|'), _),
+        true
+    )
+)).
+
+test("op_create_bar_in_list_priority_1000_should_error", (
+    catch(
+        op(1000, xfy, ['|']),
+        error(permission_error(create, operator, '|'), _),
+        true
+    )
+)).
+
+test("op_create_bar_prefix_should_error", (
+    catch(
+        op(1150, fx, '|'),
+        error(permission_error(create, operator, '|'), _),
+        true
+    )
+)).
+
+test("op_create_bar_priority_1105_should_succeed", (
+    op(1105, xfy, '|'),
+    % Clean up
+    op(0, xfy, '|')
+)).
+
+test("op_remove_bar_should_succeed", (
+    op(1105, xfy, '|'),
+    op(0, xfy, '|')
+)).
+
+% ISO/IEC 13211-1:1995 §6.3.5: List notation tests
+% items = arg, ht_sep, arg | arg, comma, items | arg
+% The head-tail separator requires arg on BOTH sides
+
+test("[|] without head element should error", (
+    % [|] has no arg before the head-tail separator
+    catch(
+        (read_from_chars("[|].", _), false),
+        error(syntax_error(_), _),
+        true
+    )
+)).
+
+test("[|X] no head before separator should error", (
+    % Cannot have ht_sep as first element in items
+    catch(
+        (read_from_chars("[|X].", _), false),
+        error(syntax_error(_), _),
+        true
+    )
+)).
+
+test("[a,|] no tail after separator should error", (
+    % "arg, ht_sep, arg" requires arg after ht_sep too
+    catch(
+        (read_from_chars("[a,|].", _), false),
+        error(syntax_error(_), _),
+        true
+    )
+)).
+
+% ISO/IEC 13211-1:1995 §6.3.4: Operator notation tests
+% Infix operators (xfy) require operands on both sides
+
+test("(|) as functor argument should error", (
+    % ISO 6.3.3.1: arg = atom (if operator) | term (priority <= 999)
+    % (|) is neither a valid atom argument nor a valid term
+    op(1105, xfy, '|'),
+    catch(
+        (read_from_chars("_/_(|).", _), false),
+        error(syntax_error(_), _),
+        true
+    ),
+    op(0, xfy, '|')
+)).
+
+test("(|) in curly brackets should error", (
+    % {!*!(|)*} - (|) without operands inside expression
+    op(1105, xfy, '|'),
+    catch(
+        (read_from_chars("{!*!(|)*}.", _), false),
+        error(syntax_error(_), _),
+        true
+    ),
+    op(0, xfy, '|')
+)).
+
+% Valid patterns should succeed
+
+test("a|b valid infix operator usage", (
+    op(1105, xfy, '|'),
+    read_from_chars("a|b.", T),
+    op(0, xfy, '|'),
+    T == '|'(a, b)
+)).
+
+test("[a|b] valid list head-tail notation", (
+    read_from_chars("[a|b].", T),
+    T == [a|b]
+)).
+
+test("{a|b} operator inside curly brackets", (
+    op(1105, xfy, '|'),
+    read_from_chars("{a|b}.", T),
+    op(0, xfy, '|'),
+    T == '{}'('|'(a, b))
+)).