static void
node_check(test_batch_runner *runner) {
// Construct an incomplete tree.
cmark_node *doc = cmark_node_new(CMARK_NODE_DOCUMENT);
cmark_node *p1 = cmark_node_new(CMARK_NODE_PARAGRAPH);
cmark_node *p2 = cmark_node_new(CMARK_NODE_PARAGRAPH);
doc->first_child = p1;
p1->next = p2;
INT_EQ(runner, cmark_node_check(doc, NULL), 4, "node_check works");
INT_EQ(runner, cmark_node_check(doc, NULL), 0,
"node_check fixes tree");
cmark_node_free(doc);
}
static void
version(test_batch_runner *runner)
{
INT_EQ(runner, cmark_version, CMARK_VERSION, "cmark_version");
STR_EQ(runner, cmark_version_string, CMARK_VERSION_STRING,
"cmark_version_string");
}
static void
S_run_prereq_tests(CFCTest *test) {
{
CFCVersion *v77_66_55 = CFCVersion_new("v77.66.55");
CFCPrereq *prereq = CFCPrereq_new("Flour", v77_66_55);
const char *name = CFCPrereq_get_name(prereq);
STR_EQ(test, name, "Flour", "prereq get_name");
CFCVersion *version = CFCPrereq_get_version(prereq);
INT_EQ(test, CFCVersion_compare_to(version, v77_66_55), 0,
"prereq get_version");
CFCBase_decref((CFCBase*)prereq);
CFCBase_decref((CFCBase*)v77_66_55);
}
{
CFCVersion *v0 = CFCVersion_new("v0");
CFCPrereq *prereq = CFCPrereq_new("Sugar", NULL);
CFCVersion *version = CFCPrereq_get_version(prereq);
INT_EQ(test, CFCVersion_compare_to(version, v0), 0,
"prereq with default version");
CFCBase_decref((CFCBase*)prereq);
CFCBase_decref((CFCBase*)v0);
}
}
static void
iterator(test_batch_runner *runner) {
cmark_node *doc = cmark_parse_document("> a *b*\n\nc", 10, CMARK_OPT_DEFAULT);
int parnodes = 0;
cmark_event_type ev_type;
cmark_iter *iter = cmark_iter_new(doc);
cmark_node *cur;
while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) {
cur = cmark_iter_get_node(iter);
if (cur->type == CMARK_NODE_PARAGRAPH &&
ev_type == CMARK_EVENT_ENTER) {
parnodes += 1;
}
}
INT_EQ(runner, parnodes, 2, "iterate correctly counts paragraphs");
cmark_iter_free(iter);
cmark_node_free(doc);
}
static void
test_content(test_batch_runner *runner, cmark_node_type type,
int allowed_content)
{
cmark_node *node = cmark_node_new(type);
for (int i = 0; i < num_node_types; ++i) {
cmark_node_type child_type = node_types[i];
cmark_node *child = cmark_node_new(child_type);
int got = cmark_node_append_child(node, child);
int expected = (allowed_content >> child_type) & 1;
INT_EQ(runner, got, expected,
"add %d as child of %d", child_type, type);
cmark_node_free(child);
}
cmark_node_free(node);
}
static void
constructor(test_batch_runner *runner)
{
for (int i = 0; i < num_node_types; ++i) {
cmark_node_type type = node_types[i];
cmark_node *node = cmark_node_new(type);
OK(runner, node != NULL, "new type %d", type);
INT_EQ(runner, cmark_node_get_type(node), type,
"get_type %d", type);
switch (node->type) {
case CMARK_NODE_HEADER:
INT_EQ(runner, cmark_node_get_header_level(node), 1,
"default header level is 1");
node->as.header.level = 1;
break;
case CMARK_NODE_LIST:
INT_EQ(runner, cmark_node_get_list_type(node),
CMARK_BULLET_LIST,
"default is list type is bullet");
INT_EQ(runner, cmark_node_get_list_delim(node),
CMARK_NO_DELIM,
"default is list delim is NO_DELIM");
INT_EQ(runner, cmark_node_get_list_start(node), 1,
"default is list start is 1");
INT_EQ(runner, cmark_node_get_list_tight(node), 0,
"default is list is loose");
break;
default:
break;
}
cmark_node_free(node);
}
}
static void
S_run_composite_tests(CFCTest *test) {
CFCParser *parser = CFCParser_new();
CFCParcel *neato_parcel = CFCParcel_new("Neato", NULL, NULL, NULL);
CFCParser_set_parcel(parser, neato_parcel);
{
static const char *type_strings[14] = {
"char*",
"char**",
"char***",
"int32_t*",
"Obj**",
"int8_t[]",
"int8_t[1]",
"neato_method_t[]",
"neato_method_t[1]",
"multi_dimensional_t[1][10]",
"char * * ",
"const Obj**",
"const void*",
"int8_t[ 3 ]"
};
for (int i = 0; i < 14; ++i) {
const char *type_string = type_strings[i];
CFCType *type = CFCTest_parse_type(test, parser, type_string);
OK(test, CFCType_is_composite(type), "composite type %s",
type_string);
CFCBase_decref((CFCBase*)type);
}
}
{
CFCType *foo = CFCType_new_object(0, neato_parcel, "Foo", 1);
CFCType *const_foo
= CFCType_new_object(CFCTYPE_CONST, neato_parcel, "Foo", 1);
CFCType *composite = CFCType_new_composite(0, foo, 1, NULL);
OK(test, CFCType_is_composite(composite), "is_composite");
STR_EQ(test, CFCType_get_specifier(composite), "Foo",
"get_specifier delegates to child" );
CFCType *twin = CFCType_new_composite(0, foo, 1, NULL);
OK(test, CFCType_equals(composite, twin), "equals");
CFCBase_decref((CFCBase*)twin);
CFCType *const_composite
= CFCType_new_composite(0, const_foo, 1, NULL);
OK(test, !CFCType_equals(composite, const_composite),
"equals spoiled by different child");
CFCBase_decref((CFCBase*)const_composite);
CFCBase_decref((CFCBase*)composite);
CFCBase_decref((CFCBase*)foo);
CFCBase_decref((CFCBase*)const_foo);
}
{
CFCType *foo_array = CFCTest_parse_type(test, parser, "foo_t[]");
CFCType_resolve(foo_array);
STR_EQ(test, CFCType_get_array(foo_array), "[]", "get_array");
STR_EQ(test, CFCType_to_c(foo_array), "foo_t",
"array subscripts not included by to_c");
CFCType *foo_array_array
= CFCTest_parse_type(test, parser, "foo_t[][]");
OK(test, !CFCType_equals(foo_array, foo_array_array),
"equals spoiled by different array postfixes");
CFCBase_decref((CFCBase*)foo_array);
CFCBase_decref((CFCBase*)foo_array_array);
}
{
CFCType *foo_star = CFCTest_parse_type(test, parser, "foo_t*");
CFCType *foo_star_star = CFCTest_parse_type(test, parser, "foo_t**");
OK(test, !CFCType_equals(foo_star, foo_star_star),
"equals spoiled by different levels of indirection");
INT_EQ(test, CFCType_get_indirection(foo_star), 1,
"foo_t* indirection");
INT_EQ(test, CFCType_get_indirection(foo_star_star), 2,
"foo_t** indirection");
CFCBase_decref((CFCBase*)foo_star);
CFCBase_decref((CFCBase*)foo_star_star);
}
CFCBase_decref((CFCBase*)neato_parcel);
CFCBase_decref((CFCBase*)parser);
}
static void
S_run_object_tests(CFCTest *test) {
static const char *modifiers[4] = {
"const", "incremented", "decremented", "nullable"
};
static int flags[4] = {
CFCTYPE_CONST,
CFCTYPE_INCREMENTED,
CFCTYPE_DECREMENTED,
CFCTYPE_NULLABLE
};
static int (*accessors[4])(CFCType *type) = {
CFCType_const,
CFCType_incremented,
CFCType_decremented,
CFCType_nullable
};
{
CFCParser *parser = CFCParser_new();
CFCParcel *neato_parcel
= CFCTest_parse_parcel(test, parser, "parcel Neato;");
static const char *specifiers[4] = {
"Foo", "FooJr", "FooIII", "Foo4th"
};
for (int i = 0; i < 4; ++i) {
const char *specifier = specifiers[i];
char *class_code = CFCUtil_sprintf("class %s {}", specifier);
CFCClass *klass = CFCTest_parse_class(test, parser, class_code);
FREEMEM(class_code);
static const char *prefixes[2] = { "", "neato_" };
char *expect = CFCUtil_sprintf("neato_%s", specifier);
for (int j = 0; j < 2; ++j) {
char *src = CFCUtil_sprintf("%s%s*", prefixes[j], specifier);
CFCType *type = CFCTest_parse_type(test, parser, src);
CFCType_resolve(type);
STR_EQ(test, CFCType_get_specifier(type), expect,
"object_type_specifier: %s", src);
OK(test, CFCType_is_object(type), "%s is_object", src);
INT_EQ(test, CFCType_get_indirection(type), 1,
"%s indirection", src);
FREEMEM(src);
CFCBase_decref((CFCBase*)type);
}
FREEMEM(expect);
for (int j = 0; j < 4; ++j) {
char *src = CFCUtil_sprintf("%s %s*", modifiers[j], specifier);
CFCType *type = CFCTest_parse_type(test, parser, src);
OK(test, CFCType_is_object(type), "%s is_object", src);
OK(test, accessors[j](type), "%s accessor", src);
FREEMEM(src);
CFCBase_decref((CFCBase*)type);
}
CFCBase_decref((CFCBase*)klass);
CFCClass_clear_registry();
}
CFCBase_decref((CFCBase*)neato_parcel);
CFCBase_decref((CFCBase*)parser);
}
CFCParcel *neato_parcel = CFCParcel_new("Neato", NULL, NULL, NULL);
CFCClass *foo_class
= CFCClass_create(neato_parcel, NULL, "Foo", NULL, NULL, NULL, NULL,
NULL, false, false, false);
CFCType *foo = CFCType_new_object(0, neato_parcel, "Foo", 1);
CFCType_resolve(foo);
{
CFCType *another_foo = CFCType_new_object(0, neato_parcel, "Foo", 1);
CFCType_resolve(another_foo);
OK(test, CFCType_equals(foo, another_foo), "equals");
CFCBase_decref((CFCBase*)another_foo);
}
{
CFCClass *bar_class
= CFCClass_create(neato_parcel, NULL, "Bar", NULL, NULL, NULL,
NULL, NULL, false, false, false);
CFCType *bar = CFCType_new_object(0, neato_parcel, "Bar", 1);
CFCType_resolve(bar);
OK(test, !CFCType_equals(foo, bar),
"different specifier spoils equals");
CFCBase_decref((CFCBase*)bar);
CFCBase_decref((CFCBase*)bar_class);
}
{
CFCParcel *foreign_parcel
= CFCParcel_new("Foreign", NULL, NULL, NULL);
CFCClass *foreign_foo_class
= CFCClass_create(foreign_parcel, NULL, "Foreign::Foo", NULL, NULL,
NULL, NULL, NULL, false, false, false);
CFCType *foreign_foo = CFCType_new_object(0, foreign_parcel, "Foo", 1);
CFCType_resolve(foreign_foo);
OK(test, !CFCType_equals(foo, foreign_foo),
"different parcel spoils equals");
STR_EQ(test, CFCType_get_specifier(foreign_foo), "foreign_Foo",
"prepend parcel prefix to specifier");
CFCBase_decref((CFCBase*)foreign_parcel);
CFCBase_decref((CFCBase*)foreign_foo_class);
CFCBase_decref((CFCBase*)foreign_foo);
}
{
for (int i = 0; i < 4; ++i) {
CFCType *modified_foo
= CFCType_new_object(flags[i], neato_parcel, "Foo", 1);
CFCType_resolve(modified_foo);
OK(test, accessors[i](modified_foo), "%s", modifiers[i]);
OK(test, !accessors[i](foo), "not %s", modifiers[i]);
OK(test, !CFCType_equals(foo, modified_foo),
"different %s spoils equals", modifiers[i]);
OK(test, !CFCType_similar(foo, modified_foo),
"different %s spoils similar", modifiers[i]);
CFCBase_decref((CFCBase*)modified_foo);
}
}
{
CFCType *string_type
= CFCType_new_object(0, neato_parcel, "String", 1);
OK(test, CFCType_is_string_type(string_type), "%s", "is_string_type");
OK(test, !CFCType_is_string_type(foo), "not %s", "not is_string_type");
CFCBase_decref((CFCBase*)string_type);
}
CFCBase_decref((CFCBase*)neato_parcel);
CFCBase_decref((CFCBase*)foo_class);
CFCBase_decref((CFCBase*)foo);
CFCClass_clear_registry();
CFCParcel_reap_singletons();
}
static void
S_run_include_tests(CFCTest *test) {
{
CFCHierarchy *hierarchy = CFCHierarchy_new(T_CFDEST);
CFCHierarchy_add_source_dir(hierarchy, T_CFEXT);
CFCHierarchy_add_include_dir(hierarchy, T_CFBASE);
const char **include_dirs = CFCHierarchy_get_include_dirs(hierarchy);
STR_EQ(test, include_dirs[0], T_CFBASE, "include_dirs[0]");
OK(test, include_dirs[1] == NULL, "include_dirs[1]");
CFCHierarchy_build(hierarchy);
CFCClass **classes = CFCHierarchy_ordered_classes(hierarchy);
CFCClass *rottweiler = NULL;;
int num_classes;
int num_source_classes = 0;
for (num_classes = 0; classes[num_classes]; ++num_classes) {
CFCClass *klass = classes[num_classes];
int expect_included = 1;
const char *class_name = CFCClass_get_name(klass);
if (strcmp(class_name, "Animal::Rottweiler") == 0) {
rottweiler = klass;
expect_included = 0;
++num_source_classes;
}
INT_EQ(test, CFCClass_included(klass), expect_included,
"included");
}
INT_EQ(test, num_classes, 5, "class count");
INT_EQ(test, num_source_classes, 1, "source class count");
STR_EQ(test, CFCClass_get_name(CFCClass_get_parent(rottweiler)),
"Animal::Dog", "parent of included class");
FREEMEM(classes);
CFCBase_decref((CFCBase*)hierarchy);
CFCClass_clear_registry();
CFCParcel_reap_singletons();
}
{
CFCHierarchy *hierarchy = CFCHierarchy_new(T_CFDEST);
CFCHierarchy_add_source_dir(hierarchy, T_CFBASE);
CFCHierarchy_add_source_dir(hierarchy, T_CFEXT);
CFCHierarchy_build(hierarchy);
CFCClass **classes = CFCHierarchy_ordered_classes(hierarchy);
CFCClass *rottweiler = NULL;;
int num_classes;
for (num_classes = 0; classes[num_classes]; ++num_classes) {
CFCClass *klass = classes[num_classes];
const char *class_name = CFCClass_get_name(klass);
if (strcmp(class_name, "Animal::Rottweiler") == 0) {
rottweiler = klass;
}
OK(test, !CFCClass_included(klass), "not included");
}
INT_EQ(test, num_classes, 5, "class count");
OK(test, rottweiler != NULL, "found rottweiler");
STR_EQ(test, CFCClass_get_name(CFCClass_get_parent(rottweiler)),
"Animal::Dog", "parent of class from second source");
FREEMEM(classes);
CFCBase_decref((CFCBase*)hierarchy);
CFCClass_clear_registry();
CFCParcel_reap_singletons();
}
{
CFCHierarchy *hierarchy = CFCHierarchy_new(T_CFDEST);
CFCHierarchy_add_include_dir(hierarchy, T_CFBASE);
CFCHierarchy_add_include_dir(hierarchy, T_CFEXT);
CFCHierarchy_add_prereq(hierarchy, "AnimalExtension");
CFCHierarchy_build(hierarchy);
CFCParcel *animal = CFCParcel_fetch("Animal");
OK(test, animal != NULL, "parcel Animal registered");
OK(test, CFCParcel_required(animal), "parcel Animal required");
CFCParcel *animal_ext = CFCParcel_fetch("AnimalExtension");
OK(test, animal_ext != NULL, "parcel AnimalExtension registered");
OK(test, CFCParcel_required(animal_ext),
"parcel AnimalExtension required");
CFCClass **classes = CFCHierarchy_ordered_classes(hierarchy);
int num_classes = 0;
while (classes[num_classes]) {
++num_classes;
}
INT_EQ(test, num_classes, 5, "class count");
FREEMEM(classes);
CFCBase_decref((CFCBase*)hierarchy);
CFCClass_clear_registry();
CFCParcel_reap_singletons();
}
rmdir(T_CFDEST_INCLUDE);
rmdir(T_CFDEST_SOURCE);
rmdir(T_CFDEST);
}
static void
S_run_parcel_tests(CFCTest *test) {
{
CFCParcel *parcel = CFCParcel_new("Foo", NULL, NULL, NULL);
OK(test, parcel != NULL, "new");
OK(test, !CFCParcel_included(parcel), "not included");
CFCBase_decref((CFCBase*)parcel);
}
{
CFCFileSpec *file_spec = CFCFileSpec_new(".", "Parcel", true);
CFCParcel *parcel = CFCParcel_new("Foo", NULL, NULL, file_spec);
OK(test, CFCParcel_included(parcel), "included");
CFCBase_decref((CFCBase*)parcel);
CFCBase_decref((CFCBase*)file_spec);
}
{
const char *json =
" {\n"
" \"name\": \"Crustacean\",\n"
" \"nickname\": \"Crust\",\n"
" \"version\": \"v0.1.0\"\n"
" }\n";
CFCParcel *parcel = CFCParcel_new_from_json(json, NULL);
OK(test, parcel != NULL, "new_from_json");
CFCBase_decref((CFCBase*)parcel);
}
{
const char *path = "t" CHY_DIR_SEP "cfbase" CHY_DIR_SEP "Animal.cfp";
CFCParcel *parcel = CFCParcel_new_from_file(path, NULL);
OK(test, parcel != NULL, "new_from_file");
CFCBase_decref((CFCBase*)parcel);
}
{
CFCParcel *parcel = CFCParcel_new("Crustacean", "Crust", NULL, NULL);
CFCParcel_register(parcel);
STR_EQ(test, CFCVersion_get_vstring(CFCParcel_get_version(parcel)),
"v0", "get_version");
CFCBase_decref((CFCBase*)parcel);
CFCParcel_reap_singletons();
}
{
const char *json =
" {\n"
" \"name\": \"Crustacean\",\n"
" \"version\": \"v0.1.0\",\n"
" \"prerequisites\": {\n"
" \"Clownfish\": null,\n"
" \"Arthropod\": \"v30.104.5\"\n"
" }\n"
" }\n";
CFCParcel *parcel = CFCParcel_new_from_json(json, NULL);
CFCPrereq **prereqs = CFCParcel_get_prereqs(parcel);
OK(test, prereqs != NULL, "prereqs");
CFCPrereq *cfish = prereqs[0];
OK(test, cfish != NULL, "prereqs[0]");
const char *cfish_name = CFCPrereq_get_name(cfish);
STR_EQ(test, cfish_name, "Clownfish", "prereqs[0] name");
CFCVersion *v0 = CFCVersion_new("v0");
CFCVersion *cfish_version = CFCPrereq_get_version(cfish);
INT_EQ(test, CFCVersion_compare_to(cfish_version, v0), 0,
"prereqs[0] version");
CFCPrereq *apod = prereqs[1];
OK(test, apod != NULL, "prereqs[1]");
const char *apod_name = CFCPrereq_get_name(apod);
STR_EQ(test, apod_name, "Arthropod", "prereqs[1] name");
CFCVersion *v30_104_5 = CFCVersion_new("v30.104.5");
CFCVersion *apod_version = CFCPrereq_get_version(apod);
INT_EQ(test, CFCVersion_compare_to(apod_version, v30_104_5), 0,
"prereqs[1] version");
OK(test, prereqs[2] == NULL, "prereqs[2]");
CFCBase_decref((CFCBase*)v30_104_5);
CFCBase_decref((CFCBase*)v0);
CFCBase_decref((CFCBase*)parcel);
}
{
CFCFileSpec *foo_file_spec = CFCFileSpec_new(".", "Foo", true);
CFCParcel *foo = CFCParcel_new("Foo", NULL, NULL, foo_file_spec);
CFCParcel_register(foo);
CFCVersion *cfish_version = CFCVersion_new("v0.8.7");
CFCFileSpec *cfish_file_spec
= CFCFileSpec_new(".", "Clownfish", true);
CFCParcel *cfish
= CFCParcel_new("Clownfish", NULL, cfish_version, cfish_file_spec);
CFCParcel_register(cfish);
const char *crust_json =
" {\n"
" \"name\": \"Crustacean\",\n"
" \"version\": \"v0.1.0\",\n"
" \"prerequisites\": {\n"
" \"Clownfish\": \"v0.8.5\",\n"
" }\n"
" }\n";
CFCParcel *crust = CFCParcel_new_from_json(crust_json, NULL);
CFCParcel_register(crust);
CFCParcel_check_prereqs(crust);
INT_EQ(test, CFCParcel_required(foo), false, "parcel not required");
INT_EQ(test, CFCParcel_required(cfish), true, "prereq required");
INT_EQ(test, CFCParcel_required(crust), true, "self required");
CFCParcel **prereq_parcels = CFCParcel_prereq_parcels(crust);
OK(test, prereq_parcels[0] != NULL, "prereq_parcels[0]");
const char *name = CFCParcel_get_name(prereq_parcels[0]);
STR_EQ(test, name, "Clownfish", "prereq_parcels[0] name");
OK(test, prereq_parcels[1] == NULL, "prereq_parcels[0]");
OK(test, CFCParcel_has_prereq(crust, cfish), "has_prereq");
OK(test, CFCParcel_has_prereq(crust, crust), "has_prereq self");
OK(test, !CFCParcel_has_prereq(crust, foo), "has_prereq false");
CFCParcel_add_struct_sym(cfish, "Swim");
CFCParcel_add_struct_sym(crust, "Pinch");
CFCParcel_add_struct_sym(foo, "Bar");
CFCParcel *found;
found = CFCParcel_lookup_struct_sym(crust, "Swim");
OK(test, found == cfish, "lookup_struct_sym prereq");
found = CFCParcel_lookup_struct_sym(crust, "Pinch");
OK(test, found == crust, "lookup_struct_sym self");
found = CFCParcel_lookup_struct_sym(crust, "Bar");
OK(test, found == NULL, "lookup_struct_sym other");
FREEMEM(prereq_parcels);
CFCBase_decref((CFCBase*)crust);
CFCBase_decref((CFCBase*)cfish_version);
CFCBase_decref((CFCBase*)cfish_file_spec);
CFCBase_decref((CFCBase*)cfish);
CFCBase_decref((CFCBase*)foo_file_spec);
CFCBase_decref((CFCBase*)foo);
CFCParcel_reap_singletons();
}
}
static void
create_tree(test_batch_runner *runner)
{
char *html;
cmark_node *doc = cmark_node_new(CMARK_NODE_DOCUMENT);
cmark_node *p = cmark_node_new(CMARK_NODE_PARAGRAPH);
OK(runner, !cmark_node_insert_before(doc, p),
"insert before root fails");
OK(runner, !cmark_node_insert_after(doc, p),
"insert after root fails");
OK(runner, cmark_node_append_child(doc, p), "append1");
INT_EQ(runner, cmark_node_check(doc, NULL), 0, "append1 consistent");
OK(runner, cmark_node_parent(p) == doc, "node_parent");
cmark_node *emph = cmark_node_new(CMARK_NODE_EMPH);
OK(runner, cmark_node_prepend_child(p, emph), "prepend1");
INT_EQ(runner, cmark_node_check(doc, NULL), 0, "prepend1 consistent");
cmark_node *str1 = cmark_node_new(CMARK_NODE_TEXT);
cmark_node_set_literal(str1, "Hello, ");
OK(runner, cmark_node_prepend_child(p, str1), "prepend2");
INT_EQ(runner, cmark_node_check(doc, NULL), 0, "prepend2 consistent");
cmark_node *str3 = cmark_node_new(CMARK_NODE_TEXT);
cmark_node_set_literal(str3, "!");
OK(runner, cmark_node_append_child(p, str3), "append2");
INT_EQ(runner, cmark_node_check(doc, NULL), 0, "append2 consistent");
cmark_node *str2 = cmark_node_new(CMARK_NODE_TEXT);
cmark_node_set_literal(str2, "world");
OK(runner, cmark_node_append_child(emph, str2), "append3");
INT_EQ(runner, cmark_node_check(doc, NULL), 0, "append3 consistent");
html = cmark_render_html(doc, CMARK_OPT_DEFAULT);
STR_EQ(runner, html, "<p>Hello, <em>world</em>!</p>\n",
"render_html");
free(html);
OK(runner, cmark_node_insert_before(str1, str3), "ins before1");
INT_EQ(runner, cmark_node_check(doc, NULL), 0,
"ins before1 consistent");
// 31e
OK(runner, cmark_node_first_child(p) == str3, "ins before1 works");
OK(runner, cmark_node_insert_before(str1, emph), "ins before2");
INT_EQ(runner, cmark_node_check(doc, NULL), 0,
"ins before2 consistent");
// 3e1
OK(runner, cmark_node_last_child(p) == str1, "ins before2 works");
OK(runner, cmark_node_insert_after(str1, str3), "ins after1");
INT_EQ(runner, cmark_node_check(doc, NULL), 0,
"ins after1 consistent");
// e13
OK(runner, cmark_node_next(str1) == str3, "ins after1 works");
OK(runner, cmark_node_insert_after(str1, emph), "ins after2");
INT_EQ(runner, cmark_node_check(doc, NULL), 0,
"ins after2 consistent");
// 1e3
OK(runner, cmark_node_previous(emph) == str1, "ins after2 works");
cmark_node_unlink(emph);
html = cmark_render_html(doc, CMARK_OPT_DEFAULT);
STR_EQ(runner, html, "<p>Hello, !</p>\n",
"render_html after shuffling");
free(html);
cmark_node_free(doc);
// TODO: Test that the contents of an unlinked inline are valid
// after the parent block was destroyed. This doesn't work so far.
cmark_node_free(emph);
}
static void
accessors(test_batch_runner *runner)
{
static const char markdown[] =
"## Header\n"
"\n"
"* Item 1\n"
"* Item 2\n"
"\n"
"2. Item 1\n"
"\n"
"3. Item 2\n"
"\n"
"\n"
" code\n"
"\n"
"``` lang\n"
"fenced\n"
"```\n"
"\n"
"<div>html</div>\n"
"\n"
"[link](url 'title')\n";
cmark_node *doc = cmark_parse_document(markdown, sizeof(markdown) - 1, CMARK_OPT_DEFAULT);
// Getters
cmark_node *header = cmark_node_first_child(doc);
INT_EQ(runner, cmark_node_get_header_level(header), 2,
"get_header_level");
cmark_node *bullet_list = cmark_node_next(header);
INT_EQ(runner, cmark_node_get_list_type(bullet_list),
CMARK_BULLET_LIST, "get_list_type bullet");
INT_EQ(runner, cmark_node_get_list_tight(bullet_list), 1,
"get_list_tight tight");
cmark_node *ordered_list = cmark_node_next(bullet_list);
INT_EQ(runner, cmark_node_get_list_type(ordered_list),
CMARK_ORDERED_LIST, "get_list_type ordered");
INT_EQ(runner, cmark_node_get_list_delim(ordered_list),
CMARK_PERIOD_DELIM, "get_list_delim ordered");
INT_EQ(runner, cmark_node_get_list_start(ordered_list), 2,
"get_list_start");
INT_EQ(runner, cmark_node_get_list_tight(ordered_list), 0,
"get_list_tight loose");
cmark_node *code = cmark_node_next(ordered_list);
STR_EQ(runner, cmark_node_get_literal(code), "code\n",
"get_literal indented code");
cmark_node *fenced = cmark_node_next(code);
STR_EQ(runner, cmark_node_get_literal(fenced), "fenced\n",
"get_literal fenced code");
STR_EQ(runner, cmark_node_get_fence_info(fenced), "lang",
"get_fence_info");
cmark_node *html = cmark_node_next(fenced);
STR_EQ(runner, cmark_node_get_literal(html),
"<div>html</div>\n", "get_literal html");
cmark_node *paragraph = cmark_node_next(html);
INT_EQ(runner, cmark_node_get_start_line(paragraph), 19,
"get_start_line");
INT_EQ(runner, cmark_node_get_start_column(paragraph), 1,
"get_start_column");
INT_EQ(runner, cmark_node_get_end_line(paragraph), 19,
"get_end_line");
cmark_node *link = cmark_node_first_child(paragraph);
STR_EQ(runner, cmark_node_get_url(link), "url",
"get_url");
STR_EQ(runner, cmark_node_get_title(link), "title",
"get_title");
cmark_node *string = cmark_node_first_child(link);
STR_EQ(runner, cmark_node_get_literal(string), "link",
"get_literal string");
// Setters
OK(runner, cmark_node_set_header_level(header, 3),
"set_header_level");
OK(runner, cmark_node_set_list_type(bullet_list, CMARK_ORDERED_LIST),
"set_list_type ordered");
OK(runner, cmark_node_set_list_delim(bullet_list, CMARK_PAREN_DELIM),
"set_list_delim paren");
OK(runner, cmark_node_set_list_start(bullet_list, 3),
"set_list_start");
OK(runner, cmark_node_set_list_tight(bullet_list, 0),
"set_list_tight loose");
OK(runner, cmark_node_set_list_type(ordered_list, CMARK_BULLET_LIST),
"set_list_type bullet");
OK(runner, cmark_node_set_list_tight(ordered_list, 1),
"set_list_tight tight");
OK(runner, cmark_node_set_literal(code, "CODE\n"),
"set_literal indented code");
OK(runner, cmark_node_set_literal(fenced, "FENCED\n"),
"set_literal fenced code");
OK(runner, cmark_node_set_fence_info(fenced, "LANG"),
"set_fence_info");
OK(runner, cmark_node_set_literal(html, "<div>HTML</div>\n"),
"set_literal html");
OK(runner, cmark_node_set_url(link, "URL"),
"set_url");
OK(runner, cmark_node_set_title(link, "TITLE"),
"set_title");
OK(runner, cmark_node_set_literal(string, "LINK"),
"set_literal string");
char *rendered_html = cmark_render_html(doc, CMARK_OPT_DEFAULT);
static const char expected_html[] =
"<h3>Header</h3>\n"
"<ol start=\"3\">\n"
"<li>\n"
"<p>Item 1</p>\n"
"</li>\n"
"<li>\n"
"<p>Item 2</p>\n"
"</li>\n"
"</ol>\n"
"<ul>\n"
"<li>Item 1</li>\n"
"<li>Item 2</li>\n"
"</ul>\n"
"<pre><code>CODE\n"
"</code></pre>\n"
"<pre><code class=\"language-LANG\">FENCED\n"
"</code></pre>\n"
"<div>HTML</div>\n"
"<p><a href=\"URL\" title=\"TITLE\">LINK</a></p>\n";
STR_EQ(runner, rendered_html, expected_html, "setters work");
free(rendered_html);
// Getter errors
INT_EQ(runner, cmark_node_get_header_level(bullet_list), 0,
"get_header_level error");
INT_EQ(runner, cmark_node_get_list_type(header), CMARK_NO_LIST,
"get_list_type error");
INT_EQ(runner, cmark_node_get_list_start(code), 0,
"get_list_start error");
INT_EQ(runner, cmark_node_get_list_tight(fenced), 0,
"get_list_tight error");
OK(runner, cmark_node_get_literal(ordered_list) == NULL,
"get_literal error");
OK(runner, cmark_node_get_fence_info(paragraph) == NULL,
"get_fence_info error");
OK(runner, cmark_node_get_url(html) == NULL,
"get_url error");
OK(runner, cmark_node_get_title(header) == NULL,
"get_title error");
// Setter errors
OK(runner, !cmark_node_set_header_level(bullet_list, 3),
"set_header_level error");
OK(runner, !cmark_node_set_list_type(header, CMARK_ORDERED_LIST),
"set_list_type error");
OK(runner, !cmark_node_set_list_start(code, 3),
"set_list_start error");
OK(runner, !cmark_node_set_list_tight(fenced, 0),
"set_list_tight error");
OK(runner, !cmark_node_set_literal(ordered_list, "content\n"),
"set_literal error");
OK(runner, !cmark_node_set_fence_info(paragraph, "lang"),
"set_fence_info error");
OK(runner, !cmark_node_set_url(html, "url"),
"set_url error");
OK(runner, !cmark_node_set_title(header, "title"),
"set_title error");
OK(runner, !cmark_node_set_header_level(header, 0),
"set_header_level too small");
OK(runner, !cmark_node_set_header_level(header, 7),
"set_header_level too large");
OK(runner, !cmark_node_set_list_type(bullet_list, CMARK_NO_LIST),
"set_list_type invalid");
OK(runner, !cmark_node_set_list_start(bullet_list, -1),
"set_list_start negative");
cmark_node_free(doc);
}
static void
S_run_tests(CFCTest *test) {
CFCParser *parser = CFCParser_new();
OK(test, parser != NULL, "new");
{
CFCParcel *fish = CFCTest_parse_parcel(test, parser, "parcel Fish;");
CFCParcel *registered
= CFCParcel_new("Crustacean", "Crust", NULL, false);
CFCParcel_register(registered);
CFCParcel *parcel
= CFCTest_parse_parcel(test, parser, "parcel Crustacean;");
OK(test, parcel == registered, "Fetch registered parcel");
OK(test, CFCParser_get_parcel(parser) == parcel,
"parcel_definition sets internal var");
CFCBase_decref((CFCBase*)fish);
CFCBase_decref((CFCBase*)registered);
CFCBase_decref((CFCBase*)parcel);
}
{
static const char *const specifiers[8] = {
"foo", "_foo", "foo_yoo", "FOO", "Foo", "fOO", "f00", "foo_foo_foo"
};
for (int i = 0; i < 8; ++i) {
const char *specifier = specifiers[i];
char *src = CFCUtil_sprintf("int32_t %s;", specifier);
CFCVariable *var = CFCTest_parse_variable(test, parser, src);
STR_EQ(test, CFCVariable_micro_sym(var), specifier,
"identifier/declarator: %s", specifier);
FREEMEM(src);
CFCBase_decref((CFCBase*)var);
}
}
{
static const char *const specifiers[6] = {
"void", "float", "uint32_t", "int64_t", "uint8_t", "bool"
};
for (int i = 0; i < 6; ++i) {
const char *specifier = specifiers[i];
char *src = CFCUtil_sprintf("int32_t %s;", specifier);
CFCBase *result = CFCParser_parse(parser, src);
OK(test, result == NULL,
"reserved word not parsed as identifier: %s", specifier);
FREEMEM(src);
CFCBase_decref(result);
}
}
{
static const char *const type_strings[7] = {
"bool", "const char *", "Obj*", "i32_t", "char[]", "long[1]",
"i64_t[30]"
};
for (int i = 0; i < 7; ++i) {
const char *type_string = type_strings[i];
CFCType *type = CFCTest_parse_type(test, parser, type_string);
CFCBase_decref((CFCBase*)type);
}
}
{
static const char *const class_names[7] = {
"ByteBuf", "Obj", "ANDMatcher", "Foo", "FooJr", "FooIII", "Foo4th"
};
CFCClass *class_list[8];
for (int i = 0; i < 7; ++i) {
char *class_code = CFCUtil_sprintf("class %s {}", class_names[i]);
CFCClass *klass = CFCTest_parse_class(test, parser, class_code);
class_list[i] = klass;
FREEMEM(class_code);
}
class_list[7] = NULL;
for (int i = 0; i < 7; ++i) {
const char *class_name = class_names[i];
char *src = CFCUtil_sprintf("%s*", class_name);
char *expected = CFCUtil_sprintf("crust_%s", class_name);
CFCType *type = CFCTest_parse_type(test, parser, src);
CFCType_resolve(type, class_list);
STR_EQ(test, CFCType_get_specifier(type), expected,
"object_type_specifier: %s", class_name);
FREEMEM(src);
FREEMEM(expected);
CFCBase_decref((CFCBase*)type);
}
for (int i = 0; i < 7; ++i) {
CFCBase_decref((CFCBase*)class_list[i]);
}
CFCClass_clear_registry();
}
{
CFCType *type = CFCTest_parse_type(test, parser, "const char");
OK(test, CFCType_const(type), "type_qualifier const");
CFCBase_decref((CFCBase*)type);
}
{
static const char *const exposures[2] = {
"public", ""
};
static int (*const accessors[2])(CFCSymbol *sym) = {
CFCSymbol_public, CFCSymbol_parcel
};
for (int i = 0; i < 2; ++i) {
const char *exposure = exposures[i];
char *src = CFCUtil_sprintf("%s inert int32_t foo;", exposure);
CFCVariable *var = CFCTest_parse_variable(test, parser, src);
OK(test, accessors[i]((CFCSymbol*)var), "exposure_specifier %s",
exposure);
FREEMEM(src);
CFCBase_decref((CFCBase*)var);
}
}
{
static const char *const hex_constants[] = {
"0x1", "0x0a", "0xFFFFFFFF", "-0xFC", NULL
};
S_test_initial_value(test, parser, hex_constants, "int32_t",
"hex_constant:");
}
{
static const char *const integer_constants[] = {
"1", "-9999", "0", "10000", NULL
};
S_test_initial_value(test, parser, integer_constants, "int32_t",
"integer_constant:");
}
{
static const char *const float_constants[] = {
"1.0", "-9999.999", "0.1", "0.0", NULL
};
S_test_initial_value(test, parser, float_constants, "double",
"float_constant:");
}
{
static const char *const string_literals[] = {
"\"blah\"", "\"blah blah\"", "\"\\\"blah\\\" \\\"blah\\\"\"", NULL
};
S_test_initial_value(test, parser, string_literals, "String*",
"string_literal:");
}
{
static const char *const composites[5] = {
"int[]", "i32_t **", "Foo **", "Foo ***", "const void *"
};
for (int i = 0; i < 5; ++i) {
const char *composite = composites[i];
CFCType *type = CFCTest_parse_type(test, parser, composite);
OK(test, CFCType_is_composite(type), "composite_type: %s",
composite);
CFCBase_decref((CFCBase*)type);
}
}
{
static const char *const object_types[5] = {
"Obj *", "incremented Foo*", "decremented String *"
};
for (int i = 0; i < 3; ++i) {
const char *object_type = object_types[i];
CFCType *type = CFCTest_parse_type(test, parser, object_type);
OK(test, CFCType_is_object(type), "object_type: %s",
object_type);
CFCBase_decref((CFCBase*)type);
}
}
{
static const char *const param_list_strings[3] = {
"()",
"(int foo)",
"(Obj *foo, Foo **foo_ptr)"
};
for (int i = 0; i < 3; ++i) {
const char *param_list_string = param_list_strings[i];
CFCParamList *param_list
= CFCTest_parse_param_list(test, parser, param_list_string);
INT_EQ(test, CFCParamList_num_vars(param_list), i,
"param list num_vars: %d", i);
CFCBase_decref((CFCBase*)param_list);
}
}
{
CFCParamList *param_list
= CFCTest_parse_param_list(test, parser, "(int foo, ...)");
OK(test, CFCParamList_variadic(param_list), "variadic param list");
CFCBase_decref((CFCBase*)param_list);
}
{
const char *param_list_string =
"(int foo = 0xFF, char *bar =\"blah\")";
CFCParamList *param_list
= CFCTest_parse_param_list(test, parser, param_list_string);
const char **initial_values
= CFCParamList_get_initial_values(param_list);
STR_EQ(test, initial_values[0], "0xFF",
"param list initial_values[0]");
STR_EQ(test, initial_values[1], "\"blah\"",
"param list initial_values[1]");
OK(test, initial_values[2] == NULL, "param list initial_values[2]");
CFCBase_decref((CFCBase*)param_list);
}
{
CFCParser_set_class_name(parser, "Stuff::Obj");
CFCParser_set_class_cnick(parser, "Obj");
const char *method_string =
"public Foo* Spew_Foo(Obj *self, uint32_t *how_many);";
CFCMethod *method = CFCTest_parse_method(test, parser, method_string);
CFCBase_decref((CFCBase*)method);
const char *var_string =
"public inert Hash *hash;";
CFCVariable *var = CFCTest_parse_variable(test, parser, var_string);
CFCBase_decref((CFCBase*)var);
}
{
static const char *const class_names[4] = {
"Foo", "Foo::FooJr", "Foo::FooJr::FooIII",
"Foo::FooJr::FooIII::Foo4th"
};
for (int i = 0; i < 4; ++i) {
const char *class_name = class_names[i];
char *class_string = CFCUtil_sprintf("class %s { }", class_name);
CFCClass *klass
= CFCTest_parse_class(test, parser, class_string);
STR_EQ(test, CFCClass_get_class_name(klass), class_name,
"class_name: %s", class_name);
FREEMEM(class_string);
CFCBase_decref((CFCBase*)klass);
}
}
{
static const char *const cnicks[2] = { "Food", "FF" };
for (int i = 0; i < 2; ++i) {
const char *cnick = cnicks[i];
char *class_string
= CFCUtil_sprintf("class Foodie%s cnick %s { }", cnick, cnick);
CFCClass *klass
= CFCTest_parse_class(test, parser, class_string);
STR_EQ(test, CFCClass_get_cnick(klass), cnick, "cnick: %s", cnick);
FREEMEM(class_string);
CFCBase_decref((CFCBase*)klass);
}
}
CFCBase_decref((CFCBase*)parser);
CFCClass_clear_registry();
CFCParcel_reap_singletons();
}