tests/tests_HTMLparser_htmlCtxtSetOptionsInternal.c

#include "unity/unity.h"
#include <libxml/HTMLparser.h>

#include <libxml/parser.h>
#include <libxml/parserInternals.h>
#include <string.h>
#include <stdlib.h>

/* Wrapper for the static function under test (provided in module) */
int test_htmlCtxtSetOptionsInternal(xmlParserCtxtPtr ctxt, int options, int keepMask);

static xmlParserCtxtPtr make_ctxt(void) {
    htmlParserCtxtPtr hctxt = htmlNewParserCtxt();
    TEST_ASSERT_NOT_NULL(hctxt);
    return (xmlParserCtxtPtr)hctxt;
}

void setUp(void) {
    xmlInitParser();
}

void tearDown(void) {
    /* Nothing to clean up per-test beyond freeing contexts within tests */
}

/* Test: NULL context returns -1 */
void test_htmlCtxtSetOptionsInternal_null_context(void) {
    int ret = test_htmlCtxtSetOptionsInternal(NULL, 0, 0);
    TEST_ASSERT_EQUAL_INT(-1, ret);
}

/* Test: Allowed options set, related fields updated (NOBLANKS, RECOVER, NOWARNING) */
void test_htmlCtxtSetOptionsInternal_set_allowed_and_fields(void) {
    xmlParserCtxtPtr ctxt = make_ctxt();

    int options = HTML_PARSE_RECOVER | HTML_PARSE_NOBLANKS | HTML_PARSE_NOWARNING;
    int keepMask = 0;

    int ret = test_htmlCtxtSetOptionsInternal(ctxt, options, keepMask);
    TEST_ASSERT_EQUAL_INT(0, ret);

    /* options should exactly match the provided allowed bits (keepMask = 0) */
    TEST_ASSERT_TRUE((ctxt->options & HTML_PARSE_RECOVER) != 0);
    TEST_ASSERT_TRUE((ctxt->options & HTML_PARSE_NOBLANKS) != 0);
    TEST_ASSERT_TRUE((ctxt->options & HTML_PARSE_NOWARNING) != 0);
    TEST_ASSERT_EQUAL_INT(options, ctxt->options);

    /* keepBlanks should be 0 when NOBLANKS is set */
    TEST_ASSERT_EQUAL_INT(0, ctxt->keepBlanks);

    /* recovery is always enabled */
    TEST_ASSERT_EQUAL_INT(1, ctxt->recovery);

    /* dictNames forced to 0 */
    TEST_ASSERT_EQUAL_INT(0, ctxt->dictNames);

    /* NOBLANKS should set the ignorableWhitespace SAX callback */
    TEST_ASSERT_NOT_NULL(ctxt->sax);
    TEST_ASSERT(ctxt->sax->ignorableWhitespace == xmlSAX2IgnorableWhitespace);

    htmlFreeParserCtxt((htmlParserCtxtPtr)ctxt);
}

/* Test: keepMask preserves bits from existing ctxt->options */
void test_htmlCtxtSetOptionsInternal_keepmask_preserves_previous(void) {
    xmlParserCtxtPtr ctxt = make_ctxt();

    /* Seed the context with known option bits */
    ctxt->options = HTML_PARSE_PEDANTIC | HTML_PARSE_BIG_LINES;

    int options = 0; /* no new options */
    int keepMask = HTML_PARSE_PEDANTIC; /* preserve only PEDANTIC from old options */

    int ret = test_htmlCtxtSetOptionsInternal(ctxt, options, keepMask);
    TEST_ASSERT_EQUAL_INT(0, ret);

    /* Only PEDANTIC should be preserved, no new bits added */
    TEST_ASSERT_EQUAL_INT(HTML_PARSE_PEDANTIC, ctxt->options);

    /* No NOBLANKS in options => keepBlanks should be 1 */
    TEST_ASSERT_EQUAL_INT(1, ctxt->keepBlanks);

    /* recovery always set */
    TEST_ASSERT_EQUAL_INT(1, ctxt->recovery);

    /* dictNames forced to 0 */
    TEST_ASSERT_EQUAL_INT(0, ctxt->dictNames);

    htmlFreeParserCtxt((htmlParserCtxtPtr)ctxt);
}

