apex-ruby 1.0.6

data/ext/apex_ext/apex_src/tests/test_plugins.c

@@ -0,0 +1,219 @@
+/**
+ * Plugin System Integration Tests
+ *
+ * Purely test-side coverage improvements:
+ * - Creates temporary plugin manifests/scripts under a temporary XDG_CONFIG_HOME
+ * - Enables plugins via apex_options and exercises pre_parse and post_render phases
+ * - Exercises both declarative regex plugins and external handler plugins
+ * - Exercises APEX_PRE_PARSE_PLUGIN env helper (plugins_env.c)
+ */
+
+#include "test_helpers.h"
+#include "apex/apex.h"
+
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+/* Not in a public header, but we want to cover it. */
+char *apex_run_preparse_plugin_env(const char *text, const apex_options *options);
+
+static int mkdir_p(const char *path) {
+    if (!path || !*path) return -1;
+    char tmp[1024];
+    snprintf(tmp, sizeof(tmp), "%s", path);
+
+    for (char *p = tmp + 1; *p; p++) {
+        if (*p == '/') {
+            *p = '\0';
+            mkdir(tmp, 0700);
+            *p = '/';
+        }
+    }
+    return mkdir(tmp, 0700);
+}
+
+static int write_file(const char *path, const char *content) {
+    FILE *fp = fopen(path, "wb");
+    if (!fp) return -1;
+    size_t n = fwrite(content, 1, strlen(content), fp);
+    fclose(fp);
+    return (n == strlen(content)) ? 0 : -1;
+}
+
+static void env_set_restore(const char *key, const char *value, void (*fn)(void *), void *ctx) {
+    const char *old = getenv(key);
+    char *old_dup = old ? strdup(old) : NULL;
+
+    if (value) setenv(key, value, 1);
+    else unsetenv(key);
+
+    fn(ctx);
+
+    if (old_dup) {
+        setenv(key, old_dup, 1);
+        free(old_dup);
+    } else {
+        unsetenv(key);
+    }
+}
+
+typedef struct {
+    const char *xdg_home;
+} plugin_test_ctx;
+
+static void plugin_test_cb(void *vctx) {
+    plugin_test_ctx *ctx = (plugin_test_ctx *)vctx;
+
+    /* Create:
+     *  $XDG_CONFIG_HOME/apex/plugins/a-regex/plugin.yml
+     *  $XDG_CONFIG_HOME/apex/plugins/b-handler/plugin.yml + handler.py
+     *  $XDG_CONFIG_HOME/apex/plugins/c-post/plugin.yml + handler.py
+     */
+    char plugins_root[1024];
+    snprintf(plugins_root, sizeof(plugins_root), "%s/apex/plugins", ctx->xdg_home);
+    mkdir_p(plugins_root);
+
+    /* a-regex: pre_parse regex replacement, high priority (runs first) */
+    {
+        char dir[1024];
+        snprintf(dir, sizeof(dir), "%s/a-regex", plugins_root);
+        mkdir_p(dir);
+
+        char manifest[1024];
+        snprintf(manifest, sizeof(manifest), "%s/plugin.yml", dir);
+        const char *yml =
+            "---\n"
+            "id: a-regex\n"
+            "phase: pre_parse\n"
+            "priority: 10\n"
+            "pattern: \"FOO\"\n"
+            "replacement: \"BAR\"\n"
+            "---\n";
+        write_file(manifest, yml);
+    }
+
+    /* b-handler: pre_parse external handler, runs after regex */
+    {
+        char dir[1024];
+        snprintf(dir, sizeof(dir), "%s/b-handler", plugins_root);
+        mkdir_p(dir);
+
+        char script[1024];
+        snprintf(script, sizeof(script), "%s/handler.py", dir);
+        const char *py =
+            "import json, os, sys\n"
+            "req = json.loads(sys.stdin.read() or '{}')\n"
+            "text = req.get('text','')\n"
+            "# Confirm env vars are set by embedding them into output.\n"
+            "plugdir = os.environ.get('APEX_PLUGIN_DIR','')\n"
+            "suppdir = os.environ.get('APEX_SUPPORT_DIR','')\n"
+            "text = text.replace('BAR', 'BAZ')\n"
+            "sys.stdout.write(text + '\\n<!--PLUGIN_DIR=' + plugdir + '-->' + '\\n<!--SUPPORT_DIR=' + suppdir + '-->\\n')\n";
+        write_file(script, py);
+
+        char manifest[1024];
+        snprintf(manifest, sizeof(manifest), "%s/plugin.yml", dir);
+        const char *yml =
+            "---\n"
+            "id: b-handler\n"
+            "phase: pre_parse\n"
+            "priority: 20\n"
+            "handler.command: \"/usr/bin/env python3 ${APEX_PLUGIN_DIR}/handler.py\"\n"
+            "timeout_ms: 500\n"
+            "---\n";
+        write_file(manifest, yml);
+    }
+
+    /* c-post: post_render external handler that appends marker with APEX_FILE_PATH */
+    {
+        char dir[1024];
+        snprintf(dir, sizeof(dir), "%s/c-post", plugins_root);
+        mkdir_p(dir);
+
+        char script[1024];
+        snprintf(script, sizeof(script), "%s/handler.py", dir);
+        const char *py =
+            "import json, os, sys\n"
+            "req = json.loads(sys.stdin.read() or '{}')\n"
+            "text = req.get('text','')\n"
+            "fp = os.environ.get('APEX_FILE_PATH','')\n"
+            "sys.stdout.write(text + '\\n<!--POST_RENDER_FILE=' + fp + '-->')\n";
+        write_file(script, py);
+
+        char manifest[1024];
+        snprintf(manifest, sizeof(manifest), "%s/plugin.yml", dir);
+        const char *yml =
+            "---\n"
+            "id: c-post\n"
+            "phase: post_render\n"
+            "priority: 10\n"
+            "handler.command: \"/usr/bin/env python3 ${APEX_PLUGIN_DIR}/handler.py\"\n"
+            "timeout_ms: 500\n"
+            "---\n";
+        write_file(manifest, yml);
+    }
+
+    /* Run a conversion that should exercise:
+     * - plugin discovery (XDG_CONFIG_HOME path)
+     * - regex plugin application (FOO->BAR)
+     * - handler plugin application (BAR->BAZ plus markers)
+     * - post_render handler append marker
+     */
+    apex_options opts = apex_options_for_mode(APEX_MODE_UNIFIED);
+    opts.enable_plugins = true;
+    opts.input_file_path = "/tmp/apex-test-input.md";
+
+    const char *md = "FOO\n";
+    char *html = apex_markdown_to_html(md, strlen(md), &opts);
+
+    assert_contains(html, "BAZ", "plugins: regex + handler transformed text (FOO->BAR->BAZ)");
+    assert_contains(html, "PLUGIN_DIR=", "plugins: handler saw APEX_PLUGIN_DIR");
+    assert_contains(html, "SUPPORT_DIR=", "plugins: handler saw APEX_SUPPORT_DIR");
+    assert_contains(html, "POST_RENDER_FILE=/tmp/apex-test-input.md", "plugins: post_render saw APEX_FILE_PATH");
+
+    apex_free_string(html);
+}
+
+void test_plugins_integration(void) {
+    int suite_failures = suite_start();
+    print_suite_title("Plugin System Integration Tests", false, true);
+
+    /* Exercise plugins_env.c helper using APEX_PRE_PARSE_PLUGIN */
+    {
+        /* A command that reads JSON and prints just the text value. */
+        const char *cmd =
+            "/usr/bin/env python3 -c 'import json,sys; print(json.loads(sys.stdin.read()).get(\"text\",\"\"))'";
+        setenv("APEX_PRE_PARSE_PLUGIN", cmd, 1);
+
+        apex_options opts = apex_options_default();
+        char *out = apex_run_preparse_plugin_env("ENV_PLUGIN_OK", &opts);
+        test_result(out && strstr(out, "ENV_PLUGIN_OK") != NULL, "APEX_PRE_PARSE_PLUGIN env helper runs");
+        if (out) free(out);
+
+        unsetenv("APEX_PRE_PARSE_PLUGIN");
+    }
+
+    /* Create temp XDG_CONFIG_HOME and run full plugin integration. */
+    char tmp_template[] = "/tmp/apex-xdg-plugins-XXXXXX";
+    char *tmp = mkdtemp(tmp_template);
+    if (!tmp) {
+        tests_run++;
+        tests_failed++;
+        printf(COLOR_RED "✗" COLOR_RESET " Failed to create temp directory for plugin tests\n");
+    } else {
+        plugin_test_ctx ctx = { .xdg_home = tmp };
+        env_set_restore("XDG_CONFIG_HOME", tmp, plugin_test_cb, &ctx);
+
+        /* Best-effort cleanup (not fatal on failure). */
+        char rm_cmd[1200];
+        snprintf(rm_cmd, sizeof(rm_cmd), "rm -rf '%s'", tmp);
+        system(rm_cmd);
+    }
+
+    bool had_failures = suite_end(suite_failures);
+    print_suite_title("Plugin System Integration Tests", had_failures, false);
+}
+

