static void test_object_iterator(void **state)
{
JsonElement *obj = JsonObjectCreate(10);
JsonObjectAppendString(obj, "first", "one");
JsonObjectAppendString(obj, "second", "two");
JsonObjectAppendInteger(obj, "third", 3);
JsonObjectAppendBool(obj, "fourth", true);
JsonObjectAppendBool(obj, "fifth", false);
{
JsonIterator it = JsonIteratorInit(obj);
assert_string_equal("first", JsonIteratorNextKey(&it));
assert_string_equal("second", JsonIteratorNextKey(&it));
assert_string_equal("third", JsonIteratorNextKey(&it));
assert_string_equal("fourth", JsonIteratorNextKey(&it));
assert_string_equal("fifth", JsonIteratorNextKey(&it));
assert_false(JsonIteratorNextKey(&it));
}
{
JsonIterator it = JsonIteratorInit(obj);
assert_string_equal("one", JsonPrimitiveGetAsString(JsonIteratorNextValue(&it)));
assert_string_equal("two", JsonPrimitiveGetAsString(JsonIteratorNextValue(&it)));
assert_int_equal(3, JsonPrimitiveGetAsInteger(JsonIteratorNextValue(&it)));
assert_true(JsonPrimitiveGetAsBool(JsonIteratorNextValue(&it)));
assert_false(JsonPrimitiveGetAsBool(JsonIteratorNextValue(&it)));
assert_false(JsonIteratorNextValue(&it));
}
JsonElementDestroy(obj);
}
static bool RenderVariablePrimitive(Buffer *out, const JsonElement *primitive, const bool escaped, const bool key_mode)
{
if (key_mode && JsonElementGetPropertyName(primitive))
{
if (escaped)
{
RenderHTMLContent(out, JsonElementGetPropertyName(primitive), strlen(JsonElementGetPropertyName(primitive)));
}
else
{
BufferAppendString(out, JsonElementGetPropertyName(primitive));
}
return true;
}
switch (JsonGetPrimitiveType(primitive))
{
case JSON_PRIMITIVE_TYPE_STRING:
if (escaped)
{
RenderHTMLContent(out, JsonPrimitiveGetAsString(primitive), strlen(JsonPrimitiveGetAsString(primitive)));
}
else
{
BufferAppendString(out, JsonPrimitiveGetAsString(primitive));
}
return true;
case JSON_PRIMITIVE_TYPE_INTEGER:
{
char *str = StringFromLong(JsonPrimitiveGetAsInteger(primitive));
BufferAppendString(out, str);
free(str);
}
return true;
case JSON_PRIMITIVE_TYPE_REAL:
{
char *str = StringFromDouble(JsonPrimitiveGetAsReal(primitive));
BufferAppendString(out, str);
free(str);
}
return true;
case JSON_PRIMITIVE_TYPE_BOOL:
BufferAppendString(out, JsonPrimitiveGetAsBool(primitive) ? "true" : "false");
return true;
case JSON_PRIMITIVE_TYPE_NULL:
return true;
default:
assert(!"Unrecognised JSON primitive type");
}
return false;
}
static void test_parse_escaped_string(void)
{
{
const char *data = "\"\\\\\"";
const char *original = data;
JsonElement *json = NULL;
assert_int_equal(JSON_PARSE_OK, JsonParse(&data, &json));
assert_string_equal("\\", JsonPrimitiveGetAsString(json));
char *out = JsonToString(json);
assert_string_equal(original, out);
free(out);
JsonDestroy(json);
}
{
// included by paranoia from Redmine #5773
const char *data = "\"/\\\\//\\\\/\\\\\"";
const char *original = data;
JsonElement *json = NULL;
assert_int_equal(JSON_PARSE_OK, JsonParse(&data, &json));
assert_string_equal("/\\//\\/\\", JsonPrimitiveGetAsString(json));
char *out = JsonToString(json);
assert_string_equal(original, out);
free(out);
JsonDestroy(json);
}
{
const char *data = "\"x\\tx\"";
const char *original = data;
JsonElement *json = NULL;
assert_int_equal(JSON_PARSE_OK, JsonParse(&data, &json));
assert_string_equal("x\tx", JsonPrimitiveGetAsString(json));
char *out = JsonToString(json);
assert_string_equal(original, out);
free(out);
JsonDestroy(json);
}
}
static void RlistAppendContainerPrimitive(Rlist **list, const JsonElement *primitive)
{
assert(JsonGetElementType(primitive) == JSON_ELEMENT_TYPE_PRIMITIVE);
switch (JsonGetPrimitiveType(primitive))
{
case JSON_PRIMITIVE_TYPE_BOOL:
RlistAppendScalar(list, JsonPrimitiveGetAsBool(primitive) ? "true" : "false");
break;
case JSON_PRIMITIVE_TYPE_INTEGER:
{
char *str = StringFromLong(JsonPrimitiveGetAsInteger(primitive));
RlistAppendScalar(list, str);
free(str);
}
break;
case JSON_PRIMITIVE_TYPE_REAL:
{
char *str = StringFromDouble(JsonPrimitiveGetAsReal(primitive));
RlistAppendScalar(list, str);
free(str);
}
break;
case JSON_PRIMITIVE_TYPE_STRING:
RlistAppendScalar(list, JsonPrimitiveGetAsString(primitive));
break;
case JSON_PRIMITIVE_TYPE_NULL:
break;
}
}
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_select(void)
{
const char *data = OBJECT_ARRAY;
JsonElement *obj = NULL;
assert_int_equal(JSON_PARSE_OK, JsonParse(&data, &obj));
assert_true(obj == JsonSelect(obj, 0, NULL));
{
char *indices[] = { "first" };
assert_int_equal(JSON_CONTAINER_TYPE_ARRAY, JsonGetContainerType(JsonSelect(obj, 1, indices)));
}
{
char *indices[] = { "first", "0" };
assert_string_equal("one", JsonPrimitiveGetAsString(JsonSelect(obj, 2, indices)));
}
{
char *indices[] = { "first", "1" };
assert_string_equal("two", JsonPrimitiveGetAsString(JsonSelect(obj, 2, indices)));
}
{
char *indices[] = { "first", "2" };
assert_true(JsonSelect(obj, 2, indices) == NULL);
}
{
char *indices[] = { "first", "x" };
assert_true(JsonSelect(obj, 2, indices) == NULL);
}
{
char *indices[] = { "first", "0", "x" };
assert_true(JsonSelect(obj, 3, indices) == NULL);
}
{
char *indices[] = { "second" };
assert_true(JsonSelect(obj, 1, indices) == NULL);
}
JsonDestroy(obj);
}
static void test_parse_empty_string(void)
{
const char *data = "";
JsonElement *json = NULL;
assert_int_not_equal(JSON_PARSE_OK, JsonParse(&data, &json));
assert_false(json);
data = "\"\"";
assert_int_equal(JSON_PARSE_OK, JsonParse(&data, &json));
assert_string_equal("", JsonPrimitiveGetAsString(json));
JsonDestroy(json);
}
static void test_parse_primitives(void)
{
JsonElement *pri = NULL;
const char *data = "\"foo\"";
assert_int_equal(JSON_PARSE_OK, JsonParse(&data, &pri));
assert_string_equal("foo", JsonPrimitiveGetAsString(pri));
JsonDestroy(pri);
data = "-123";
assert_int_equal(JSON_PARSE_OK, JsonParse(&data, &pri));
assert_true(-123 == JsonPrimitiveGetAsInteger(pri));
JsonDestroy(pri);
data = "1.23";
assert_int_equal(JSON_PARSE_OK, JsonParse(&data, &pri));
assert_double_close(1.23, JsonPrimitiveGetAsReal(pri));
JsonDestroy(pri);
data = "true";
assert_int_equal(JSON_PARSE_OK, JsonParse(&data, &pri));
assert_true(JsonPrimitiveGetAsBool(pri));
JsonDestroy(pri);
}
/**
* Expand a #string into Buffer #out, returning the pointer to the string
* itself, inside the Buffer #out. If #out is NULL then the buffer will be
* created and destroyed internally.
*
* @retval NULL something went wrong
*/
char *ExpandScalar(const EvalContext *ctx, const char *ns, const char *scope,
const char *string, Buffer *out)
{
bool out_belongs_to_us = false;
if (out == NULL)
{
out = BufferNew();
out_belongs_to_us = true;
}
assert(string != NULL);
assert(out != NULL);
Buffer *current_item = BufferNew();
for (const char *sp = string; *sp != '\0'; sp++)
{
BufferClear(current_item);
ExtractScalarPrefix(current_item, sp, strlen(sp));
BufferAppend(out, BufferData(current_item), BufferSize(current_item));
sp += BufferSize(current_item);
if (*sp == '\0')
{
break;
}
BufferClear(current_item);
char varstring = sp[1];
ExtractScalarReference(current_item, sp, strlen(sp), true);
sp += BufferSize(current_item) + 2;
if (IsCf3VarString(BufferData(current_item)))
{
Buffer *temp = BufferCopy(current_item);
BufferClear(current_item);
ExpandScalar(ctx, ns, scope, BufferData(temp), current_item);
BufferDestroy(temp);
}
if (!IsExpandable(BufferData(current_item)))
{
VarRef *ref = VarRefParseFromNamespaceAndScope(
BufferData(current_item),
ns, scope, CF_NS, '.');
DataType value_type;
const void *value = EvalContextVariableGet(ctx, ref, &value_type);
VarRefDestroy(ref);
switch (DataTypeToRvalType(value_type))
{
case RVAL_TYPE_SCALAR:
assert(value != NULL);
BufferAppendString(out, value);
continue;
break;
case RVAL_TYPE_CONTAINER:
{
assert(value != NULL);
const JsonElement *jvalue = value; /* instead of casts */
if (JsonGetElementType(jvalue) == JSON_ELEMENT_TYPE_PRIMITIVE)
{
BufferAppendString(out, JsonPrimitiveGetAsString(jvalue));
continue;
}
break;
}
default:
/* TODO Log() */
break;
}
}
if (varstring == '{')
{
BufferAppendF(out, "${%s}", BufferData(current_item));
}
else
{
BufferAppendF(out, "$(%s)", BufferData(current_item));
}
}
BufferDestroy(current_item);
LogDebug(LOG_MOD_EXPAND, "ExpandScalar( %s : %s . %s ) => %s",
SAFENULL(ns), SAFENULL(scope), string, BufferData(out));
return out_belongs_to_us ? BufferClose(out) : BufferGet(out);
}
bool ExpandScalar(const EvalContext *ctx,
const char *ns, const char *scope, const char *string,
Buffer *out)
{
assert(string);
if (strlen(string) == 0)
{
return true;
}
bool fully_expanded = true;
Buffer *current_item = BufferNew();
for (const char *sp = string; *sp != '\0'; sp++)
{
BufferClear(current_item);
ExtractScalarPrefix(current_item, sp, strlen(sp));
BufferAppend(out, BufferData(current_item), BufferSize(current_item));
sp += BufferSize(current_item);
if (*sp == '\0')
{
break;
}
BufferClear(current_item);
char varstring = sp[1];
ExtractScalarReference(current_item, sp, strlen(sp), true);
sp += BufferSize(current_item) + 2;
if (IsCf3VarString(BufferData(current_item)))
{
Buffer *temp = BufferCopy(current_item);
BufferClear(current_item);
ExpandScalar(ctx, ns, scope, BufferData(temp), current_item);
BufferDestroy(temp);
}
if (!IsExpandable(BufferData(current_item)))
{
DataType type = CF_DATA_TYPE_NONE;
const void *value = NULL;
{
VarRef *ref = VarRefParseFromNamespaceAndScope(BufferData(current_item), ns, scope, CF_NS, '.');
value = EvalContextVariableGet(ctx, ref, &type);
VarRefDestroy(ref);
}
if (value)
{
switch (DataTypeToRvalType(type))
{
case RVAL_TYPE_SCALAR:
BufferAppendString(out, value);
continue;
case RVAL_TYPE_CONTAINER:
if (JsonGetElementType((JsonElement*)value) == JSON_ELEMENT_TYPE_PRIMITIVE)
{
BufferAppendString(out, JsonPrimitiveGetAsString((JsonElement*)value));
continue;
}
break;
default:
break;
}
}
}
if (varstring == '{')
{
BufferAppendF(out, "${%s}", BufferData(current_item));
}
else
{
BufferAppendF(out, "$(%s)", BufferData(current_item));
}
}
BufferDestroy(current_item);
return fully_expanded;
}