/* Test: XML_PARSE_NOENT is not reported as leftover and does not set ctxt->options */
void test_htmlCtxtSetOptionsInternal_allows_XML_PARSE_NOENT(void) {
    xmlParserCtxtPtr ctxt = make_ctxt();

    int options = XML_PARSE_NOENT;
    int keepMask = 0;

    int ret = test_htmlCtxtSetOptionsInternal(ctxt, options, keepMask);
    /* NOENT is masked out from the return value */
    TEST_ASSERT_EQUAL_INT(0, ret);

    /* NOENT is not in the allowed mask for HTML, so ctxt->options should not gain bits */
    TEST_ASSERT_EQUAL_INT(0, ctxt->options);

    /* No NOBLANKS => keepBlanks = 1 */
    TEST_ASSERT_EQUAL_INT(1, ctxt->keepBlanks);

    htmlFreeParserCtxt((htmlParserCtxtPtr)ctxt);
}

/* Test: Return unhandled bits (e.g., XML_PARSE_NOCDATA), but mask out XML_PARSE_NOENT */
void test_htmlCtxtSetOptionsInternal_returns_unhandled_bits(void) {
    xmlParserCtxtPtr ctxt = make_ctxt();

    int options = XML_PARSE_NOENT | XML_PARSE_NOCDATA; /* NOCDATA is not in HTML allowed mask */
    int keepMask = 0;

    int ret = test_htmlCtxtSetOptionsInternal(ctxt, options, keepMask);
    /* Should return only NOCDATA; NOENT should be masked out */
    TEST_ASSERT_EQUAL_INT(XML_PARSE_NOCDATA, ret);

    /* Neither NOENT nor NOCDATA are applied to ctxt->options in HTML path */
    TEST_ASSERT_EQUAL_INT(0, ctxt->options);

    /* keepBlanks should default to 1 since NOBLANKS not set */
    TEST_ASSERT_EQUAL_INT(1, ctxt->keepBlanks);

    htmlFreeParserCtxt((htmlParserCtxtPtr)ctxt);
}

/* Test: HTML5 and HUGE flags get applied; basic fields set appropriately */
void test_htmlCtxtSetOptionsInternal_html5_and_huge_bits(void) {
    xmlParserCtxtPtr ctxt = make_ctxt();

    int options = HTML_PARSE_HTML5 | HTML_PARSE_HUGE;
    int keepMask = 0;

    int ret = test_htmlCtxtSetOptionsInternal(ctxt, options, keepMask);
    TEST_ASSERT_EQUAL_INT(0, ret);

    TEST_ASSERT_TRUE((ctxt->options & HTML_PARSE_HTML5) != 0);
    TEST_ASSERT_TRUE((ctxt->options & HTML_PARSE_HUGE) != 0);

    /* No NOBLANKS => keepBlanks = 1 */
    TEST_ASSERT_EQUAL_INT(1, ctxt->keepBlanks);

    /* recovery always set */
    TEST_ASSERT_EQUAL_INT(1, ctxt->recovery);

    /* dictNames forced to 0 */
    TEST_ASSERT_EQUAL_INT(0, ctxt->dictNames);

    htmlFreeParserCtxt((htmlParserCtxtPtr)ctxt);
}

int main(void) {
    UNITY_BEGIN();
    RUN_TEST(test_htmlCtxtSetOptionsInternal_null_context);
    RUN_TEST(test_htmlCtxtSetOptionsInternal_set_allowed_and_fields);
    RUN_TEST(test_htmlCtxtSetOptionsInternal_keepmask_preserves_previous);
    RUN_TEST(test_htmlCtxtSetOptionsInternal_allows_XML_PARSE_NOENT);
    RUN_TEST(test_htmlCtxtSetOptionsInternal_returns_unhandled_bits);
    RUN_TEST(test_htmlCtxtSetOptionsInternal_html5_and_huge_bits);
    return UNITY_END();
}