W21: anthropic Stream+Tools + --prompt batch + sanitizer fix + plugin unit tests (W21.1-W21.6)
- W21.1: ci-sanitize preset 独立 Linux-clang + ci-threadsan (TSan) - W21.2: anthropic tool_use content_block 解析 + configure 缓存 tools_json - W21.3: --prompt 非交互批处理模式 - W21.4: session auto-save 失败告警 + 当前目录 fallback - W21.5: smoke 补 tool_calls 边界用例 4 块 12 断言 - W21.6: anthropic 11 块 78 CHECK + deepseek 12 块 78 CHECK Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
This commit is contained in:
558
tests/anthropic_plugin_test.cpp
Normal file
558
tests/anthropic_plugin_test.cpp
Normal file
@@ -0,0 +1,558 @@
|
||||
// ============================================================================
|
||||
// anthropic_plugin_test.cpp — Anthropic AI 插件单元测试
|
||||
// W21.6 (qa-wang): 覆盖 SSE 解析 / JSON 请求构建 / URL 解析 / 安全擦除
|
||||
// 通过 #include plugin source 访问 file-scope static 函数
|
||||
// ============================================================================
|
||||
#define BOOST_JSON_HEADER_ONLY
|
||||
#define BOOST_ALL_NO_LIB
|
||||
#include "../plugins/anthropic/src/anthropic_plugin.cpp"
|
||||
|
||||
#include <cstring>
|
||||
#include <iostream>
|
||||
#include <string>
|
||||
|
||||
static int g_failures = 0;
|
||||
#define CHECK(cond, msg) do { \
|
||||
if (cond) { \
|
||||
std::cout << "[OK] " << (msg) << "\n"; \
|
||||
} else { \
|
||||
std::cerr << "[FAIL] " << (msg) << "\n"; \
|
||||
g_failures++; \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
// Test helper: populate g_cfg for build functions
|
||||
static void setup_config() {
|
||||
g_cfg.provider = "anthropic";
|
||||
g_cfg.base_url = "https://api.anthropic.com";
|
||||
g_cfg.api_key = "sk-ant-test-key-12345";
|
||||
g_cfg.model = "claude-sonnet-4-20250514";
|
||||
g_cfg.max_tokens = 4096;
|
||||
g_cfg.temperature = 0.7;
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
// ================================================================
|
||||
// Test Block 1: parse_sse_data — invalid/malformed inputs
|
||||
// ================================================================
|
||||
std::cout << "\n--- Block 1: parse_sse_data invalid/malformed ---\n";
|
||||
|
||||
{
|
||||
std::string token;
|
||||
bool ret = parse_sse_data("", token, nullptr);
|
||||
CHECK(!ret, "T1.1: empty string returns false");
|
||||
}
|
||||
|
||||
{
|
||||
std::string token;
|
||||
bool ret = parse_sse_data("not json at all", token, nullptr);
|
||||
CHECK(!ret, "T1.2: non-JSON string returns false (no crash)");
|
||||
}
|
||||
|
||||
{
|
||||
std::string token;
|
||||
bool ret = parse_sse_data("{}", token, nullptr);
|
||||
CHECK(!ret, "T1.3: empty JSON object returns false");
|
||||
}
|
||||
|
||||
{
|
||||
std::string token;
|
||||
bool ret = parse_sse_data("{\"notype\":\"x\"}", token, nullptr);
|
||||
CHECK(!ret, "T1.4: JSON without 'type' field returns false");
|
||||
}
|
||||
|
||||
{
|
||||
std::string token;
|
||||
bool ret = parse_sse_data("{\"type\":123}", token, nullptr);
|
||||
CHECK(!ret, "T1.5: 'type' is number (not string) returns false");
|
||||
}
|
||||
|
||||
{
|
||||
// Malformed JSON: unclosed brace
|
||||
std::string token;
|
||||
bool ret = parse_sse_data("{\"type\":\"ping\"", token, nullptr);
|
||||
CHECK(!ret, "T1.6: malformed JSON (unclosed brace) returns false (no crash)");
|
||||
}
|
||||
|
||||
{
|
||||
// Random garbage bytes
|
||||
std::string token;
|
||||
bool ret = parse_sse_data("\x00\x01\xFF\xFE", token, nullptr);
|
||||
CHECK(!ret, "T1.7: binary garbage returns false (no crash)");
|
||||
}
|
||||
|
||||
// ================================================================
|
||||
// Test Block 2: parse_sse_data — content_block_delta
|
||||
// ================================================================
|
||||
std::cout << "\n--- Block 2: parse_sse_data content_block_delta ---\n";
|
||||
|
||||
{
|
||||
std::string token;
|
||||
const char* json =
|
||||
"{\"type\":\"content_block_delta\","
|
||||
"\"delta\":{\"type\":\"text_delta\",\"text\":\"Hello\"}}";
|
||||
bool ret = parse_sse_data(json, token, nullptr);
|
||||
CHECK(ret, "T2.1: text_delta with 'Hello' returns true");
|
||||
CHECK(token == "Hello", "T2.2: token equals 'Hello'");
|
||||
}
|
||||
|
||||
{
|
||||
std::string token;
|
||||
const char* json =
|
||||
"{\"type\":\"content_block_delta\","
|
||||
"\"delta\":{\"type\":\"text_delta\",\"text\":\"\"}}";
|
||||
bool ret = parse_sse_data(json, token, nullptr);
|
||||
CHECK(ret, "T2.3: text_delta with empty text returns true");
|
||||
CHECK(token.empty(), "T2.4: token is empty string");
|
||||
}
|
||||
|
||||
{
|
||||
std::string token;
|
||||
const char* json =
|
||||
"{\"type\":\"content_block_delta\","
|
||||
"\"delta\":{\"type\":\"text_delta\"}}";
|
||||
bool ret = parse_sse_data(json, token, nullptr);
|
||||
CHECK(!ret, "T2.5: text_delta missing 'text' field returns false");
|
||||
}
|
||||
|
||||
{
|
||||
std::string token;
|
||||
const char* json =
|
||||
"{\"type\":\"content_block_delta\","
|
||||
"\"delta\":{\"type\":\"input_json_delta\","
|
||||
"\"partial_json\":\"{\\\"foo\\\":\"}}";
|
||||
bool ret = parse_sse_data(json, token, nullptr);
|
||||
CHECK(!ret, "T2.6: input_json_delta (non-text) returns false");
|
||||
}
|
||||
|
||||
{
|
||||
std::string token;
|
||||
const char* json =
|
||||
"{\"type\":\"content_block_delta\","
|
||||
"\"delta\":\"not_an_object\"}";
|
||||
bool ret = parse_sse_data(json, token, nullptr);
|
||||
CHECK(!ret, "T2.7: delta is string (not object) returns false");
|
||||
}
|
||||
|
||||
{
|
||||
std::string token;
|
||||
const char* json =
|
||||
"{\"type\":\"content_block_delta\","
|
||||
"\"delta\":{\"no_type_here\":\"x\"}}";
|
||||
bool ret = parse_sse_data(json, token, nullptr);
|
||||
CHECK(!ret, "T2.8: delta without 'type' field returns false");
|
||||
}
|
||||
|
||||
// ================================================================
|
||||
// Test Block 3: parse_sse_data — message_stop / ignored types
|
||||
// ================================================================
|
||||
std::cout << "\n--- Block 3: parse_sse_data message_stop / ignored types ---\n";
|
||||
|
||||
{
|
||||
std::string token = "SHOULD_BE_CLEARED";
|
||||
const char* json = "{\"type\":\"message_stop\"}";
|
||||
bool ret = parse_sse_data(json, token, nullptr);
|
||||
CHECK(ret, "T3.1: message_stop returns true (stream end)");
|
||||
CHECK(token.empty(), "T3.2: message_stop clears token");
|
||||
}
|
||||
|
||||
{
|
||||
std::string token;
|
||||
const char* json = "{\"type\":\"message_start\",\"message\":{}}";
|
||||
bool ret = parse_sse_data(json, token, nullptr);
|
||||
CHECK(!ret, "T3.3: message_start returns false (ignored)");
|
||||
}
|
||||
|
||||
{
|
||||
std::string token;
|
||||
const char* json = "{\"type\":\"content_block_start\"}";
|
||||
bool ret = parse_sse_data(json, token, nullptr);
|
||||
CHECK(!ret, "T3.4: content_block_start returns false (ignored)");
|
||||
}
|
||||
|
||||
{
|
||||
std::string token;
|
||||
const char* json = "{\"type\":\"content_block_stop\"}";
|
||||
bool ret = parse_sse_data(json, token, nullptr);
|
||||
CHECK(!ret, "T3.5: content_block_stop returns false (ignored)");
|
||||
}
|
||||
|
||||
{
|
||||
std::string token;
|
||||
const char* json = "{\"type\":\"ping\"}";
|
||||
bool ret = parse_sse_data(json, token, nullptr);
|
||||
CHECK(!ret, "T3.6: ping returns false (ignored)");
|
||||
}
|
||||
|
||||
{
|
||||
std::string token;
|
||||
const char* json = "{\"type\":\"message_delta\"}";
|
||||
bool ret = parse_sse_data(json, token, nullptr);
|
||||
CHECK(!ret, "T3.7: message_delta returns false (ignored)");
|
||||
}
|
||||
|
||||
// ================================================================
|
||||
// Test Block 4: parse_sse_data — deeply nested / edge structures
|
||||
// ================================================================
|
||||
std::cout << "\n--- Block 4: parse_sse_data deep/edge structures ---\n";
|
||||
|
||||
{
|
||||
// Unrecognized event type should just be ignored
|
||||
std::string token;
|
||||
const char* json = "{\"type\":\"some_unknown_future_type\"}";
|
||||
bool ret = parse_sse_data(json, token, nullptr);
|
||||
CHECK(!ret, "T4.1: unknown type returns false (ignored)");
|
||||
}
|
||||
|
||||
{
|
||||
// text_delta with unicode content (Japanese)
|
||||
std::string token;
|
||||
const char* json =
|
||||
"{\"type\":\"content_block_delta\","
|
||||
"\"delta\":{\"type\":\"text_delta\","
|
||||
"\"text\":\"\\u3053\\u3093\\u306b\\u3061\\u306f\"}}";
|
||||
bool ret = parse_sse_data(json, token, nullptr);
|
||||
CHECK(ret, "T4.2: unicode text_delta returns true");
|
||||
CHECK(token == "\xe3\x81\x93\xe3\x82\x93\xe3\x81\xab"
|
||||
"\xe3\x81\xa1\xe3\x81\xaf",
|
||||
"T4.3: unicode token decoded correctly"); // こんにちは
|
||||
}
|
||||
|
||||
{
|
||||
// Realistic Anthropic SSE chunk (content_block_delta + text_delta)
|
||||
std::string token;
|
||||
const char* json =
|
||||
"{\"type\":\"content_block_delta\","
|
||||
"\"index\":0,"
|
||||
"\"delta\":{\"type\":\"text_delta\",\"text\":\" I'm\"}}";
|
||||
bool ret = parse_sse_data(json, token, nullptr);
|
||||
CHECK(ret, "T4.4: realistic SSE chunk returns true");
|
||||
CHECK(token == " I'm", "T4.5: token ' I'm' correct");
|
||||
}
|
||||
|
||||
// ================================================================
|
||||
// Test Block 5: build_request_json — basic cases
|
||||
// ================================================================
|
||||
setup_config();
|
||||
std::cout << "\n--- Block 5: build_request_json basic ---\n";
|
||||
|
||||
{
|
||||
// Single user input, no history, stream=false
|
||||
std::string json = build_request_json(nullptr, 0, "Hello", "", false);
|
||||
CHECK(!json.empty(), "T5.1: non-empty JSON produced");
|
||||
CHECK(json.find("\"messages\"") != std::string::npos,
|
||||
"T5.2: contains 'messages' array");
|
||||
CHECK(json.find("\"user\"") != std::string::npos,
|
||||
"T5.3: contains 'user' role");
|
||||
CHECK(json.find("\"Hello\"") != std::string::npos,
|
||||
"T5.4: contains user input text");
|
||||
CHECK(json.find("\"stream\":false") != std::string::npos,
|
||||
"T5.5: stream=false present");
|
||||
CHECK(json.find("\"model\":\"claude-sonnet-4-20250514\"")
|
||||
!= std::string::npos,
|
||||
"T5.6: model field present");
|
||||
CHECK(json.find("\"max_tokens\":4096") != std::string::npos,
|
||||
"T5.7: max_tokens field present");
|
||||
}
|
||||
|
||||
{
|
||||
// With system message in history
|
||||
dstalk_message_t msgs[1] = {
|
||||
{"system", "You are a helpful assistant", nullptr, nullptr}
|
||||
};
|
||||
std::string json = build_request_json(msgs, 1, "Hello", "", false);
|
||||
CHECK(json.find("\"system\"") != std::string::npos,
|
||||
"T5.8: system prompt extracted to 'system' field");
|
||||
CHECK(json.find("You are a helpful assistant") != std::string::npos,
|
||||
"T5.9: system prompt content present");
|
||||
// messages should NOT contain the system role
|
||||
// (since system messages are stripped from messages[] and put in system field)
|
||||
// Actually, the code puts non-system into msgs. Let me check if system is in messages...
|
||||
// The loop skips system: `if (m.role && strcmp(m.role, "system")==0) { ... continue; }`
|
||||
// So system should NOT be in the messages array.
|
||||
CHECK(json.find("\"role\":\"system\"") == std::string::npos,
|
||||
"T5.10: system role NOT in messages array");
|
||||
}
|
||||
|
||||
{
|
||||
// With user+assistant history
|
||||
dstalk_message_t msgs[2] = {
|
||||
{"user", "What is 2+2?", nullptr, nullptr},
|
||||
{"assistant", "It is 4.", nullptr, nullptr}
|
||||
};
|
||||
std::string json = build_request_json(msgs, 2, "Thanks!", "", false);
|
||||
CHECK(json.find("\"role\":\"user\"") != std::string::npos,
|
||||
"T5.11: user role present in messages");
|
||||
CHECK(json.find("\"role\":\"assistant\"") != std::string::npos,
|
||||
"T5.12: assistant role present in messages");
|
||||
CHECK(json.find("Thanks!") != std::string::npos,
|
||||
"T5.13: current user input present");
|
||||
}
|
||||
|
||||
// ================================================================
|
||||
// Test Block 6: build_request_json — edge cases
|
||||
// ================================================================
|
||||
std::cout << "\n--- Block 6: build_request_json edge cases ---\n";
|
||||
|
||||
{
|
||||
// Empty user input
|
||||
std::string json = build_request_json(nullptr, 0, "", "", false);
|
||||
CHECK(!json.empty(), "T6.1: empty user input produces valid JSON");
|
||||
CHECK(json.find("\"role\":\"user\"") != std::string::npos,
|
||||
"T6.2: user role still present with empty content");
|
||||
CHECK(json.find("\"content\":\"\"") != std::string::npos,
|
||||
"T6.3: empty content string present");
|
||||
// The user input IS added even if empty (line 109-112: no check for empty)
|
||||
}
|
||||
|
||||
{
|
||||
// Stream=true
|
||||
std::string json = build_request_json(nullptr, 0, "Hi", "", true);
|
||||
CHECK(json.find("\"stream\":true") != std::string::npos,
|
||||
"T6.4: stream=true present");
|
||||
}
|
||||
|
||||
{
|
||||
// Temperature in valid range -> should be included
|
||||
g_cfg.temperature = 1.0;
|
||||
std::string json = build_request_json(nullptr, 0, "Hi", "", false);
|
||||
CHECK(json.find("\"temperature\"") != std::string::npos,
|
||||
"T6.5: temperature=1.0 included (boundary valid)");
|
||||
g_cfg.temperature = 0.7; // reset
|
||||
}
|
||||
|
||||
{
|
||||
// Temperature out of range -> should NOT be included
|
||||
g_cfg.temperature = 1.5;
|
||||
std::string json = build_request_json(nullptr, 0, "Hi", "", false);
|
||||
CHECK(json.find("\"temperature\"") == std::string::npos,
|
||||
"T6.6: temperature=1.5 (>1.0) omitted");
|
||||
g_cfg.temperature = -0.5;
|
||||
json = build_request_json(nullptr, 0, "Hi", "", false);
|
||||
CHECK(json.find("\"temperature\"") == std::string::npos,
|
||||
"T6.7: temperature=-0.5 (<0.0) omitted");
|
||||
g_cfg.temperature = 0.7; // reset
|
||||
}
|
||||
|
||||
{
|
||||
// History with null role (should default to "")
|
||||
dstalk_message_t msgs[1] = {
|
||||
{nullptr, "some content", nullptr, nullptr}
|
||||
};
|
||||
std::string json = build_request_json(msgs, 1, "Hi", "", false);
|
||||
CHECK(!json.empty(), "T6.8: null role produces valid JSON (no crash)");
|
||||
}
|
||||
|
||||
{
|
||||
// History with null content
|
||||
dstalk_message_t msgs[1] = {
|
||||
{"user", nullptr, nullptr, nullptr}
|
||||
};
|
||||
std::string json = build_request_json(msgs, 1, "Hi", "", false);
|
||||
CHECK(!json.empty(), "T6.9: null content produces valid JSON (no crash)");
|
||||
}
|
||||
|
||||
{
|
||||
// Very long message (>2000 chars) — validate no truncation / crash
|
||||
std::string long_input(5000, 'A');
|
||||
std::string json = build_request_json(nullptr, 0, long_input, "", false);
|
||||
CHECK(!json.empty(), "T6.10: 5000-char input produces valid JSON");
|
||||
CHECK(json.length() > 5000, "T6.11: JSON longer than input (wraps content)");
|
||||
}
|
||||
|
||||
{
|
||||
// Multiple system messages concatenated
|
||||
dstalk_message_t msgs[2] = {
|
||||
{"system", "Rule 1: be polite", nullptr, nullptr},
|
||||
{"system", "Rule 2: be concise", nullptr, nullptr}
|
||||
};
|
||||
std::string json = build_request_json(msgs, 2, "Hello", "", false);
|
||||
CHECK(json.find("be polite") != std::string::npos,
|
||||
"T6.12: first system prompt present");
|
||||
CHECK(json.find("be concise") != std::string::npos,
|
||||
"T6.13: second system prompt present (concatenated)");
|
||||
}
|
||||
|
||||
// ================================================================
|
||||
// Test Block 7: build_headers_json
|
||||
// ================================================================
|
||||
std::cout << "\n--- Block 7: build_headers_json ---\n";
|
||||
|
||||
{
|
||||
std::string headers = build_headers_json();
|
||||
CHECK(headers.find("x-api-key") != std::string::npos,
|
||||
"T7.1: contains x-api-key header");
|
||||
CHECK(headers.find(g_cfg.api_key) != std::string::npos,
|
||||
"T7.2: contains correct API key value");
|
||||
CHECK(headers.find("anthropic-version") != std::string::npos,
|
||||
"T7.3: contains anthropic-version header");
|
||||
CHECK(headers.find("2023-06-01") != std::string::npos,
|
||||
"T7.4: anthropic-version is 2023-06-01");
|
||||
}
|
||||
|
||||
{
|
||||
// With empty API key
|
||||
std::string saved = g_cfg.api_key;
|
||||
g_cfg.api_key = "";
|
||||
std::string headers = build_headers_json();
|
||||
CHECK(headers.find("x-api-key") != std::string::npos,
|
||||
"T7.5: x-api-key present even with empty key");
|
||||
CHECK(headers.find("\"x-api-key\":\"\"") != std::string::npos,
|
||||
"T7.6: empty API key serialized as empty string");
|
||||
g_cfg.api_key = saved;
|
||||
}
|
||||
|
||||
// ================================================================
|
||||
// Test Block 8: extract_host_port
|
||||
// ================================================================
|
||||
std::cout << "\n--- Block 8: extract_host_port ---\n";
|
||||
|
||||
{
|
||||
std::string scheme, host, port, target;
|
||||
bool ret = extract_host_port(
|
||||
"https://api.anthropic.com/v1/messages",
|
||||
scheme, host, port, target);
|
||||
CHECK(ret, "T8.1: valid HTTPS URL returns true");
|
||||
CHECK(scheme == "https", "T8.2: scheme is 'https'");
|
||||
CHECK(host == "api.anthropic.com", "T8.3: host extracted correctly");
|
||||
CHECK(port == "443", "T8.4: default HTTPS port 443");
|
||||
CHECK(target == "/v1/messages", "T8.5: target path extracted");
|
||||
}
|
||||
|
||||
{
|
||||
std::string scheme, host, port, target;
|
||||
bool ret = extract_host_port(
|
||||
"http://localhost:8080/chat",
|
||||
scheme, host, port, target);
|
||||
CHECK(ret, "T8.6: HTTP URL with explicit port returns true");
|
||||
CHECK(scheme == "http", "T8.7: scheme is 'http'");
|
||||
CHECK(host == "localhost", "T8.8: host is 'localhost'");
|
||||
CHECK(port == "8080", "T8.9: explicit port 8080");
|
||||
CHECK(target == "/chat", "T8.10: target path extracted");
|
||||
}
|
||||
|
||||
{
|
||||
std::string scheme, host, port, target;
|
||||
bool ret = extract_host_port(
|
||||
"https://example.com",
|
||||
scheme, host, port, target);
|
||||
CHECK(ret, "T8.11: URL without path returns true");
|
||||
CHECK(scheme == "https", "T8.12: scheme is 'https'");
|
||||
CHECK(host == "example.com", "T8.13: host extracted");
|
||||
CHECK(port == "443", "T8.14: default HTTPS port");
|
||||
CHECK(target == "/", "T8.15: target defaults to '/'");
|
||||
}
|
||||
|
||||
{
|
||||
std::string scheme, host, port, target;
|
||||
bool ret = extract_host_port(
|
||||
"http://localhost",
|
||||
scheme, host, port, target);
|
||||
CHECK(ret, "T8.16: HTTP URL returns true");
|
||||
CHECK(port == "80", "T8.17: default HTTP port 80");
|
||||
}
|
||||
|
||||
{
|
||||
std::string scheme, host, port, target;
|
||||
bool ret = extract_host_port(
|
||||
"no-scheme-url.com/path",
|
||||
scheme, host, port, target);
|
||||
CHECK(!ret, "T8.18: URL without scheme returns false");
|
||||
}
|
||||
|
||||
{
|
||||
std::string scheme, host, port, target;
|
||||
bool ret = extract_host_port(
|
||||
"https://127.0.0.1:9090/v1/chat/completions",
|
||||
scheme, host, port, target);
|
||||
CHECK(ret, "T8.19: IP address with port returns true");
|
||||
CHECK(host == "127.0.0.1", "T8.20: IP host extracted");
|
||||
CHECK(port == "9090", "T8.21: port 9090 extracted");
|
||||
}
|
||||
|
||||
// ================================================================
|
||||
// Test Block 9: secure_zero
|
||||
// ================================================================
|
||||
std::cout << "\n--- Block 9: secure_zero ---\n";
|
||||
|
||||
{
|
||||
char buf[16];
|
||||
memset(buf, 0xFF, sizeof(buf));
|
||||
secure_zero(buf, sizeof(buf));
|
||||
bool all_zero = true;
|
||||
for (int i = 0; i < 16; ++i) {
|
||||
if (buf[i] != 0) { all_zero = false; break; }
|
||||
}
|
||||
CHECK(all_zero, "T9.1: secure_zero zeros entire buffer");
|
||||
}
|
||||
|
||||
{
|
||||
// Zero-length should not crash
|
||||
char buf[4] = {1,2,3,4};
|
||||
secure_zero(buf, 0);
|
||||
CHECK(buf[0] == 1 && buf[3] == 4,
|
||||
"T9.2: secure_zero(0) is a no-op (buffer unchanged)");
|
||||
}
|
||||
|
||||
{
|
||||
// Null pointer + zero length = no-op
|
||||
secure_zero(nullptr, 0);
|
||||
CHECK(true, "T9.3: secure_zero(nullptr, 0) does not crash");
|
||||
}
|
||||
|
||||
// ================================================================
|
||||
// Test Block 10: my_free_result — null safety
|
||||
// ================================================================
|
||||
std::cout << "\n--- Block 10: my_free_result null safety ---\n";
|
||||
|
||||
{
|
||||
// g_host is nullptr, so free_result should early-return
|
||||
my_free_result(nullptr);
|
||||
CHECK(true, "T10.1: free_result(nullptr) does not crash (null host)");
|
||||
}
|
||||
|
||||
{
|
||||
dstalk_chat_result_t r = {};
|
||||
r.ok = 1;
|
||||
r.content = nullptr;
|
||||
r.error = nullptr;
|
||||
r.tool_calls_json = nullptr;
|
||||
my_free_result(&r);
|
||||
CHECK(true, "T10.2: free_result with all-null fields does not crash");
|
||||
}
|
||||
|
||||
// ================================================================
|
||||
// Test Block 11: my_configure — null host safety
|
||||
// ================================================================
|
||||
std::cout << "\n--- Block 11: my_configure null host safety ---\n";
|
||||
|
||||
{
|
||||
// g_host is nullptr, configure should still return 0 (log skipped)
|
||||
int ret = my_configure(
|
||||
"anthropic", "https://api.anthropic.com",
|
||||
"sk-key", "claude-sonnet", 2048, 0.5);
|
||||
CHECK(ret == 0, "T11.1: my_configure returns 0 with null host");
|
||||
CHECK(g_cfg.provider == "anthropic", "T11.2: provider stored");
|
||||
CHECK(g_cfg.max_tokens == 2048, "T11.3: max_tokens stored");
|
||||
CHECK(g_cfg.temperature == 0.5, "T11.4: temperature stored");
|
||||
}
|
||||
|
||||
{
|
||||
// Null string params — should not crash
|
||||
int ret = my_configure(nullptr, nullptr, nullptr, nullptr, 4096, 0.7);
|
||||
CHECK(ret == 0, "T11.5: my_configure with all-null strings returns 0");
|
||||
}
|
||||
|
||||
// ================================================================
|
||||
// Summary
|
||||
// ================================================================
|
||||
std::cout << "\n";
|
||||
if (g_failures == 0) {
|
||||
std::cout << "=== All anthropic plugin tests passed ===\n";
|
||||
return 0;
|
||||
} else {
|
||||
std::cerr << "=== " << g_failures << " test(s) FAILED ===\n";
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user