David
/
Pantheon
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Pantheon/tests/test_tool_calling.c

1082 lines
42 KiB
C
Raw Blame History

/* SPDX-License-Identifier: AGPL-3.0-or-later */
/* Copyright (C) 2026 David (Corey) Herrera */
/*
* Unit tests for the tool-call parser (src/serve/tool_calling.c).
*
* Focus of these tests is tc_parse_tool_calls' wrapper-tolerant parsing: the
* canonical wrapped <tool_call><function=…></function></tool_call> form AND a
* bare <function=…></function> block with no wrapper (which the Q3 nex-n2-mini
* emits most of the time) must both parse into identical structured calls, and
* text with no <function= at all must yield zero calls. Pure C string parsing,
* no model/engine deps — fully local (no CUDA/BLAS needed).
*
* The last section covers the ABANDONED call (tc_parse_tool_calls_diagnosed)
* against the fixture in abandoned_call_fixture.h, together with the
* neighbours it must NOT be confused with — an empty argument, a well-formed
* call, a turn with no opener, and a merely-malformed close over a good value.
*/
#include "lib/test.h"
#include "abandoned_call_fixture.h"
#include "../src/serve/tool_calling.h"
#include "../src/serve/json_reader.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/* A one-function tools schema (get_weather: location string, unit string) so
* parameter values get schema-typed exactly like the serve path does. */
static const char *TOOLS_JSON =
"[{\"type\":\"function\",\"function\":{\"name\":\"get_weather\","
"\"description\":\"Get the weather.\",\"parameters\":{\"type\":\"object\","
"\"properties\":{\"location\":{\"type\":\"string\"},"
"\"unit\":{\"type\":\"string\"},\"days\":{\"type\":\"integer\"}},"
"\"required\":[\"location\"]}}}]";
/* ============================================================
* Wrapped form (canonical) still parses — regression guard.
* ============================================================ */
static void test_wrapped_single(void) {
jr_value *tools = jr_parse(TOOLS_JSON);
const char *text =
"<tool_call>\n<function=get_weather>\n"
"<parameter=location>\nParis\n</parameter>\n"
"</function>\n</tool_call>";
tc_tool_call *calls = NULL; int n = -1;
int rc = tc_parse_tool_calls(text, tools, TC_DIALECT_QWEN_XML, &calls, &n);
ASSERT_INT_EQ(rc, 0);
ASSERT_INT_EQ(n, 1);
ASSERT_NOT_NULL(calls);
ASSERT_STR_EQ(calls[0].name, "get_weather");
ASSERT_STR_EQ(calls[0].arguments, "{\"location\":\"Paris\"}");
ASSERT_TRUE(strncmp(calls[0].id, "call_", 5) == 0);
tc_tool_calls_free(calls, n);
jr_free(tools);
}
/* ============================================================
* Bare form (no <tool_call> wrapper) — the Phase 1 fix.
* ============================================================ */
static void test_bare_single(void) {
jr_value *tools = jr_parse(TOOLS_JSON);
const char *text =
"<function=get_weather>\n"
"<parameter=location>\nParis\n</parameter>\n"
"</function>";
tc_tool_call *calls = NULL; int n = -1;
int rc = tc_parse_tool_calls(text, tools, TC_DIALECT_QWEN_XML, &calls, &n);
ASSERT_INT_EQ(rc, 0);
ASSERT_INT_EQ(n, 1);
ASSERT_NOT_NULL(calls);
ASSERT_STR_EQ(calls[0].name, "get_weather");
ASSERT_STR_EQ(calls[0].arguments, "{\"location\":\"Paris\"}");
ASSERT_TRUE(strncmp(calls[0].id, "call_", 5) == 0);
tc_tool_calls_free(calls, n);
jr_free(tools);
}
/* Bare and wrapped forms of the same call yield identical name + arguments
* (only the random id differs) — proves output parity. */
static void test_bare_matches_wrapped(void) {
jr_value *tools = jr_parse(TOOLS_JSON);
const char *bare =
"<function=get_weather>\n<parameter=location>\nParis\n</parameter>\n"
"<parameter=unit>\ncelsius\n</parameter>\n</function>";
const char *wrapped =
"<tool_call>\n<function=get_weather>\n<parameter=location>\nParis\n</parameter>\n"
"<parameter=unit>\ncelsius\n</parameter>\n</function>\n</tool_call>";
tc_tool_call *cb = NULL, *cw = NULL; int nb = -1, nw = -1;
ASSERT_INT_EQ(tc_parse_tool_calls(bare, tools, TC_DIALECT_QWEN_XML, &cb, &nb), 0);
ASSERT_INT_EQ(tc_parse_tool_calls(wrapped, tools, TC_DIALECT_QWEN_XML, &cw, &nw), 0);
ASSERT_INT_EQ(nb, 1);
ASSERT_INT_EQ(nw, 1);
ASSERT_STR_EQ(cb[0].name, cw[0].name);
ASSERT_STR_EQ(cb[0].arguments, cw[0].arguments);
ASSERT_STR_EQ(cb[0].arguments, "{\"location\":\"Paris\",\"unit\":\"celsius\"}");
tc_tool_calls_free(cb, nb);
tc_tool_calls_free(cw, nw);
jr_free(tools);
}
/* Integer schema typing survives the bare path (days -> bare literal). */
static void test_bare_typed_integer(void) {
jr_value *tools = jr_parse(TOOLS_JSON);
const char *text =
"<function=get_weather>\n<parameter=location>\nParis\n</parameter>\n"
"<parameter=days>\n3\n</parameter>\n</function>";
tc_tool_call *calls = NULL; int n = -1;
ASSERT_INT_EQ(tc_parse_tool_calls(text, tools, TC_DIALECT_QWEN_XML, &calls, &n), 0);
ASSERT_INT_EQ(n, 1);
ASSERT_STR_EQ(calls[0].arguments, "{\"location\":\"Paris\",\"days\":3}");
tc_tool_calls_free(calls, n);
jr_free(tools);
}
/* ============================================================
* Multiple calls in one message (bare + wrapped).
* ============================================================ */
static void test_bare_multi(void) {
jr_value *tools = jr_parse(TOOLS_JSON);
const char *text =
"<function=get_weather>\n<parameter=location>\nParis\n</parameter>\n</function>\n"
"<function=get_weather>\n<parameter=location>\nTokyo\n</parameter>\n</function>";
tc_tool_call *calls = NULL; int n = -1;
ASSERT_INT_EQ(tc_parse_tool_calls(text, tools, TC_DIALECT_QWEN_XML, &calls, &n), 0);
ASSERT_INT_EQ(n, 2);
ASSERT_STR_EQ(calls[0].arguments, "{\"location\":\"Paris\"}");
ASSERT_STR_EQ(calls[1].arguments, "{\"location\":\"Tokyo\"}");
tc_tool_calls_free(calls, n);
jr_free(tools);
}
static void test_wrapped_multi(void) {
jr_value *tools = jr_parse(TOOLS_JSON);
const char *text =
"<tool_call>\n<function=get_weather>\n<parameter=location>\nParis\n</parameter>\n</function>\n</tool_call>\n"
"<tool_call>\n<function=get_weather>\n<parameter=location>\nTokyo\n</parameter>\n</function>\n</tool_call>";
tc_tool_call *calls = NULL; int n = -1;
ASSERT_INT_EQ(tc_parse_tool_calls(text, tools, TC_DIALECT_QWEN_XML, &calls, &n), 0);
ASSERT_INT_EQ(n, 2);
ASSERT_STR_EQ(calls[0].arguments, "{\"location\":\"Paris\"}");
ASSERT_STR_EQ(calls[1].arguments, "{\"location\":\"Tokyo\"}");
tc_tool_calls_free(calls, n);
jr_free(tools);
}
/* ============================================================
* Real-world noise tolerance.
* ============================================================ */
/* Natural-language reasoning before the first bare <function= is skipped. */
static void test_reasoning_then_bare_call(void) {
jr_value *tools = jr_parse(TOOLS_JSON);
const char *text =
"I'll check the weather for you now.\n"
"<function=get_weather>\n<parameter=location>\nParis\n</parameter>\n</function>";
tc_tool_call *calls = NULL; int n = -1;
ASSERT_INT_EQ(tc_parse_tool_calls(text, tools, TC_DIALECT_QWEN_XML, &calls, &n), 0);
ASSERT_INT_EQ(n, 1);
ASSERT_STR_EQ(calls[0].name, "get_weather");
ASSERT_STR_EQ(calls[0].arguments, "{\"location\":\"Paris\"}");
tc_tool_calls_free(calls, n);
jr_free(tools);
}
/* A doubled/again </function> after a valid bare call must not crash or emit a
* second garbage call. */
static void test_bare_doubled_close(void) {
jr_value *tools = jr_parse(TOOLS_JSON);
const char *text =
"<function=get_weather>\n<parameter=location>\nParis\n</parameter>\n"
"</function>\n</function>";
tc_tool_call *calls = NULL; int n = -1;
ASSERT_INT_EQ(tc_parse_tool_calls(text, tools, TC_DIALECT_QWEN_XML, &calls, &n), 0);
ASSERT_INT_EQ(n, 1);
ASSERT_STR_EQ(calls[0].arguments, "{\"location\":\"Paris\"}");
tc_tool_calls_free(calls, n);
jr_free(tools);
}
/* A trailing </tool_call> with no opener alongside a bare call: since a real
* TC_OPEN is present in this shape only if wrapped, the bare scan handles it and
* the stray closer is inert. */
static void test_bare_call_stray_closer(void) {
jr_value *tools = jr_parse(TOOLS_JSON);
const char *text =
"<function=get_weather>\n<parameter=location>\nParis\n</parameter>\n"
"</function>\n</tool_call>";
tc_tool_call *calls = NULL; int n = -1;
ASSERT_INT_EQ(tc_parse_tool_calls(text, tools, TC_DIALECT_QWEN_XML, &calls, &n), 0);
ASSERT_INT_EQ(n, 1);
ASSERT_STR_EQ(calls[0].arguments, "{\"location\":\"Paris\"}");
tc_tool_calls_free(calls, n);
jr_free(tools);
}
/* ============================================================
* No false positives.
* ============================================================ */
/* Plain answer text with no <function= at all -> zero calls. */
static void test_no_tools_text(void) {
jr_value *tools = jr_parse(TOOLS_JSON);
const char *text = "The weather in Paris is sunny and 18 degrees celsius.";
tc_tool_call *calls = NULL; int n = -1;
ASSERT_INT_EQ(tc_parse_tool_calls(text, tools, TC_DIALECT_QWEN_XML, &calls, &n), 0);
ASSERT_INT_EQ(n, 0);
ASSERT_NULL(calls);
tc_tool_calls_free(calls, n);
jr_free(tools);
}
/* Empty string -> zero calls. */
static void test_empty(void) {
tc_tool_call *calls = (tc_tool_call *)0x1; int n = -1;
ASSERT_INT_EQ(tc_parse_tool_calls("", NULL, TC_DIALECT_QWEN_XML, &calls, &n), 0);
ASSERT_INT_EQ(n, 0);
ASSERT_NULL(calls);
}
/* NULL text -> zero calls, no crash. */
static void test_null_text(void) {
tc_tool_call *calls = (tc_tool_call *)0x1; int n = -1;
ASSERT_INT_EQ(tc_parse_tool_calls(NULL, NULL, TC_DIALECT_QWEN_XML, &calls, &n), 0);
ASSERT_INT_EQ(n, 0);
ASSERT_NULL(calls);
}
/* A stray "<function=" with no '>'-terminated name must not crash or emit a
* garbage call. */
static void test_garbage_unterminated_name(void) {
jr_value *tools = jr_parse(TOOLS_JSON);
const char *text = "here is a stray <function= tag with no close at all";
tc_tool_call *calls = NULL; int n = -1;
ASSERT_INT_EQ(tc_parse_tool_calls(text, tools, TC_DIALECT_QWEN_XML, &calls, &n), 0);
ASSERT_INT_EQ(n, 0);
ASSERT_NULL(calls);
tc_tool_calls_free(calls, n);
jr_free(tools);
}
/* An empty-name "<function=>" (has a '>' but no name) emits no call. */
static void test_garbage_empty_name(void) {
jr_value *tools = jr_parse(TOOLS_JSON);
const char *text = "<function=></function>";
tc_tool_call *calls = NULL; int n = -1;
ASSERT_INT_EQ(tc_parse_tool_calls(text, tools, TC_DIALECT_QWEN_XML, &calls, &n), 0);
ASSERT_INT_EQ(n, 0);
tc_tool_calls_free(calls, n);
jr_free(tools);
}
/* ============================================================
* Name-set gate (defense-in-depth) — a hallucinated tool name that is NOT in
* the request's tools schema must NEVER surface as a tool_call, even when it is
* otherwise well-formed XML. This is the parser-side backstop for the observed
* saber-orch degeneration: PANTHEON_TOOL_GRAMMAR=1 constrains the NAME only once
* the armed skeleton is entered, but a model that degenerates in the reasoning
* region (or a fail-open step) can leave a garbage "<function=NAME>" in the raw
* text — the parser must reject any NAME outside the tools set.
* ============================================================ */
/* The live-observed failure: a garbage hallucinated name with empty args, in an
* otherwise well-formed bare block, is dropped (0 calls). */
static void test_hallucinated_name_rejected(void) {
jr_value *tools = jr_parse(TOOLS_JSON);
const char *text =
"<function=base_agent_agent_agent_tool_tool_call_call_action_p2555577766>\n"
"</function>";
tc_tool_call *calls = NULL; int n = -1;
ASSERT_INT_EQ(tc_parse_tool_calls(text, tools, TC_DIALECT_QWEN_XML, &calls, &n), 0);
ASSERT_INT_EQ(n, 0);
ASSERT_NULL(calls);
tc_tool_calls_free(calls, n);
jr_free(tools);
}
/* Wrapped form with a hallucinated name is likewise dropped. */
static void test_hallucinated_name_rejected_wrapped(void) {
jr_value *tools = jr_parse(TOOLS_JSON);
const char *text =
"<tool_call>\n<function=not_a_real_tool>\n"
"<parameter=location>\nParis\n</parameter>\n"
"</function>\n</tool_call>";
tc_tool_call *calls = NULL; int n = -1;
ASSERT_INT_EQ(tc_parse_tool_calls(text, tools, TC_DIALECT_QWEN_XML, &calls, &n), 0);
ASSERT_INT_EQ(n, 0);
tc_tool_calls_free(calls, n);
jr_free(tools);
}
/* A KNOWN name is unaffected — a garbage block adjacent to a valid one keeps the
* valid call and drops only the bogus one. */
static void test_known_name_kept_bogus_dropped(void) {
jr_value *tools = jr_parse(TOOLS_JSON);
const char *text =
"<function=bogus_name>\n</function>\n"
"<function=get_weather>\n"
"<parameter=location>\nParis\n</parameter>\n"
"</function>";
tc_tool_call *calls = NULL; int n = -1;
ASSERT_INT_EQ(tc_parse_tool_calls(text, tools, TC_DIALECT_QWEN_XML, &calls, &n), 0);
ASSERT_INT_EQ(n, 1);
ASSERT_NOT_NULL(calls);
ASSERT_STR_EQ(calls[0].name, "get_weather");
ASSERT_STR_EQ(calls[0].arguments, "{\"location\":\"Paris\"}");
tc_tool_calls_free(calls, n);
jr_free(tools);
}
/* With NO tools schema the gate is permissive (nothing to validate against) —
* preserves the prior behavior for schema-less parses. */
static void test_no_schema_permissive(void) {
const char *text =
"<function=anything_goes>\n"
"<parameter=x>\ny\n</parameter>\n"
"</function>";
tc_tool_call *calls = NULL; int n = -1;
ASSERT_INT_EQ(tc_parse_tool_calls(text, NULL, TC_DIALECT_QWEN_XML, &calls, &n), 0);
ASSERT_INT_EQ(n, 1);
ASSERT_NOT_NULL(calls);
ASSERT_STR_EQ(calls[0].name, "anything_goes");
tc_tool_calls_free(calls, n);
jr_free(NULL);
}
/* ============================================================
* MiniCPM5 attribute-style dialect: bare, unwrapped
* <function name="NAME"><param name="KEY">VALUE</param>…</function>
* (quoted-attribute name/keys, optional CDATA values). Disjoint from the
* Qwen "<function=" / "<parameter=" forms above.
* ============================================================ */
static void test_minicpm_single(void) {
jr_value *tools = jr_parse(TOOLS_JSON);
const char *text =
"<function name=\"get_weather\">"
"<param name=\"location\">Paris</param></function>";
tc_tool_call *calls = NULL; int n = -1;
ASSERT_INT_EQ(tc_parse_tool_calls(text, tools, TC_DIALECT_QWEN_XML, &calls, &n), 0);
ASSERT_INT_EQ(n, 1);
ASSERT_NOT_NULL(calls);
ASSERT_STR_EQ(calls[0].name, "get_weather");
ASSERT_STR_EQ(calls[0].arguments, "{\"location\":\"Paris\"}");
ASSERT_TRUE(strncmp(calls[0].id, "call_", 5) == 0);
tc_tool_calls_free(calls, n);
jr_free(tools);
}
/* Typed multi-param: integer stays a JSON literal, string stays quoted. */
static void test_minicpm_typed_multi(void) {
jr_value *tools = jr_parse(TOOLS_JSON);
const char *text =
"<function name=\"get_weather\">"
"<param name=\"location\">Paris</param>"
"<param name=\"days\">3</param></function>";
tc_tool_call *calls = NULL; int n = -1;
ASSERT_INT_EQ(tc_parse_tool_calls(text, tools, TC_DIALECT_QWEN_XML, &calls, &n), 0);
ASSERT_INT_EQ(n, 1);
ASSERT_STR_EQ(calls[0].name, "get_weather");
ASSERT_STR_EQ(calls[0].arguments,
"{\"location\":\"Paris\",\"days\":3}");
tc_tool_calls_free(calls, n);
jr_free(tools);
}
/* CDATA-wrapped multi-line value is taken verbatim (wrapper stripped). */
static void test_minicpm_cdata(void) {
jr_value *tools = jr_parse(TOOLS_JSON);
const char *text =
"<function name=\"get_weather\">"
"<param name=\"location\"><![CDATA[Paris\n& Berlin]]></param>"
"</function>";
tc_tool_call *calls = NULL; int n = -1;
ASSERT_INT_EQ(tc_parse_tool_calls(text, tools, TC_DIALECT_QWEN_XML, &calls, &n), 0);
ASSERT_INT_EQ(n, 1);
ASSERT_STR_EQ(calls[0].arguments, "{\"location\":\"Paris\\n& Berlin\"}");
tc_tool_calls_free(calls, n);
jr_free(tools);
}
/* Single-quoted attributes are accepted. */
static void test_minicpm_single_quotes(void) {
jr_value *tools = jr_parse(TOOLS_JSON);
const char *text =
"<function name='get_weather'>"
"<param name='location'>Paris</param></function>";
tc_tool_call *calls = NULL; int n = -1;
ASSERT_INT_EQ(tc_parse_tool_calls(text, tools, TC_DIALECT_QWEN_XML, &calls, &n), 0);
ASSERT_INT_EQ(n, 1);
ASSERT_STR_EQ(calls[0].name, "get_weather");
ASSERT_STR_EQ(calls[0].arguments, "{\"location\":\"Paris\"}");
tc_tool_calls_free(calls, n);
jr_free(tools);
}
/* Leading reasoning prose before the call is skipped; hallucinated names are
* still gated by the schema. */
static void test_minicpm_reasoning_prefix(void) {
jr_value *tools = jr_parse(TOOLS_JSON);
const char *text =
"Let me check the weather for you.\n"
"<function name=\"get_weather\">"
"<param name=\"location\">Paris</param></function>";
tc_tool_call *calls = NULL; int n = -1;
ASSERT_INT_EQ(tc_parse_tool_calls(text, tools, TC_DIALECT_QWEN_XML, &calls, &n), 0);
ASSERT_INT_EQ(n, 1);
ASSERT_STR_EQ(calls[0].name, "get_weather");
tc_tool_calls_free(calls, n);
jr_free(tools);
}
/* The native preamble renderer emits the <tools> block + <function name=…>
* instructions (not the Qwen <parameter=…> form). */
static void test_minicpm_preamble(void) {
jr_value *tools = jr_parse(TOOLS_JSON);
char *pre = tc_render_tools_system_minicpm(tools, NULL);
ASSERT_NOT_NULL(pre);
ASSERT_TRUE(strstr(pre, "<tools>") != NULL);
ASSERT_TRUE(strstr(pre, "<function name=\"function-name\">") != NULL);
ASSERT_TRUE(strstr(pre, "<param name=\"param-name\">") != NULL);
ASSERT_TRUE(strstr(pre, "get_weather") != NULL); /* the tool JSON */
/* Must NOT carry the Qwen dialect's example form. */
ASSERT_TRUE(strstr(pre, "<parameter=") == NULL);
free(pre);
jr_free(tools);
}
/* ============================================================
* Grammar-forced dialect: the body-style <function=NAME> / <parameter=KEY>
* (like the bare Qwen form) but with an extra <value>…</value> wrapper around
* each value:
* <function=NAME>\n<parameter=KEY>\n<value>\nVALUE\n</value>\n</parameter>\n</function>
* The generation grammar accepts the wrapper as free VALUE text, so the parser
* must peel it back to the bare VALUE. Regression: without the fix the value
* captured as the literal "<value>\nVALUE\n</value>" text.
* ============================================================ */
static void test_forced_value_wrapper_bare(void) {
jr_value *tools = jr_parse(TOOLS_JSON);
const char *text =
"<function=get_weather>\n<parameter=location>\n"
"<value>\nParis\n</value>\n</parameter>\n</function>";
tc_tool_call *calls = NULL; int n = -1;
ASSERT_INT_EQ(tc_parse_tool_calls(text, tools, TC_DIALECT_QWEN_XML, &calls, &n), 0);
ASSERT_INT_EQ(n, 1);
ASSERT_NOT_NULL(calls);
ASSERT_STR_EQ(calls[0].name, "get_weather");
ASSERT_STR_EQ(calls[0].arguments, "{\"location\":\"Paris\"}");
tc_tool_calls_free(calls, n);
jr_free(tools);
}
/* Same forced dialect INSIDE a <tool_call> wrapper (the grammar's wrapped form
* with the <value> wrapper). */
static void test_forced_value_wrapper_wrapped(void) {
jr_value *tools = jr_parse(TOOLS_JSON);
const char *text =
"<tool_call>\n<function=get_weather>\n<parameter=location>\n"
"<value>\nParis\n</value>\n</parameter>\n</function>\n</tool_call>";
tc_tool_call *calls = NULL; int n = -1;
ASSERT_INT_EQ(tc_parse_tool_calls(text, tools, TC_DIALECT_QWEN_XML, &calls, &n), 0);
ASSERT_INT_EQ(n, 1);
ASSERT_STR_EQ(calls[0].name, "get_weather");
ASSERT_STR_EQ(calls[0].arguments, "{\"location\":\"Paris\"}");
tc_tool_calls_free(calls, n);
jr_free(tools);
}
/* A multi-line value inside the <value> wrapper keeps its interior newlines. */
static void test_forced_value_wrapper_multiline(void) {
jr_value *tools = jr_parse(TOOLS_JSON);
const char *text =
"<function=get_weather>\n<parameter=location>\n"
"<value>\nParis\nand Berlin\n</value>\n</parameter>\n</function>";
tc_tool_call *calls = NULL; int n = -1;
ASSERT_INT_EQ(tc_parse_tool_calls(text, tools, TC_DIALECT_QWEN_XML, &calls, &n), 0);
ASSERT_INT_EQ(n, 1);
ASSERT_STR_EQ(calls[0].arguments, "{\"location\":\"Paris\\nand Berlin\"}");
tc_tool_calls_free(calls, n);
jr_free(tools);
}
/* Typed integer survives the <value> wrapper (unwrapped, then schema-typed). */
static void test_forced_value_wrapper_typed_integer(void) {
jr_value *tools = jr_parse(TOOLS_JSON);
const char *text =
"<function=get_weather>\n<parameter=location>\n"
"<value>\nParis\n</value>\n</parameter>\n"
"<parameter=days>\n<value>\n3\n</value>\n</parameter>\n</function>";
tc_tool_call *calls = NULL; int n = -1;
ASSERT_INT_EQ(tc_parse_tool_calls(text, tools, TC_DIALECT_QWEN_XML, &calls, &n), 0);
ASSERT_INT_EQ(n, 1);
ASSERT_STR_EQ(calls[0].arguments, "{\"location\":\"Paris\",\"days\":3}");
tc_tool_calls_free(calls, n);
jr_free(tools);
}
/* An empty <value></value> inner yields an EMPTY arg, not a missing one: the
* model wrote both halves of the wrapper, so it closed the value deliberately,
* and the parameter-level close is the whole empty-value test. */
static void test_forced_value_wrapper_empty_inner(void) {
jr_value *tools = jr_parse(TOOLS_JSON);
const char *text =
"<function=get_weather>\n<parameter=location>\n"
"<value>\n</value>\n</parameter>\n</function>";
tc_tool_call *calls = NULL; int n = -1;
ASSERT_INT_EQ(tc_parse_tool_calls(text, tools, TC_DIALECT_QWEN_XML, &calls, &n), 0);
ASSERT_INT_EQ(n, 1);
/* name kept, and the closed-around-nothing value is kept as "". */
ASSERT_STR_EQ(calls[0].arguments, "{\"location\":\"\"}");
tc_tool_calls_free(calls, n);
jr_free(tools);
}
/* The forced-dialect value and the plain bare value of the same call yield
* identical structured args (only the id differs) — proves the wrapper is fully
* transparent to the client. */
static void test_forced_value_matches_plain(void) {
jr_value *tools = jr_parse(TOOLS_JSON);
const char *wrapped_val =
"<function=get_weather>\n<parameter=location>\n"
"<value>\nParis\n</value>\n</parameter>\n</function>";
const char *plain_val =
"<function=get_weather>\n<parameter=location>\nParis\n</parameter>\n</function>";
tc_tool_call *cw = NULL, *cp = NULL; int nw = -1, np = -1;
ASSERT_INT_EQ(tc_parse_tool_calls(wrapped_val, tools, TC_DIALECT_QWEN_XML, &cw, &nw), 0);
ASSERT_INT_EQ(tc_parse_tool_calls(plain_val, tools, TC_DIALECT_QWEN_XML, &cp, &np), 0);
ASSERT_INT_EQ(nw, 1);
ASSERT_INT_EQ(np, 1);
ASSERT_STR_EQ(cw[0].arguments, cp[0].arguments);
tc_tool_calls_free(cw, nw);
tc_tool_calls_free(cp, np);
jr_free(tools);
}
/* Live MiniCPM-Q8 quirk: the value is <value>-wrapped AND the </parameter> close
* is emitted malformed ("</paramet>"). PARAM_CLOSE is then never found, so a
* naive scan drags the wrapper + junk into the value. Anchoring on </value> (the
* model closes it reliably) recovers the clean value regardless. */
static void test_forced_value_wrapper_malformed_param_close(void) {
jr_value *tools = jr_parse(TOOLS_JSON);
const char *text =
"<function=get_weather>\n<parameter=location>\n"
"<value>Paris</value>\n</paramet>\n</function>";
tc_tool_call *calls = NULL; int n = -1;
ASSERT_INT_EQ(tc_parse_tool_calls(text, tools, TC_DIALECT_QWEN_XML, &calls, &n), 0);
ASSERT_INT_EQ(n, 1);
ASSERT_STR_EQ(calls[0].name, "get_weather");
ASSERT_STR_EQ(calls[0].arguments, "{\"location\":\"Paris\"}");
tc_tool_calls_free(calls, n);
jr_free(tools);
}
/* Multiple <value>-wrapped params, each with the malformed close, still parse. */
static void test_forced_value_wrapper_multi_malformed(void) {
jr_value *tools = jr_parse(TOOLS_JSON);
const char *text =
"<function=get_weather>\n"
"<parameter=location>\n<value>Paris</value>\n</paramet>\n"
"<parameter=days>\n<value>3</value>\n</paramet>\n</function>";
tc_tool_call *calls = NULL; int n = -1;
ASSERT_INT_EQ(tc_parse_tool_calls(text, tools, TC_DIALECT_QWEN_XML, &calls, &n), 0);
ASSERT_INT_EQ(n, 1);
ASSERT_STR_EQ(calls[0].arguments, "{\"location\":\"Paris\",\"days\":3}");
tc_tool_calls_free(calls, n);
jr_free(tools);
}
/* A bare value that merely CONTAINS "<value>" mid-text (not a full enclosing
* wrapper) is NOT unwrapped — only a value that both starts with <value> and
* ends with </value> is a wrapper. */
static void test_forced_value_partial_not_unwrapped(void) {
jr_value *tools = jr_parse(TOOLS_JSON);
const char *text =
"<function=get_weather>\n<parameter=location>\n"
"Paris <value> not a wrapper\n</parameter>\n</function>";
tc_tool_call *calls = NULL; int n = -1;
ASSERT_INT_EQ(tc_parse_tool_calls(text, tools, TC_DIALECT_QWEN_XML, &calls, &n), 0);
ASSERT_INT_EQ(n, 1);
ASSERT_STR_EQ(calls[0].arguments, "{\"location\":\"Paris <value> not a wrapper\"}");
tc_tool_calls_free(calls, n);
jr_free(tools);
}
/* ============================================================
* Ornith JSON dialect (TC_DIALECT_ORNITH_JSON) — Phase 1.
* The model emits a markdown-fenced or bare {"function"|"name":NAME,
* "arguments":{…}} object instead of XML.
* ============================================================ */
/* A read-tool schema (path string) matching a live agent client's envelope. */
static const char *READ_TOOLS =
"[{\"type\":\"function\",\"function\":{\"name\":\"read\","
"\"parameters\":{\"type\":\"object\","
"\"properties\":{\"path\":{\"type\":\"string\"}},"
"\"required\":[\"path\"]}}}]";
static void test_ornith_fenced_single(void) {
jr_value *tools = jr_parse(READ_TOOLS);
const char *text =
"```json\n{\n \"function\": \"read\",\n"
" \"arguments\": {\n \"path\": \"/etc/hostname\"\n }\n}\n```";
tc_tool_call *calls = NULL; int n = -1;
ASSERT_INT_EQ(tc_parse_tool_calls(text, tools, TC_DIALECT_ORNITH_JSON, &calls, &n), 0);
ASSERT_INT_EQ(n, 1);
ASSERT_STR_EQ(calls[0].name, "read");
ASSERT_STR_EQ(calls[0].arguments, "{\"path\":\"/etc/hostname\"}");
ASSERT_TRUE(strncmp(calls[0].id, "call_", 5) == 0);
tc_tool_calls_free(calls, n);
jr_free(tools);
}
/* A bare (unfenced) object with reasoning prose before it. */
static void test_ornith_bare_with_prose(void) {
jr_value *tools = jr_parse(READ_TOOLS);
const char *text =
"Let me read that file for you.\n"
"{\"function\": \"read\", \"arguments\": {\"path\": \"/tmp/a.txt\"}}";
tc_tool_call *calls = NULL; int n = -1;
ASSERT_INT_EQ(tc_parse_tool_calls(text, tools, TC_DIALECT_ORNITH_JSON, &calls, &n), 0);
ASSERT_INT_EQ(n, 1);
ASSERT_STR_EQ(calls[0].name, "read");
ASSERT_STR_EQ(calls[0].arguments, "{\"path\":\"/tmp/a.txt\"}");
tc_tool_calls_free(calls, n);
jr_free(tools);
}
/* The "name" key spelling (some emissions use it instead of "function"). */
static void test_ornith_name_key(void) {
jr_value *tools = jr_parse(READ_TOOLS);
const char *text =
"```json\n{\"name\": \"read\", \"arguments\": {\"path\": \"/x\"}}\n```";
tc_tool_call *calls = NULL; int n = -1;
ASSERT_INT_EQ(tc_parse_tool_calls(text, tools, TC_DIALECT_ORNITH_JSON, &calls, &n), 0);
ASSERT_INT_EQ(n, 1);
ASSERT_STR_EQ(calls[0].name, "read");
ASSERT_STR_EQ(calls[0].arguments, "{\"path\":\"/x\"}");
tc_tool_calls_free(calls, n);
jr_free(tools);
}
/* Schema typing: integer args stay JSON literals through the round-trip
* (arguments objects are re-serialized from the parsed DOM). */
static void test_ornith_typed_args(void) {
jr_value *tools = jr_parse(TOOLS_JSON); /* get_weather: location, unit, days(int) */
const char *text =
"{\"function\": \"get_weather\", \"arguments\": "
"{\"location\": \"Paris\", \"days\": 3}}";
tc_tool_call *calls = NULL; int n = -1;
ASSERT_INT_EQ(tc_parse_tool_calls(text, tools, TC_DIALECT_ORNITH_JSON, &calls, &n), 0);
ASSERT_INT_EQ(n, 1);
ASSERT_STR_EQ(calls[0].name, "get_weather");
ASSERT_STR_EQ(calls[0].arguments, "{\"location\":\"Paris\",\"days\":3}");
tc_tool_calls_free(calls, n);
jr_free(tools);
}
/* Parallel calls: two fenced JSON blocks in one emission. */
static void test_ornith_parallel_blocks(void) {
jr_value *tools = jr_parse(READ_TOOLS);
const char *text =
"```json\n{\"function\":\"read\",\"arguments\":{\"path\":\"/a\"}}\n```\n"
"```json\n{\"function\":\"read\",\"arguments\":{\"path\":\"/b\"}}\n```";
tc_tool_call *calls = NULL; int n = -1;
ASSERT_INT_EQ(tc_parse_tool_calls(text, tools, TC_DIALECT_ORNITH_JSON, &calls, &n), 0);
ASSERT_INT_EQ(n, 2);
ASSERT_STR_EQ(calls[0].arguments, "{\"path\":\"/a\"}");
ASSERT_STR_EQ(calls[1].arguments, "{\"path\":\"/b\"}");
tc_tool_calls_free(calls, n);
jr_free(tools);
}
/* An unknown function name is dropped (never surfaced as a bogus call). */
static void test_ornith_unknown_name_dropped(void) {
jr_value *tools = jr_parse(READ_TOOLS);
const char *text =
"{\"function\":\"delete_everything\",\"arguments\":{\"path\":\"/\"}}";
tc_tool_call *calls = NULL; int n = -1;
ASSERT_INT_EQ(tc_parse_tool_calls(text, tools, TC_DIALECT_ORNITH_JSON, &calls, &n), 0);
ASSERT_INT_EQ(n, 0);
tc_tool_calls_free(calls, n);
jr_free(tools);
}
/* Malformed / truncated JSON → zero calls (never a bogus call). */
static void test_ornith_truncated_zero(void) {
jr_value *tools = jr_parse(READ_TOOLS);
const char *text = "```json\n{\"function\":\"read\",\"arguments\":{\"path\":";
tc_tool_call *calls = NULL; int n = -1;
ASSERT_INT_EQ(tc_parse_tool_calls(text, tools, TC_DIALECT_ORNITH_JSON, &calls, &n), 0);
ASSERT_INT_EQ(n, 0);
tc_tool_calls_free(calls, n);
jr_free(tools);
}
/* Plain prose with no JSON object → zero calls. */
static void test_ornith_prose_only(void) {
jr_value *tools = jr_parse(READ_TOOLS);
const char *text = "I don't think I need a tool for this one.";
tc_tool_call *calls = NULL; int n = -1;
ASSERT_INT_EQ(tc_parse_tool_calls(text, tools, TC_DIALECT_ORNITH_JSON, &calls, &n), 0);
ASSERT_INT_EQ(n, 0);
tc_tool_calls_free(calls, n);
jr_free(tools);
}
/* Render→parse round-trip for ornith: history render produces a fenced JSON
* block the ornith parser reads back into the identical call. */
static void test_ornith_render_roundtrip(void) {
jr_value *tools = jr_parse(READ_TOOLS);
const char *calls_json =
"[{\"id\":\"call_1\",\"type\":\"function\",\"function\":"
"{\"name\":\"read\",\"arguments\":\"{\\\"path\\\":\\\"/etc/hostname\\\"}\"}}]";
jr_value *tc = jr_parse(calls_json);
char *rendered = tc_render_assistant_tool_calls(tc, true, TC_DIALECT_ORNITH_JSON);
ASSERT_NOT_NULL(rendered);
ASSERT_TRUE(strstr(rendered, "```json") != NULL);
tc_tool_call *calls = NULL; int n = -1;
ASSERT_INT_EQ(tc_parse_tool_calls(rendered, tools, TC_DIALECT_ORNITH_JSON, &calls, &n), 0);
ASSERT_INT_EQ(n, 1);
ASSERT_STR_EQ(calls[0].name, "read");
ASSERT_STR_EQ(calls[0].arguments, "{\"path\":\"/etc/hostname\"}");
tc_tool_calls_free(calls, n);
free(rendered);
jr_free(tc);
jr_free(tools);
}
/* A bare "{" in a QWEN_XML request must NOT be parsed as a call (dialect gate:
* the JSON parser only runs for ORNITH_JSON). */
static void test_json_ignored_under_xml_dialect(void) {
jr_value *tools = jr_parse(READ_TOOLS);
const char *text =
"{\"function\":\"read\",\"arguments\":{\"path\":\"/etc/hostname\"}}";
tc_tool_call *calls = NULL; int n = -1;
ASSERT_INT_EQ(tc_parse_tool_calls(text, tools, TC_DIALECT_QWEN_XML, &calls, &n), 0);
ASSERT_INT_EQ(n, 0);
tc_tool_calls_free(calls, n);
jr_free(tools);
}
/* Dialect resolver (tc_dialect_for_model) — name/arch table. */
static void test_dialect_resolver(void) {
ASSERT_INT_EQ(tc_dialect_for_model("ornith", false), TC_DIALECT_ORNITH_JSON);
ASSERT_INT_EQ(tc_dialect_for_model("Ornith-1.0-9B", false), TC_DIALECT_ORNITH_JSON);
ASSERT_INT_EQ(tc_dialect_for_model("saber-orch", false), TC_DIALECT_QWEN_XML);
ASSERT_INT_EQ(tc_dialect_for_model("nex-n2-mini", false), TC_DIALECT_QWEN_XML);
ASSERT_INT_EQ(tc_dialect_for_model("minicpm5", true), TC_DIALECT_MINICPM_XML);
/* Name table wins over the minicpm flag for an ornith model. */
ASSERT_INT_EQ(tc_dialect_for_model("ornith", true), TC_DIALECT_ORNITH_JSON);
ASSERT_INT_EQ(tc_dialect_for_model(NULL, false), TC_DIALECT_QWEN_XML);
}
/* ============================================================
* Abandoned call (TC_PARSE_CALL_ABANDONED).
*
* The defect: an opener and a <parameter=KEY> were emitted, the parameter
* was never closed, and no value was ever written — the model stopped in the
* middle of the call. That used to parse to `{}`, which is byte-identical to
* what a deliberately EMPTY argument produces, so a client could not tell the
* two apart. The neighbour tests below are the point of the whole fix: three
* conditions, three different answers.
* ============================================================ */
static void test_abandoned_call_fixture(void) {
jr_value *tools = jr_parse(READ_TOOLS);
tc_tool_call *calls = NULL; int n = -1;
tc_parse_error err = {0};
/* The 57-byte abandoned emission, as the diagnostic reports it. */
ASSERT_INT_EQ(tc_parse_tool_calls_diagnosed(FX_ABANDONED_READ_PATH, tools,
TC_DIALECT_QWEN_XML,
&calls, &n, &err, NULL), 0);
ASSERT_INT_EQ(n, 0); /* not a call — a truncation */
ASSERT_INT_EQ(err.kind, TC_PARSE_CALL_ABANDONED);
ASSERT_STR_EQ(tc_parse_failure_code(err.kind), "call_abandoned");
ASSERT_STR_EQ(err.function_name, "read");
ASSERT_STR_EQ(err.parameter_name, "path"); /* names the key left open */
ASSERT_TRUE(err.message != NULL);
ASSERT_TRUE(strstr(err.message, "read") != NULL);
ASSERT_TRUE(strstr(err.message, "abandoned") != NULL);
ASSERT_TRUE(strstr(err.message, "'path'") != NULL);
tc_parse_error_free(&err);
ASSERT_INT_EQ(err.kind, TC_PARSE_OK); /* reset, nothing to leak */
tc_tool_calls_free(calls, n);
jr_free(tools);
}
/* Both entry points agree on the RESULT: the abandoned call is absent either
* way. tc_parse_tool_calls just does not say why. */
static void test_abandoned_legacy_entry_point_agrees(void) {
jr_value *tools = jr_parse(READ_TOOLS);
tc_tool_call *calls = NULL; int n = -1;
ASSERT_INT_EQ(tc_parse_tool_calls(FX_ABANDONED_READ_PATH, tools,
TC_DIALECT_QWEN_XML, &calls, &n), 0);
ASSERT_INT_EQ(n, 0);
tc_tool_calls_free(calls, n);
jr_free(tools);
}
/* The call ends at END OF TEXT rather than at </function> — same shape, same
* verdict. The close tag is not what makes it abandoned; the missing
* </parameter> plus the missing value is. */
static void test_abandoned_at_end_of_text(void) {
jr_value *tools = jr_parse(READ_TOOLS);
const char *text = "<function=read>\n<parameter=path>\n";
tc_tool_call *calls = NULL; int n = -1;
tc_parse_error err = {0};
ASSERT_INT_EQ(tc_parse_tool_calls_diagnosed(text, tools, TC_DIALECT_QWEN_XML,
&calls, &n, &err, NULL), 0);
ASSERT_INT_EQ(n, 0);
ASSERT_INT_EQ(err.kind, TC_PARSE_CALL_ABANDONED);
ASSERT_STR_EQ(err.parameter_name, "path");
tc_parse_error_free(&err);
tc_tool_calls_free(calls, n);
jr_free(tools);
}
/* NEIGHBOUR 1 — a genuinely EMPTY argument. The parameter IS closed, so the
* model finished writing the argument; the call is emitted, and the argument
* with it, empty. This is the condition that used to be indistinguishable from
* abandoned — and dropping the value put it right back, because a member the
* serve deleted and one the model never sent read identically at the client. */
static void test_abandoned_neighbour_empty_value_still_a_call(void) {
jr_value *tools = jr_parse(READ_TOOLS);
const char *text =
"<tool_call>\n<function=read>\n<parameter=path>\n\n</parameter>\n"
"</function>";
tc_tool_call *calls = NULL; int n = -1;
tc_parse_error err = {0};
ASSERT_INT_EQ(tc_parse_tool_calls_diagnosed(text, tools, TC_DIALECT_QWEN_XML,
&calls, &n, &err, NULL), 0);
ASSERT_INT_EQ(n, 1);
ASSERT_STR_EQ(calls[0].name, "read");
ASSERT_STR_EQ(calls[0].arguments, "{\"path\":\"\"}");
ASSERT_INT_EQ(err.kind, TC_PARSE_OK); /* NOT abandoned */
tc_parse_error_free(&err);
tc_tool_calls_free(calls, n);
jr_free(tools);
}
/* NEIGHBOUR 2 — a well-formed call is untouched: still one call, still its
* arguments, and no error. */
static void test_abandoned_neighbour_wellformed_untouched(void) {
jr_value *tools = jr_parse(READ_TOOLS);
const char *text =
"<tool_call>\n<function=read>\n<parameter=path>\n/etc/hostname\n"
"</parameter>\n</function>";
tc_tool_call *calls = NULL; int n = -1;
tc_parse_error err = {0};
ASSERT_INT_EQ(tc_parse_tool_calls_diagnosed(text, tools, TC_DIALECT_QWEN_XML,
&calls, &n, &err, NULL), 0);
ASSERT_INT_EQ(n, 1);
ASSERT_STR_EQ(calls[0].arguments, "{\"path\":\"/etc/hostname\"}");
ASSERT_INT_EQ(err.kind, TC_PARSE_OK);
tc_parse_error_free(&err);
tc_tool_calls_free(calls, n);
jr_free(tools);
}
/* NEIGHBOUR 3 — no opener at all is untouched: zero calls AND no error, which
* is a different answer from the abandoned zero-calls-plus-error. */
static void test_abandoned_neighbour_no_opener_untouched(void) {
jr_value *tools = jr_parse(READ_TOOLS);
const char *text = "I could read that file, but let me think first.";
tc_tool_call *calls = NULL; int n = -1;
tc_parse_error err = {0};
ASSERT_INT_EQ(tc_parse_tool_calls_diagnosed(text, tools, TC_DIALECT_QWEN_XML,
&calls, &n, &err, NULL), 0);
ASSERT_INT_EQ(n, 0);
ASSERT_INT_EQ(err.kind, TC_PARSE_OK);
tc_parse_error_free(&err);
tc_tool_calls_free(calls, n);
jr_free(tools);
}
/* NEIGHBOUR 4 — the missing close tag ALONE is not abandonment. The live
* MiniCPM-Q8 "</paramet>" quirk drops the close over a perfectly good value;
* that call must still come through, unflagged. */
static void test_abandoned_unclosed_but_valued_is_a_call(void) {
jr_value *tools = jr_parse(READ_TOOLS);
const char *text =
"<function=read>\n<parameter=path>\n/etc/hostname\n</function>";
tc_tool_call *calls = NULL; int n = -1;
tc_parse_error err = {0};
ASSERT_INT_EQ(tc_parse_tool_calls_diagnosed(text, tools, TC_DIALECT_QWEN_XML,
&calls, &n, &err, NULL), 0);
ASSERT_INT_EQ(n, 1);
ASSERT_STR_EQ(calls[0].arguments, "{\"path\":\"/etc/hostname\"}");
ASSERT_INT_EQ(err.kind, TC_PARSE_OK);
tc_parse_error_free(&err);
tc_tool_calls_free(calls, n);
jr_free(tools);
}
/* A healthy call BEFORE an abandoned one: the good call survives and the
* abandoned one is reported, so one truncation does not cost the whole turn. */
static void test_abandoned_after_a_good_call(void) {
jr_value *tools = jr_parse(READ_TOOLS);
const char *text =
"<function=read>\n<parameter=path>\n/etc/hostname\n</parameter>\n</function>\n"
"<function=read>\n<parameter=path>\n</function>";
tc_tool_call *calls = NULL; int n = -1;
tc_parse_error err = {0};
ASSERT_INT_EQ(tc_parse_tool_calls_diagnosed(text, tools, TC_DIALECT_QWEN_XML,
&calls, &n, &err, NULL), 0);
ASSERT_INT_EQ(n, 1);
ASSERT_STR_EQ(calls[0].arguments, "{\"path\":\"/etc/hostname\"}");
ASSERT_INT_EQ(err.kind, TC_PARSE_CALL_ABANDONED);
ASSERT_STR_EQ(err.parameter_name, "path");
tc_parse_error_free(&err);
tc_tool_calls_free(calls, n);
jr_free(tools);
}
/* ============================================================
* Main
* ============================================================ */
int main(void) {
printf("\n tool-call parser tests\n\n");
RUN_TEST(wrapped_single);
RUN_TEST(bare_single);
RUN_TEST(bare_matches_wrapped);
RUN_TEST(bare_typed_integer);
RUN_TEST(bare_multi);
RUN_TEST(wrapped_multi);
RUN_TEST(reasoning_then_bare_call);
RUN_TEST(bare_doubled_close);
RUN_TEST(bare_call_stray_closer);
RUN_TEST(no_tools_text);
RUN_TEST(empty);
RUN_TEST(null_text);
RUN_TEST(garbage_unterminated_name);
RUN_TEST(garbage_empty_name);
RUN_TEST(hallucinated_name_rejected);
RUN_TEST(hallucinated_name_rejected_wrapped);
RUN_TEST(known_name_kept_bogus_dropped);
RUN_TEST(no_schema_permissive);
RUN_TEST(minicpm_single);
RUN_TEST(minicpm_typed_multi);
RUN_TEST(minicpm_cdata);
RUN_TEST(minicpm_single_quotes);
RUN_TEST(minicpm_reasoning_prefix);
RUN_TEST(minicpm_preamble);
RUN_TEST(forced_value_wrapper_bare);
RUN_TEST(forced_value_wrapper_wrapped);
RUN_TEST(forced_value_wrapper_multiline);
RUN_TEST(forced_value_wrapper_typed_integer);
RUN_TEST(forced_value_wrapper_empty_inner);
RUN_TEST(forced_value_matches_plain);
RUN_TEST(forced_value_wrapper_malformed_param_close);
RUN_TEST(forced_value_wrapper_multi_malformed);
RUN_TEST(forced_value_partial_not_unwrapped);
RUN_TEST(ornith_fenced_single);
RUN_TEST(ornith_bare_with_prose);
RUN_TEST(ornith_name_key);
RUN_TEST(ornith_typed_args);
RUN_TEST(ornith_parallel_blocks);
RUN_TEST(ornith_unknown_name_dropped);
RUN_TEST(ornith_truncated_zero);
RUN_TEST(ornith_prose_only);
RUN_TEST(ornith_render_roundtrip);
RUN_TEST(json_ignored_under_xml_dialect);
RUN_TEST(dialect_resolver);
RUN_TEST(abandoned_call_fixture);
RUN_TEST(abandoned_legacy_entry_point_agrees);
RUN_TEST(abandoned_at_end_of_text);
RUN_TEST(abandoned_neighbour_empty_value_still_a_call);
RUN_TEST(abandoned_neighbour_wellformed_untouched);
RUN_TEST(abandoned_neighbour_no_opener_untouched);
RUN_TEST(abandoned_unclosed_but_valued_is_a_call);
RUN_TEST(abandoned_after_a_good_call);
TEST_REPORT();
return __ft_failed > 0 ? 1 : 0;
}
Reference in New Issue View Git Blame Copy Permalink