data/ext/apex_ext/apex_src/tests/test_refs.bib

@@ -0,0 +1,31 @@
+@article{doe99,
+  author = {Doe, John},
+  title = {Article Title},
+  journal = {Journal Name},
+  year = {1999},
+  volume = {1},
+  pages = {1--10}
+}
+
+@book{smith2000,
+  author = {Smith, Jane},
+  title = {Book Title},
+  publisher = {Publisher},
+  year = {2000}
+}
+
+@article{smith2004,
+  author = {Smith, Jane},
+  title = {Another Article},
+  journal = {Journal},
+  year = {2004},
+  volume = {2},
+  pages = {20--30}
+}
+
+@book{smith04,
+  author = {Smith, John},
+  title = {Some Book},
+  publisher = {Publisher},
+  year = {2004}
+}

data/ext/apex_ext/apex_src/tests/test_runner.c

@@ -0,0 +1,244 @@
+/**
+ * Apex Test Runner
+ * Main test runner that calls all test suites
+ */
+
+#include "test_helpers.h"
+#include "apex/apex.h"
+
+#include <string.h>
+#include <stddef.h>
+#include <signal.h>
+#include <stdlib.h>
+
+/* Track current test name for error reporting */
+static const char *current_test_name = NULL;
+
+/* Signal handler for assertion failures */
+static void sigabrt_handler(int sig) {
+    (void)sig;
+    if (current_test_name) {
+        fprintf(stderr, "\n*** Assertion failure in test: %s ***\n", current_test_name);
+    }
+    fprintf(stderr, "This is likely a cmark block finalization issue.\n");
+    fprintf(stderr, "Set APEX_SKIP_PROBLEMATIC_TESTS=1 to skip tests that trigger this.\n");
+}
+
+/* Forward declarations for individual test suites */
+void test_basic_markdown(void);
+void test_gfm_features(void);
+void test_metadata(void);
+void test_mmd_metadata_keys(void);
+void test_metadata_transforms(void);
+void test_metadata_control_options(void);
+void test_syntax_highlight_options(void);
+void test_syntax_highlight_integration(void);
+void test_wiki_links(void);
+void test_image_embedding(void);
+void test_image_width_height_conversion(void);
+void test_math(void);
+void test_critic_markup(void);
+void test_processor_modes(void);
+void test_multimarkdown_image_attributes(void);
+void test_file_includes(void);
+void test_ial(void);
+void test_bracketed_spans(void);
+void test_definition_lists(void);
+void test_advanced_tables(void);
+void test_relaxed_tables(void);
+void test_comprehensive_table_features(void);
+void test_table_no_trailing_newline(void);
+void test_table_cr_line_endings(void);
+void test_combine_gitbook_like(void);
+void test_callouts(void);
+void test_blockquote_lists(void);
+void test_toc(void);
+void test_html_markdown_attributes(void);
+void test_fenced_divs(void);
+void test_sup_sub(void);
+void test_mixed_lists(void);
+void test_unsafe_mode(void);
+void test_abbreviations(void);
+void test_mmd6_features(void);
+void test_emoji(void);
+void test_special_markers(void);
+void test_inline_tables(void);
+void test_insert_syntax(void);
+void test_advanced_footnotes(void);
+void test_standalone_output(void);
+void test_pretty_html(void);
+void test_header_ids(void);
+void test_image_captions(void);
+void test_indices(void);
+void test_citations(void);
+void test_aria_labels(void);
+void test_marked_integration_features(void);
+void test_plugins_integration(void);
+
+/**
+ * Test suite registry
+ *
+ * Maps human-friendly suite names (command-line arguments) to the
+ * corresponding test functions.
+ */
+typedef void (*test_fn)(void);
+
+typedef struct {
+    const char *name;
+    test_fn fn;
+} test_suite;
+
+static test_suite suites[] = {
+    { "tests_basic",                   test_basic_markdown },
+    { "basic",                         test_basic_markdown },
+    { "gfm",                           test_gfm_features },
+    { "metadata",                      test_metadata },
+    { "metadata_transforms",           test_metadata_transforms },
+    { "mmd_metadata_keys",             test_mmd_metadata_keys },
+    { "metadata_control_options",      test_metadata_control_options },
+    { "syntax_highlight_options",      test_syntax_highlight_options },
+    { "syntax_highlight_integration",  test_syntax_highlight_integration },
+    { "wiki_links",                    test_wiki_links },
+    { "math",                          test_math },
+    { "critic_markup",                 test_critic_markup },
+    { "multimarkdown_image_attributes",test_multimarkdown_image_attributes },
+    { "processor_modes",               test_processor_modes },
+    { "file_includes",                 test_file_includes },
+    { "ial",                           test_ial },
+    { "bracketed_spans",               test_bracketed_spans },
+    { "definition_lists",              test_definition_lists },
+    { "advanced_tables",               test_advanced_tables },
+    { "relaxed_tables",                test_relaxed_tables },
+    { "comprehensive_table_features",  test_comprehensive_table_features },
+    { "table_no_trailing_newline",     test_table_no_trailing_newline },
+    { "table_cr_line_endings",         test_table_cr_line_endings },
+    { "combine_gitbook_like",          test_combine_gitbook_like },
+    { "callouts",                      test_callouts },
+    { "blockquote_lists",              test_blockquote_lists },
+    { "toc",                           test_toc },
+    { "html_markdown_attributes",      test_html_markdown_attributes },
+    { "fenced_divs",                   test_fenced_divs },
+    { "sup_sub",                       test_sup_sub },
+    { "mixed_lists",                   test_mixed_lists },
+    { "unsafe_mode",                   test_unsafe_mode },
+    { "abbreviations",                 test_abbreviations },
+    { "mmd6_features",                 test_mmd6_features },
+    { "emoji",                         test_emoji },
+    { "special_markers",               test_special_markers },
+    { "inline_tables",                 test_inline_tables },
+    { "insert_syntax",                 test_insert_syntax },
+    { "advanced_footnotes",            test_advanced_footnotes },
+    { "standalone_output",             test_standalone_output },
+    { "pretty_html",                   test_pretty_html },
+    { "header_ids",                    test_header_ids },
+    { "image_captions",                test_image_captions },
+    { "image_embedding",               test_image_embedding },
+    { "image_width_height_conversion", test_image_width_height_conversion },
+    { "indices",                       test_indices },
+    { "citations",                     test_citations },
+    { "aria_labels",                   test_aria_labels },
+    { "marked_integration",            test_marked_integration_features },
+    { "marked",                        test_marked_integration_features },
+    { "plugins_integration",           test_plugins_integration },
+};
+
+static const size_t suite_count = sizeof(suites) / sizeof(suites[0]);
+
+/**
+ * Main test runner
+ */
+int main(int argc, char *argv[]) {
+    /* Install signal handler for better error reporting */
+    signal(SIGABRT, sigabrt_handler);
+
+    /* Parse command-line arguments */
+    int errors_only = 0;
+    int badge_flag = 0;
+    const char *requested_suite = NULL;
+
+    for (int i = 1; i < argc; i++) {
+        if (strcmp(argv[i], "--errors-only") == 0 || strcmp(argv[i], "-e") == 0) {
+            errors_only = 1;
+        } else if (strcmp(argv[i], "--badge") == 0 || strcmp(argv[i], "-b") == 0) {
+            badge_flag = 1;
+        } else if (!requested_suite) {
+            requested_suite = argv[i];
+        }
+    }
+
+    /* Set global badge_mode flag in test helpers */
+    if (badge_flag) {
+        badge_mode = 1;
+    }
+
+    /* Skip header in badge mode */
+    if (!badge_flag) {
+        printf("Apex Test Suite v%s\n", apex_version_string());
+        printf("==========================================\n");
+    }
+
+    /* Propagate errors-only mode to test helpers */
+    if (errors_only) {
+        errors_only_output = 1;
+    }
+
+    /* In badge mode, suppress all output except the final count */
+    if (badge_flag) {
+        errors_only_output = 1; /* Suppress test output */
+    }
+
+    if (requested_suite) {
+        // List available test suites
+        if (strcmp(requested_suite, "list") == 0 || strcmp(requested_suite, "--list") == 0) {
+            printf("Available test suites:\n");
+            for (size_t i = 0; i < suite_count; i++) {
+                printf("  %s\n", suites[i].name);
+            }
+            return 0;
+        }
+
+        // Run only the specified test suite
+        for (size_t i = 0; i < suite_count; i++) {
+            if (strcmp(requested_suite, suites[i].name) == 0) {
+                current_test_name = suites[i].name;
+                suites[i].fn();
+                current_test_name = NULL;
+                goto done_single_suite;
+            }
+        }
+
+        if (!badge_mode) {
+            printf("Unknown test suite: %s\n", requested_suite);
+        }
+        return 2;
+    } else {
+        // Run all test suites
+        for (size_t i = 0; i < suite_count; i++) {
+            current_test_name = suites[i].name;
+            suites[i].fn();
+            current_test_name = NULL;
+        }
+    }
+
+done_single_suite:
+
+    /* In badge mode, output only the count */
+    if (badge_flag) {
+        printf("%d/%d\n", tests_passed, tests_run);
+        return (tests_failed == 0) ? 0 : 1;
+    }
+
+    /* Print results */
+    printf("\n==========================================\n");
+    printf("Results: %d total, ", tests_run);
+    printf(COLOR_GREEN "%d passed" COLOR_RESET ", ", tests_passed);
+    printf(COLOR_RED "%d failed" COLOR_RESET "\n", tests_failed);
+
+    if (tests_failed == 0) {
+        printf(COLOR_GREEN "\nAll tests passed! ✓" COLOR_RESET "\n");
+        return 0;
+    } else {
+        printf(COLOR_RED "\nSome tests failed!" COLOR_RESET "\n");
+        return 1;
+    }
+}

