static void test_merge_array(void)
{
JsonElement *a = JsonArrayCreate(2);
JsonArrayAppendString(a, "a");
JsonArrayAppendString(a, "b");
JsonElement *b = JsonArrayCreate(2);
JsonArrayAppendString(b, "c");
JsonArrayAppendString(b, "d");
JsonElement *c = JsonMerge(a, b);
assert_int_equal(2, JsonLength(a));
assert_int_equal(2, JsonLength(b));
assert_int_equal(4, JsonLength(c));
assert_string_equal("a", JsonArrayGetAsString(c, 0));
assert_string_equal("b", JsonArrayGetAsString(c, 1));
assert_string_equal("c", JsonArrayGetAsString(c, 2));
assert_string_equal("d", JsonArrayGetAsString(c, 3));
JsonDestroy(a);
JsonDestroy(b);
JsonDestroy(c);
}
static void test_array_get_string(void)
{
JsonElement *arr = JsonArrayCreate(10);
JsonArrayAppendString(arr, "first");
JsonArrayAppendString(arr, "second");
assert_string_equal(JsonArrayGetAsString(arr, 1), "second");
assert_string_equal(JsonArrayGetAsString(arr, 0), "first");
JsonDestroy(arr);
}
static void test_show_array(void **state)
{
JsonElement *array = JsonArrayCreate(10);
JsonArrayAppendString(array, "one");
JsonArrayAppendString(array, "two");
Writer *writer = StringWriter();
JsonElementPrint(writer, array, 0);
assert_string_equal(ARRAY_SIMPLE, StringWriterData(writer));
JsonElementDestroy(array);
}
static JsonElement *ExportBodyAsJson(Body *body)
{
JsonElement *json_body = JsonObjectCreate(10);
JsonObjectAppendInteger(json_body, "offset", body->offset.start);
JsonObjectAppendInteger(json_body, "offset-end", body->offset.end);
JsonObjectAppendString(json_body, "name", body->name);
JsonObjectAppendString(json_body, "body-type", body->type);
{
JsonElement *json_args = JsonArrayCreate(10);
Rlist *argp = NULL;
for (argp = body->args; argp != NULL; argp = argp->next)
{
JsonArrayAppendString(json_args, argp->item);
}
JsonObjectAppendArray(json_body, "arguments", json_args);
}
JsonObjectAppendArray(json_body, "classes", ExportBodyClassesAsJson(body->conlist));
return json_body;
}
static JsonElement *ExportAttributesSyntaxAsJson(const ConstraintSyntax attributes[])
{
JsonElement *json = JsonObjectCreate(10);
int i = 0;
if (attributes == NULL)
{
return json;
}
for (i = 0; attributes[i].lval != NULL; i++)
{
if (attributes[i].range.validation_string == CF_BUNDLE)
{
/* TODO: must handle edit_line somehow */
continue;
}
else if (attributes[i].dtype == DATA_TYPE_BODY)
{
JsonElement *json_attributes = ExportAttributesSyntaxAsJson(attributes[i].range.body_type_syntax->constraints);
JsonObjectAppendObject(json, attributes[i].lval, json_attributes);
}
else
{
JsonElement *attribute = JsonObjectCreate(10);
JsonObjectAppendString(attribute, "datatype", CF_DATATYPES[attributes[i].dtype]);
if (strlen(attributes[i].range.validation_string) == 0)
{
JsonObjectAppendString(attribute, "pcre-range", ".*");
}
else if (attributes[i].dtype == DATA_TYPE_OPTION || attributes[i].dtype == DATA_TYPE_OPTION_LIST)
{
JsonElement *options = JsonArrayCreate(10);
char options_buffer[CF_BUFSIZE];
char *option = NULL;
strcpy(options_buffer, attributes[i].range.validation_string);
for (option = strtok(options_buffer, ","); option != NULL; option = strtok(NULL, ","))
{
JsonArrayAppendString(options, option);
}
JsonObjectAppendArray(attribute, "pcre-range", options);
}
else
{
char *pcre_range = PCREStringToJsonString(attributes[i].range.validation_string);
JsonObjectAppendString(attribute, "pcre-range", pcre_range);
}
JsonObjectAppendObject(json, attributes[i].lval, attribute);
}
}
return json;
}
JsonElement *FnCallToJson(FnCall *fp)
{
assert(fp);
JsonElement *object = JsonObjectCreate(3);
JsonObjectAppendString(object, "name", fp->name);
JsonObjectAppendString(object, "type", "function-call");
JsonElement *argsArray = JsonArrayCreate(fp->argc);
for (Rlist *rp = fp->args; rp != NULL; rp = rp->next)
{
switch (rp->type)
{
case CF_SCALAR:
JsonArrayAppendString(argsArray, (const char *) rp->item);
break;
case CF_FNCALL:
JsonArrayAppendObject(argsArray, FnCallToJson((FnCall *) rp->item));
break;
default:
assert(false && "Unknown argument type");
break;
}
}
JsonObjectAppendArray(object, "arguments", argsArray);
return object;
}
static JsonElement *FnCallToJson(const FnCall *fp)
{
assert(fp);
JsonElement *object = JsonObjectCreate(3);
JsonObjectAppendString(object, "name", fp->name);
JsonObjectAppendString(object, "type", "function-call");
JsonElement *argsArray = JsonArrayCreate(5);
for (Rlist *rp = fp->args; rp != NULL; rp = rp->next)
{
switch (rp->val.type)
{
case RVAL_TYPE_SCALAR:
JsonArrayAppendString(argsArray, RlistScalarValue(rp));
break;
case RVAL_TYPE_FNCALL:
JsonArrayAppendObject(argsArray, FnCallToJson(RlistFnCallValue(rp)));
break;
default:
assert(false && "Unknown argument type");
break;
}
}
JsonObjectAppendArray(object, "arguments", argsArray);
return object;
}
static JsonElement *RlistToJson(Rlist *list)
{
JsonElement *array = JsonArrayCreate(RlistLen(list));
for (Rlist *rp = list; rp; rp = rp->next)
{
switch (rp->val.type)
{
case RVAL_TYPE_SCALAR:
JsonArrayAppendString(array, RlistScalarValue(rp));
break;
case RVAL_TYPE_LIST:
JsonArrayAppendArray(array, RlistToJson(RlistRlistValue(rp)));
break;
case RVAL_TYPE_FNCALL:
JsonArrayAppendObject(array, FnCallToJson(RlistFnCallValue(rp)));
break;
default:
assert(false && "Unsupported item type in rlist");
break;
}
}
return array;
}
static void test_show_array_compact(void)
{
JsonElement *array = JsonArrayCreate(10);
JsonArrayAppendString(array, "one");
JsonArrayAppendString(array, "two");
Writer *writer = StringWriter();
JsonWriteCompact(writer, array);
char *output = StringWriterClose(writer);
assert_string_equal("[\"one\",\"two\"]", output);
JsonDestroy(array);
free(output);
}
static void test_array_iterator(void **state)
{
JsonElement *arr = JsonArrayCreate(10);
JsonArrayAppendString(arr, "first");
JsonArrayAppendString(arr, "second");
{
JsonIterator it = JsonIteratorInit(arr);
assert_string_equal("first", JsonPrimitiveGetAsString(JsonIteratorNextValue(&it)));
assert_string_equal("second", JsonPrimitiveGetAsString(JsonIteratorNextValue(&it)));
assert_false(JsonIteratorNextValue(&it));
}
JsonElementDestroy(arr);
}
static void test_object_get_array(void)
{
JsonElement *arr = JsonArrayCreate(10);
JsonArrayAppendString(arr, "one");
JsonArrayAppendString(arr, "two");
JsonElement *obj = JsonObjectCreate(10);
JsonObjectAppendArray(obj, "array", arr);
JsonElement *arr2 = JsonObjectGetAsArray(obj, "array");
assert_string_equal(JsonArrayGetAsString(arr2, 1), "two");
JsonDestroy(obj);
}
static void test_show_array(void)
{
JsonElement *array = JsonArrayCreate(10);
JsonArrayAppendString(array, "one");
JsonArrayAppendString(array, "two");
Writer *writer = StringWriter();
JsonWrite(writer, array, 0);
char *output = StringWriterClose(writer);
assert_string_equal(ARRAY_SIMPLE, output);
JsonDestroy(array);
free(output);
}
static void test_show_object_array(void **state)
{
JsonElement *json = JsonObjectCreate(10);
JsonElement *array = JsonArrayCreate(10);
JsonArrayAppendString(array, "one");
JsonArrayAppendString(array, "two");
JsonObjectAppendArray(json, "first", array);
Writer *writer = StringWriter();
JsonElementPrint(writer, json, 0);
assert_string_equal(OBJECT_ARRAY, StringWriterData(writer));
JsonElementDestroy(json);
}
static void test_show_object_array(void)
{
JsonElement *json = JsonObjectCreate(10);
JsonElement *array = JsonArrayCreate(10);
JsonArrayAppendString(array, "one");
JsonArrayAppendString(array, "two");
JsonObjectAppendArray(json, "first", array);
Writer *writer = StringWriter();
JsonWrite(writer, json, 0);
char *output = StringWriterClose(writer);
assert_string_equal(OBJECT_ARRAY, output);
JsonDestroy(json);
free(output);
}
JsonElement *StringSetToJson(const StringSet *set)
{
JsonElement *arr = JsonArrayCreate(StringSetSize(set));
StringSetIterator it = StringSetIteratorInit((StringSet *)set);
const char *el = NULL;
while ((el = StringSetIteratorNext(&it)))
{
JsonArrayAppendString(arr, el);
}
return arr;
}
static JsonElement *ExportBundleAsJson(Bundle *bundle)
{
JsonElement *json_bundle = JsonObjectCreate(10);
JsonObjectAppendInteger(json_bundle, "offset", bundle->offset.start);
JsonObjectAppendInteger(json_bundle, "offset-end", bundle->offset.end);
JsonObjectAppendString(json_bundle, "name", bundle->name);
JsonObjectAppendString(json_bundle, "bundle-type", bundle->type);
{
JsonElement *json_args = JsonArrayCreate(10);
Rlist *argp = NULL;
for (argp = bundle->args; argp != NULL; argp = argp->next)
{
JsonArrayAppendString(json_args, argp->item);
}
JsonObjectAppendArray(json_bundle, "arguments", json_args);
}
{
JsonElement *json_promise_types = JsonArrayCreate(10);
SubType *sp = NULL;
for (sp = bundle->subtypes; sp != NULL; sp = sp->next)
{
JsonElement *json_promise_type = JsonObjectCreate(10);
JsonObjectAppendInteger(json_promise_type, "offset", sp->offset.start);
JsonObjectAppendInteger(json_promise_type, "offset-end", sp->offset.end);
JsonObjectAppendString(json_promise_type, "name", sp->name);
JsonObjectAppendArray(json_promise_type, "classes", ExportBundleClassesAsJson(sp->promiselist));
JsonArrayAppendObject(json_promise_types, json_promise_type);
}
JsonObjectAppendArray(json_bundle, "promise-types", json_promise_types);
}
return json_bundle;
}
static JsonElement *BundleTypesToJson(void)
{
JsonElement *bundle_types = JsonObjectCreate(50);
Seq *common_promise_types = SeqNew(50, free);
for (int module_index = 0; module_index < CF3_MODULES; module_index++)
{
for (int promise_type_index = 0; CF_ALL_PROMISE_TYPES[module_index][promise_type_index].promise_type; promise_type_index++)
{
const PromiseTypeSyntax *promise_type_syntax = &CF_ALL_PROMISE_TYPES[module_index][promise_type_index];
// skip global constraints
if (strcmp("*", promise_type_syntax->promise_type) == 0)
{
continue;
}
// collect common promise types to be appended at the end
if (strcmp("*", promise_type_syntax->bundle_type) == 0)
{
SeqAppend(common_promise_types, xstrdup(promise_type_syntax->promise_type));
continue;
}
if (promise_type_syntax->status == SYNTAX_STATUS_REMOVED)
{
continue;
}
JsonElement *bundle_type = JsonObjectGet(bundle_types, promise_type_syntax->bundle_type);
if (!bundle_type)
{
bundle_type = JsonBundleTypeNew();
JsonObjectAppendObject(bundle_types, promise_type_syntax->bundle_type, bundle_type);
}
assert(bundle_type);
JsonElement *promise_types = JsonObjectGet(bundle_type, "promiseTypes");
assert(promise_types);
JsonArrayAppendString(promise_types, promise_type_syntax->promise_type);
}
}
// Append the common bundle, which has only common promise types, but is not declared in syntax
{
JsonElement *bundle_type = JsonBundleTypeNew();
JsonObjectAppendObject(bundle_types, "common", bundle_type);
}
JsonIterator it = JsonIteratorInit(bundle_types);
const char *bundle_type = NULL;
while ((bundle_type = JsonIteratorNextKey(&it)))
{
JsonElement *promise_types = JsonObjectGetAsArray(JsonObjectGetAsObject(bundle_types, bundle_type), "promiseTypes");
for (int i = 0; i < SeqLength(common_promise_types); i++)
{
const char *common_promise_type = SeqAt(common_promise_types, i);
JsonArrayAppendString(promise_types, common_promise_type);
}
}
SeqDestroy(common_promise_types);
return bundle_types;
}
static void test_array_remove_range(void)
{
{
// remove whole
JsonElement *arr = JsonArrayCreate(5);
JsonArrayAppendString(arr, "one");
JsonArrayAppendString(arr, "two");
JsonArrayAppendString(arr, "three");
JsonArrayRemoveRange(arr, 0, 2);
assert_int_equal(JsonLength(arr), 0);
JsonDestroy(arr);
}
{
// remove middle
JsonElement *arr = JsonArrayCreate(5);
JsonArrayAppendString(arr, "one");
JsonArrayAppendString(arr, "two");
JsonArrayAppendString(arr, "three");
JsonArrayRemoveRange(arr, 1, 1);
assert_int_equal(JsonLength(arr), 2);
assert_string_equal(JsonArrayGetAsString(arr, 0), "one");
assert_string_equal(JsonArrayGetAsString(arr, 1), "three");
JsonDestroy(arr);
}
{
// remove rest
JsonElement *arr = JsonArrayCreate(5);
JsonArrayAppendString(arr, "one");
JsonArrayAppendString(arr, "two");
JsonArrayAppendString(arr, "three");
JsonArrayRemoveRange(arr, 1, 2);
assert_int_equal(JsonLength(arr), 1);
assert_string_equal(JsonArrayGetAsString(arr, 0), "one");
JsonDestroy(arr);
}
{
// remove but last
JsonElement *arr = JsonArrayCreate(5);
JsonArrayAppendString(arr, "one");
JsonArrayAppendString(arr, "two");
JsonArrayAppendString(arr, "three");
JsonArrayRemoveRange(arr, 0, 1);
assert_int_equal(JsonLength(arr), 1);
assert_string_equal(JsonArrayGetAsString(arr, 0), "three");
JsonDestroy(arr);
}
}