data/ext/apex_ext/apex_src/tests/test_syntax_highlight.c

@@ -0,0 +1,198 @@
+/**
+ * Syntax Highlighting Integration Tests
+ *
+ * These tests exercise the actual external highlighters (pygments/skylighting)
+ * via the core pipeline (apex_markdown_to_html), plus a couple of targeted
+ * edge cases (tool missing, language-only mode).
+ */
+
+#include "test_helpers.h"
+#include "apex/apex.h"
+#include "../src/extensions/syntax_highlight.h"
+
+#include <string.h>
+#include <stdlib.h>
+
+static void with_env(const char *key, const char *value, void (*fn)(void *), void *ctx) {
+    const char *old = getenv(key);
+    char *old_dup = old ? strdup(old) : NULL;
+
+    if (value) {
+        setenv(key, value, 1);
+    } else {
+        unsetenv(key);
+    }
+
+    fn(ctx);
+
+    if (old_dup) {
+        setenv(key, old_dup, 1);
+        free(old_dup);
+    } else {
+        unsetenv(key);
+    }
+}
+
+static void test_tool_missing_cb(void *ctx) {
+    (void)ctx;
+    apex_options opts = apex_options_for_mode(APEX_MODE_UNIFIED);
+    opts.code_highlighter = "pygments";
+
+    const char *md =
+        "```python\n"
+        "print(\"hi\")\n"
+        "```\n";
+    char *html = apex_markdown_to_html(md, strlen(md), &opts);
+
+    /* When PATH is empty, tool check should fail and we should fall back to raw <pre><code>. */
+    assert_contains(html, "<pre", "missing tool: keeps <pre>");
+    assert_contains(html, "<code", "missing tool: keeps <code>");
+    assert_not_contains(html, "class=\"highlight\"", "missing tool: no pygments wrapper");
+
+    apex_free_string(html);
+}
+
+static void test_tool_missing_with_suppression(void *ctx) {
+    /* Set suppression variable, then clear PATH and run the test */
+    with_env("PATH", "", test_tool_missing_cb, ctx);
+}
+
+static int contains_in_order(const char *haystack, const char *a, const char *b) {
+    const char *pa = strstr(haystack, a);
+    const char *pb = strstr(haystack, b);
+    return (pa && pb && pa < pb) ? 1 : 0;
+}
+
+void test_syntax_highlight_integration(void) {
+    int suite_failures = suite_start();
+    print_suite_title("Syntax Highlighting Integration Tests", false, true);
+
+    /* Exercise tool-missing branch by clearing PATH during conversion. */
+    /* Suppress the warning for this intentional test case */
+    with_env("APEX_SUPPRESS_HIGHLIGHT_WARNINGS", "1", test_tool_missing_with_suppression, NULL);
+
+    /* Pygments: basic highlight with language */
+    {
+        apex_options opts = apex_options_for_mode(APEX_MODE_UNIFIED);
+        opts.code_highlighter = "pygments";
+
+        const char *md =
+            "```python\n"
+            "print(\"hi\")\n"
+            "```\n";
+        char *html = apex_markdown_to_html(md, strlen(md), &opts);
+        assert_contains(html, "class=\"highlight\"", "pygments: emits highlight wrapper");
+        assert_contains(html, "print", "pygments: preserves code content");
+        apex_free_string(html);
+    }
+
+    /* Pygments: line numbers */
+    {
+        apex_options opts = apex_options_for_mode(APEX_MODE_UNIFIED);
+        opts.code_highlighter = "pygments";
+        opts.code_line_numbers = true;
+
+        const char *md =
+            "```python\n"
+            "print(\"hi\")\n"
+            "```\n";
+        char *html = apex_markdown_to_html(md, strlen(md), &opts);
+        assert_contains(html, "class=\"linenos\"", "pygments: line numbers include linenos");
+        apex_free_string(html);
+    }
+
+    /* Pygments: language-only mode should skip unlanguaged blocks */
+    {
+        apex_options opts = apex_options_for_mode(APEX_MODE_UNIFIED);
+        opts.code_highlighter = "pygments";
+        opts.highlight_language_only = true;
+
+        const char *md =
+            "```\n"
+            "print(\"no lang\")\n"
+            "```\n";
+        char *html = apex_markdown_to_html(md, strlen(md), &opts);
+        assert_contains(html, "<pre", "language-only: still has code block");
+        assert_not_contains(html, "class=\"highlight\"", "language-only: unlanguaged block not highlighted");
+        apex_free_string(html);
+    }
+
+    /* Pygments: ensure unescape_html path is exercised (entities in code) */
+    {
+        apex_options opts = apex_options_for_mode(APEX_MODE_UNIFIED);
+        opts.code_highlighter = "pygments";
+
+        const char *md =
+            "```python\n"
+            "print(\"<tag>&\")\n"
+            "```\n";
+        char *html = apex_markdown_to_html(md, strlen(md), &opts);
+        assert_contains(html, "class=\"highlight\"", "pygments: highlighted wrapper present (entities case)");
+        assert_contains(html, "&lt;tag&gt;", "pygments: highlighted output contains escaped <tag>");
+        assert_contains(html, "&amp;", "pygments: highlighted output contains escaped &");
+        apex_free_string(html);
+    }
+
+    /* Skylighting: basic highlight */
+    {
+        apex_options opts = apex_options_for_mode(APEX_MODE_UNIFIED);
+        opts.code_highlighter = "skylighting";
+
+        const char *md =
+            "```python\n"
+            "print(\"hi\")\n"
+            "```\n";
+        char *html = apex_markdown_to_html(md, strlen(md), &opts);
+        assert_contains(html, "class=\"sourceCode\"", "skylighting: emits sourceCode wrapper");
+        assert_contains(html, "print", "skylighting: preserves code content");
+        apex_free_string(html);
+    }
+
+    /* Skylighting: line numbers */
+    {
+        apex_options opts = apex_options_for_mode(APEX_MODE_UNIFIED);
+        opts.code_highlighter = "skylighting";
+        opts.code_line_numbers = true;
+
+        const char *md =
+            "```python\n"
+            "print(\"hi\")\n"
+            "```\n";
+        char *html = apex_markdown_to_html(md, strlen(md), &opts);
+        assert_contains(html, "numberSource", "skylighting: line numbers add numberSource class");
+        apex_free_string(html);
+    }
+
+    /* Skylighting: language-only mode skips unlanguaged blocks (and still highlights languaged ones) */
+    {
+        apex_options opts = apex_options_for_mode(APEX_MODE_UNIFIED);
+        opts.code_highlighter = "skylighting";
+        opts.highlight_language_only = true;
+
+        const char *md =
+            "```python\n"
+            "print(\"yes\")\n"
+            "```\n"
+            "\n"
+            "```\n"
+            "print(\"no\")\n"
+            "```\n";
+        char *html = apex_markdown_to_html(md, strlen(md), &opts);
+        test_result(contains_in_order(html, "class=\"sourceCode\"", "<pre") == 1,
+                    "skylighting: first block highlighted, later raw <pre> remains");
+        apex_free_string(html);
+    }
+
+    /* Direct function call: cover code-tag class=\"language-...\" extraction path */
+    {
+        const char *html_in =
+            "<pre><code class=\"language-python\">print(&quot;hi&quot;)\n</code></pre>";
+        char *out = apex_apply_syntax_highlighting(html_in, "pygments", false, false);
+        assert_contains(out, "class=\"highlight\"", "direct: class=language-... triggers highlighting");
+        free(out);
+    }
+
+    bool had_failures = suite_end(suite_failures);
+    print_suite_title("Syntax Highlighting Integration Tests", had_failures, false);
+}
+