Adding upstream version 1.44.3.upstream/1.44.3

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 914 insertions, 0 deletions

diff --git a/fluent-bit/tests/internal/pack.c b/fluent-bit/tests/internal/pack.c
new file mode 100644
index 000000000..1bfabfeb6
--- /dev/null
+++ b/fluent-bit/tests/internal/pack.c
@@ -0,0 +1,914 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+#include <fluent-bit/flb_info.h>
+#include <fluent-bit/flb_mem.h>
+#include <fluent-bit/flb_pack.h>
+#include <fluent-bit/flb_error.h>
+#include <fluent-bit/flb_str.h>
+#include <monkey/mk_core.h>
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <dirent.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <math.h> /* for NAN */
+
+
+#include "flb_tests_internal.h"
+
+/* JSON iteration tests */
+#define JSON_SINGLE_MAP1 FLB_TESTS_DATA_PATH "/data/pack/json_single_map_001.json"
+#define JSON_SINGLE_MAP2 FLB_TESTS_DATA_PATH "/data/pack/json_single_map_002.json"
+#define JSON_DUP_KEYS_I  FLB_TESTS_DATA_PATH "/data/pack/dup_keys_in.json"
+#define JSON_DUP_KEYS_O  FLB_TESTS_DATA_PATH "/data/pack/dup_keys_out.json"
+
+#define JSON_BUG342      FLB_TESTS_DATA_PATH "/data/pack/bug342.json"
+
+/* Pack Samples path */
+#define PACK_SAMPLES     FLB_TESTS_DATA_PATH "/data/pack/"
+
+struct pack_test {
+    char *msgpack;
+    char *json;
+};
+
+/* If we get more than 256 tests, just update the size */
+struct pack_test pt[256];
+
+static inline void consume_bytes(char *buf, int bytes, int length)
+{
+    memmove(buf, buf + bytes, length - bytes);
+}
+
+/* Pack a simple JSON map */
+void test_json_pack()
+{
+    int ret;
+    int root_type;
+    size_t len;
+    char *data;
+    char *out_buf;
+    size_t out_size;
+
+    data = mk_file_to_buffer(JSON_SINGLE_MAP1);
+    TEST_CHECK(data != NULL);
+
+    len = strlen(data);
+
+    ret = flb_pack_json(data, len, &out_buf, &out_size, &root_type, NULL);
+    TEST_CHECK(ret == 0);
+
+    flb_free(data);
+    flb_free(out_buf);
+}
+
+/* Pack a simple JSON map using a state */
+void test_json_pack_iter()
+{
+    int i;
+    int ret;
+    size_t len;
+    char *data;
+    char *out_buf = NULL;
+    int out_size;
+    struct flb_pack_state state;
+
+    data = mk_file_to_buffer(JSON_SINGLE_MAP1);
+    TEST_CHECK(data != NULL);
+
+    len = strlen(data);
+
+    ret = flb_pack_state_init(&state);
+    TEST_CHECK(ret == 0);
+
+    /* Pass byte by byte */
+    for (i = 1; i < len; i++) {
+        ret = flb_pack_json_state(data, i, &out_buf, &out_size, &state);
+        if (i + 1 != len) {
+            TEST_CHECK(ret == FLB_ERR_JSON_PART);
+        }
+    }
+    TEST_CHECK(ret != FLB_ERR_JSON_INVAL && ret != FLB_ERR_JSON_PART);
+
+    flb_pack_state_reset(&state);
+    flb_free(data);
+    flb_free(out_buf);
+}
+
+/* Pack two concatenated JSON maps using a state */
+void test_json_pack_mult()
+
+{
+    int ret;
+    int maps = 0;
+    size_t off = 0;
+    size_t len1;
+    size_t len2;
+    size_t total;
+    char *buf;
+    char *data1;
+    char *data2;
+    char *out_buf;
+    int out_size;
+    msgpack_unpacked result;
+    msgpack_object root;
+    struct flb_pack_state state;
+
+    data1 = mk_file_to_buffer(JSON_SINGLE_MAP1);
+    TEST_CHECK(data1 != NULL);
+    len1 = strlen(data1);
+
+    data2 = mk_file_to_buffer(JSON_SINGLE_MAP2);
+    TEST_CHECK(data2 != NULL);
+    len2 = strlen(data2);
+
+    buf = flb_malloc(len1 + len2 + 1);
+    TEST_CHECK(buf != NULL);
+
+    /* Merge buffers */
+    memcpy(buf, data1, len1);
+    memcpy(buf + len1, data2, len2);
+    total = len1 + len2;
+    buf[total] = '\0';
+
+    /* Release buffers */
+    flb_free(data1);
+    flb_free(data2);
+
+    ret = flb_pack_state_init(&state);
+    TEST_CHECK(ret == 0);
+
+    /* Enable the 'multiple' flag so the parser will accept concatenated msgs */
+    state.multiple = FLB_TRUE;
+
+    /* It should pack two msgpack-maps in out_buf */
+    ret = flb_pack_json_state(buf, total, &out_buf, &out_size, &state);
+    TEST_CHECK(ret == 0);
+
+    /* Validate output buffer */
+    msgpack_unpacked_init(&result);
+    while (msgpack_unpack_next(&result, out_buf, out_size, &off) == MSGPACK_UNPACK_SUCCESS) {
+        maps++;
+        root = result.data;
+        TEST_CHECK(root.type == MSGPACK_OBJECT_MAP);
+    }
+    msgpack_unpacked_destroy(&result);
+
+    TEST_CHECK(maps == 2);
+
+    flb_pack_state_reset(&state);
+    flb_free(out_buf);
+    flb_free(buf);
+}
+
+/* Pack two concatenated JSON maps byte by byte using a state */
+void test_json_pack_mult_iter()
+
+{
+    int i;
+    int ret;
+    int maps = 0;
+    int total_maps = 0;
+    size_t off = 0;
+    size_t len1;
+    size_t len2;
+    size_t total;
+    char *buf;
+    char *data1;
+    char *data2;
+    char *out_buf;
+    int out_size;
+    msgpack_unpacked result;
+    msgpack_object root;
+    struct flb_pack_state state;
+
+    data1 = mk_file_to_buffer(JSON_SINGLE_MAP1);
+    TEST_CHECK(data1 != NULL);
+    len1 = strlen(data1);
+
+    data2 = mk_file_to_buffer(JSON_SINGLE_MAP2);
+    TEST_CHECK(data2 != NULL);
+    len2 = strlen(data2);
+
+    buf = flb_malloc(len1 + len2 + 1);
+    TEST_CHECK(buf != NULL);
+
+    /* Merge buffers */
+    memcpy(buf, data1, len1);
+    memcpy(buf + len1, data2, len2);
+    total = len1 + len2;
+    buf[total] = '\0';
+
+    /* Release buffers */
+    flb_free(data1);
+    flb_free(data2);
+
+    ret = flb_pack_state_init(&state);
+    TEST_CHECK(ret == 0);
+
+    /* Enable the 'multiple' flag so the parser will accept concatenated msgs */
+    state.multiple = FLB_TRUE;
+
+    /* Pass byte by byte */
+    for (i = 1; i < total; i++) {
+        ret = flb_pack_json_state(buf, i, &out_buf, &out_size, &state);
+        if (ret == 0) {
+            /* Consume processed bytes */
+            consume_bytes(buf, state.last_byte, total);
+            i = 1;
+            total -= state.last_byte;
+            flb_pack_state_reset(&state);
+            flb_pack_state_init(&state);
+
+            /* Validate output buffer */
+            off = 0;
+            maps = 0;
+            msgpack_unpacked_init(&result);
+            while (msgpack_unpack_next(&result, out_buf, out_size, &off) == MSGPACK_UNPACK_SUCCESS) {
+                root = result.data;
+                TEST_CHECK(root.type == MSGPACK_OBJECT_MAP);
+                maps++;
+                total_maps++;
+            }
+            TEST_CHECK(maps == 1);
+            msgpack_unpacked_destroy(&result);
+            flb_free(out_buf);
+        }
+    }
+
+    TEST_CHECK(total_maps == 2);
+    flb_pack_state_reset(&state);
+    flb_free(buf);
+}
+
+/* Validate default values of macros used in flb_msgpack_raw_to_json_sds */
+void test_msgpack_to_json_macros()
+{
+    /* Verify default values */
+    TEST_CHECK(FLB_MSGPACK_TO_JSON_INIT_BUFFER_SIZE == 2.0);
+    TEST_CHECK(FLB_MSGPACK_TO_JSON_REALLOC_BUFFER_SIZE == 0.10);
+}
+
+/* Validate that duplicated keys are removed */
+void test_json_dup_keys()
+{
+    int ret;
+    int type;
+    size_t len_in;
+    char *out_buf;
+    size_t out_size;
+    char *data_in;
+    char *data_out;
+    flb_sds_t out_json;
+    flb_sds_t d;
+
+    /* Read JSON input file */
+    data_in = mk_file_to_buffer(JSON_DUP_KEYS_I);
+    TEST_CHECK(data_in != NULL);
+    len_in = strlen(data_in);
+
+    /* Read JSON output file */
+    data_out = mk_file_to_buffer(JSON_DUP_KEYS_O);
+    TEST_CHECK(data_out != NULL);
+
+    /* Pack raw JSON as msgpack */
+    ret = flb_pack_json(data_in, len_in, &out_buf, &out_size, &type, NULL);
+    TEST_CHECK(ret == 0);
+
+    d = flb_sds_create("date");
+    TEST_CHECK(d != NULL);
+
+    /* Convert back to JSON */
+    out_json = flb_pack_msgpack_to_json_format(out_buf, out_size,
+                                               FLB_PACK_JSON_FORMAT_LINES,
+                                               FLB_PACK_JSON_DATE_EPOCH,
+                                               d);
+    TEST_CHECK(out_json != NULL);
+
+    TEST_CHECK(strncmp(out_json, data_out, flb_sds_len(out_json)) == 0);
+    flb_sds_destroy(d);
+    flb_sds_destroy(out_json);
+    flb_free(out_buf);
+    flb_free(data_in);
+    flb_free(data_out);
+}
+
+void test_json_pack_bug342()
+{
+    int i = 0;
+    int records = 0;
+    int fd;
+    int ret;
+    size_t off = 0;
+    ssize_t r = 0;
+    char *out;
+    char buf[1024*4];
+    int out_size;
+    size_t total = 0;
+    int bytes[] = {1, 3, 3, 5, 5, 35, 17, 23,
+                   46, 37, 49, 51, 68, 70, 86, 268,
+                   120, 178, 315, 754, 753, 125};
+    struct stat st;
+    struct flb_pack_state state;
+    msgpack_unpacked result;
+    ret = stat(JSON_BUG342, &st);
+    if (ret == -1) {
+        perror("stat");
+        exit(EXIT_FAILURE);
+    }
+
+    for (i = 0; i < (sizeof(bytes)/sizeof(int)); i++) {
+        total += bytes[i];
+    }
+
+    TEST_CHECK(total == st.st_size);
+    if (total != st.st_size) {
+        exit(EXIT_FAILURE);
+    }
+
+    fd = open(JSON_BUG342, O_RDONLY);
+    if (fd == -1) {
+        perror("open");
+        exit(EXIT_FAILURE);
+    }
+
+    flb_pack_state_init(&state);
+    state.multiple = FLB_TRUE;
+
+    for (i = 0; i < (sizeof(bytes)/sizeof(int)); i++) {
+        r = read(fd, buf + off, bytes[i]);
+        TEST_CHECK(r == bytes[i]);
+        if (r <= 0) {
+            perror("read");
+            exit(EXIT_FAILURE);
+        }
+        off += r;
+
+        ret = flb_pack_json_state(buf, off, &out, &out_size, &state);
+        TEST_CHECK(ret != FLB_ERR_JSON_INVAL);
+        if (ret == FLB_ERR_JSON_INVAL) {
+            exit(EXIT_FAILURE);
+        }
+        else if (ret == FLB_ERR_JSON_PART) {
+            continue;
+        }
+        else if (ret == 0) {
+            /* remove used bytes */
+            consume_bytes(buf, state.last_byte, off);
+            off -= state.last_byte;
+
+            /* reset the packer state */
+            flb_pack_state_reset(&state);
+            flb_pack_state_init(&state);
+            state.multiple = FLB_TRUE;
+        }
+
+        size_t coff = 0;
+        msgpack_unpacked_init(&result);
+        while (msgpack_unpack_next(&result, out, out_size, &coff) == MSGPACK_UNPACK_SUCCESS) {
+            records++;
+        }
+        msgpack_unpacked_destroy(&result);
+
+        TEST_CHECK(off >= state.last_byte);
+        if (off < state.last_byte) {
+            exit(1);
+        }
+        flb_free(out);
+    }
+    flb_pack_state_reset(&state);
+    close(fd);
+    TEST_CHECK(records == 240);
+}
+
+
+/* Iterate data/pack/ directory and compose an array with files to test */
+static int utf8_tests_create()
+{
+    int i = 0;
+    int len;
+    int ret;
+    char ext_mp[PATH_MAX];
+    char ext_json[PATH_MAX];
+    DIR *dir;
+    struct pack_test *test;
+    struct dirent *entry;
+    struct stat st;
+
+    memset(pt, '\0', sizeof(pt));
+
+    dir = opendir(PACK_SAMPLES);
+    TEST_CHECK(dir != NULL);
+    if (dir == NULL) {
+        exit(EXIT_FAILURE);
+    }
+
+    while ((entry = readdir(dir)) != NULL) {
+        if (entry->d_type != DT_REG) {
+            continue;
+        }
+
+        len = strlen(entry->d_name);
+        if (strcmp(entry->d_name + (len - 3), ".mp") != 0) {
+            continue;
+        }
+
+        snprintf(ext_mp, sizeof(ext_mp) - 1,
+                 "%s%s", PACK_SAMPLES, entry->d_name);
+        len = snprintf(ext_json, sizeof(ext_json) - 1, "%s%s",
+                       PACK_SAMPLES, entry->d_name);
+        snprintf(ext_json + (len - 3), sizeof(ext_json) - len - 3,
+                 "%s", ".json");
+
+
+        /* Validate new paths */
+        ret = stat(ext_mp, &st);
+        if (ret == -1) {
+            printf("Unit test msgpack not found: %s\n", ext_mp);
+            exit(EXIT_FAILURE);
+        }
+
+        ret = stat(ext_json, &st);
+        if (ret == -1) {
+            printf("Unit test result JSON not found: %s\n", ext_json);
+            exit(EXIT_FAILURE);
+        }
+
+        /* Insert into table */
+        test = &pt[i];
+        test->msgpack = flb_strdup(ext_mp);
+        test->json    = flb_strdup(ext_json);
+        i++;
+    }
+
+    closedir(dir);
+    return i;
+}
+
+static void utf8_tests_destroy(int s)
+{
+    int i;
+    struct pack_test *test;
+
+    for (i = 0; i < s; i++) {
+        test = &pt[i];
+        flb_free(test->msgpack);
+        flb_free(test->json);
+    }
+}
+
+void test_utf8_to_json()
+{
+    int i;
+    int ret;
+    int n_tests;
+    char *file_msgp;
+    char *file_json;
+    flb_sds_t out_buf;
+    size_t out_size;
+    size_t msgp_size;
+    size_t json_size;
+    struct stat st;
+    struct pack_test *test;
+
+    n_tests = utf8_tests_create();
+
+    /* Iterate unit tests table */
+    for (i = 0; i < n_tests; i++) {
+        test = &pt[i];
+        if (!test->msgpack) {
+            break;
+        }
+
+        file_msgp = mk_file_to_buffer(test->msgpack);
+        TEST_CHECK(file_msgp != NULL);
+        stat(test->msgpack, &st);
+        msgp_size = st.st_size;
+
+        file_json = mk_file_to_buffer(test->json);
+        TEST_CHECK(file_json != NULL);
+        if (!file_json) {
+            printf("Missing JSON file: %s\n", test->json);
+            flb_free(file_msgp);
+            continue;
+        }
+
+        json_size = strlen(file_json);
+
+        out_buf = flb_msgpack_raw_to_json_sds(file_msgp, msgp_size);
+        TEST_CHECK(out_buf != NULL);
+        out_size = flb_sds_len(out_buf);
+
+        ret = strcmp(file_json, out_buf);
+        if (ret != 0) {
+            TEST_CHECK(ret == 0);
+            printf("[test] %s\n", test->json);
+            printf("       EXPECTED => '%s'\n", file_json);
+            printf("       ENCODED  => '%s'\n", out_buf);
+        }
+
+        TEST_CHECK(out_size == json_size);
+
+        if (out_buf) {
+            flb_sds_destroy(out_buf);
+        }
+        flb_free(file_msgp);
+        flb_free(file_json);
+    }
+
+    utf8_tests_destroy(n_tests);
+}
+
+void test_json_pack_bug1278()
+{
+    int i;
+    int len;
+    int ret;
+    int items;
+    int type;
+    char *p_in;
+    char *p_out;
+    char *out_buf;
+    size_t out_size;
+    msgpack_sbuffer mp_sbuf;
+    msgpack_packer mp_pck;
+    msgpack_unpacked result;
+    msgpack_object root;
+    msgpack_object val;
+    size_t off = 0;
+    flb_sds_t json;
+    char tmp[32];
+
+    char *in[]  = {
+                   "one\atwo",
+                   "one\btwo",
+                   "one\ttwo",
+                   "one\ntwo",
+                   "one\vtwo",
+                   "one\ftwo",
+                   "one\rtwo",
+                   "\\n",
+    };
+
+    char *out[] = {
+                   "\"one\\u0007two\"",
+                   "\"one\\btwo\"",
+                   "\"one\\ttwo\"",
+                   "\"one\\ntwo\"",
+                   "\"one\\u000btwo\"",
+                   "\"one\\ftwo\"",
+                   "\"one\\rtwo\"",
+                   "\"\\\\n\"",
+    };
+
+    printf("\n");
+    items = sizeof(in) / sizeof(char *);
+    for (i = 0; i < items; i++) {
+        p_in = in[i];
+        p_out = out[i];
+
+        len = strlen(p_in);
+
+        msgpack_sbuffer_init(&mp_sbuf);
+        msgpack_packer_init(&mp_pck, &mp_sbuf, msgpack_sbuffer_write);
+
+        msgpack_pack_str(&mp_pck, len);
+        msgpack_pack_str_body(&mp_pck, p_in, len);
+
+        /* Pack raw string as JSON */
+        json = flb_msgpack_raw_to_json_sds(mp_sbuf.data, mp_sbuf.size);
+
+        /* Compare expected JSON output */
+        ret = strcmp(p_out, json);
+        TEST_CHECK(ret == 0);
+        if (ret != 0) {
+            printf("== JSON comparisson failed ==\n");
+            printf("expected: %s\n", p_out);
+            printf("output  : %s\n", json);
+        }
+        else {
+            printf("test %i out => %s\n", i, json);
+        }
+        /* Put JSON string in a map and convert it to msgpack */
+        snprintf(tmp, sizeof(tmp) -1 , "{\"log\": %s}", json);
+        ret = flb_pack_json(tmp, strlen(tmp), &out_buf, &out_size, &type, NULL);
+        TEST_CHECK(ret == 0);
+        if (ret != 0) {
+            printf("failed packaging to JSON\n");
+        }
+
+        /* Unpack 'log' value and compare it to the original raw */
+        off = 0;
+        msgpack_unpacked_init(&result);
+        ret = msgpack_unpack_next(&result, out_buf, out_size, &off);
+        TEST_CHECK(ret == MSGPACK_UNPACK_SUCCESS);
+
+        /* Check parent type is a map */
+        root = result.data;
+        TEST_CHECK(root.type == MSGPACK_OBJECT_MAP);
+
+        /* Get map value */
+        val = root.via.map.ptr[0].val;
+        TEST_CHECK(val.type == MSGPACK_OBJECT_STR);
+
+        /* Compare bytes length */
+        len = strlen(p_in);
+        TEST_CHECK(len == val.via.str.size);
+        if (len != val.via.str.size) {
+            printf("failed comparing string length\n");
+        }
+
+        /* Compare raw bytes */
+        ret = memcmp(val.via.str.ptr, p_in, len);
+        TEST_CHECK(ret == 0);
+        if (ret != 0) {
+            printf("failed comparing to original value\n");
+        }
+
+        /* Relese resources */
+        flb_free(out_buf);
+        flb_sds_destroy(json);
+        msgpack_unpacked_destroy(&result);
+        msgpack_sbuffer_destroy(&mp_sbuf);
+
+    }
+}
+
+void test_json_pack_nan()
+{
+    int ret;
+    char json_str[128] = {0};
+    char *p = NULL;
+    struct flb_config config;
+    msgpack_sbuffer mp_sbuf;
+    msgpack_packer mp_pck;
+    msgpack_object obj;
+    msgpack_zone mempool;
+
+    config.convert_nan_to_null = FLB_TRUE;
+
+    // initialize msgpack
+    msgpack_sbuffer_init(&mp_sbuf);
+    msgpack_packer_init(&mp_pck, &mp_sbuf, msgpack_sbuffer_write);
+    msgpack_pack_double(&mp_pck, NAN);
+    msgpack_zone_init(&mempool, 2048);
+    msgpack_unpack(mp_sbuf.data, mp_sbuf.size, NULL, &mempool, &obj);
+    msgpack_zone_destroy(&mempool);
+    msgpack_sbuffer_destroy(&mp_sbuf);
+
+    // convert msgpack to json
+    ret = flb_msgpack_to_json(&json_str[0], sizeof(json_str), &obj);
+    TEST_CHECK(ret >= 0);
+
+    p = strstr(&json_str[0], "nan");
+    if (!TEST_CHECK(p != NULL)) {
+        TEST_MSG("json should be nan. json_str=%s", json_str);
+    }
+
+    // convert. nan -> null
+    memset(&json_str[0], 0, sizeof(json_str));
+    flb_pack_init(&config);
+    ret = flb_msgpack_to_json(&json_str[0], sizeof(json_str), &obj);
+    TEST_CHECK(ret >= 0);
+
+    p = strstr(&json_str[0], "null");
+    if (!TEST_CHECK(p != NULL)) {
+        TEST_MSG("json should be null. json_str=%s", json_str);
+    }
+
+    // clear setting
+    config.convert_nan_to_null = FLB_FALSE;
+    flb_pack_init(&config);
+}
+
+static int check_msgpack_val(msgpack_object obj, int expected_type, char *expected_val)
+{
+    int len;
+
+    if (!TEST_CHECK(obj.type == expected_type)) {
+        TEST_MSG("type mismatch\nexpected=%d got=%d", expected_type, obj.type);
+        return -1;
+    }
+    switch(obj.type) {
+    case MSGPACK_OBJECT_MAP:
+        if(!TEST_CHECK(obj.via.map.size == atoi(expected_val))) {
+            TEST_MSG("map size mismatch\nexpected=%s got=%d", expected_val, obj.via.map.size);
+            return -1;
+        }
+        break;
+
+    case MSGPACK_OBJECT_ARRAY:
+        if(!TEST_CHECK(obj.via.array.size == atoi(expected_val))) {
+            TEST_MSG("array size mismatch\nexpected=%s got=%d", expected_val, obj.via.array.size);
+            return -1;
+        }
+        break;
+
+    case MSGPACK_OBJECT_STR:
+        len = strlen(expected_val);
+        if (!TEST_CHECK(obj.via.str.size == strlen(expected_val))) {
+            TEST_MSG("str size mismatch\nexpected=%d got=%d", len, obj.via.str.size);
+            return -1;
+        }
+        else if(!TEST_CHECK(strncmp(expected_val, obj.via.str.ptr ,len) == 0)) {
+            TEST_MSG("str mismatch\nexpected=%.*s got=%.*s", len, expected_val, len, obj.via.str.ptr);
+            return -1;
+        }
+        break;
+
+    case MSGPACK_OBJECT_POSITIVE_INTEGER:
+        if(!TEST_CHECK(obj.via.u64 == (uint64_t)atoi(expected_val))) {
+            TEST_MSG("int mismatch\nexpected=%s got=%"PRIu64, expected_val, obj.via.u64);
+            return -1;
+        }
+        break;
+
+    case MSGPACK_OBJECT_BOOLEAN:
+        if (obj.via.boolean) {
+            if(!TEST_CHECK(strncasecmp(expected_val, "true",4) == 0)) {
+                TEST_MSG("bool mismatch\nexpected=%s got=true", expected_val);
+                return -1;
+            }
+        }
+        else {
+            if(!TEST_CHECK(strncasecmp(expected_val, "false",5) == 0)) {
+                TEST_MSG("bool mismatch\nexpected=%s got=false", expected_val);
+                return -1;
+            }
+        }
+        break;
+
+    default:
+        TEST_MSG("unknown type %d", obj.type);
+        return -1;
+    }
+
+    return 0;
+}
+
+/*
+ * https://github.com/fluent/fluent-bit/issues/5336
+ * Pack "valid JSON + partial JSON"
+ */
+#define JSON_BUG5336 "{\"int\":10, \"string\":\"hello\", \"bool\":true, \"array\":[0,1,2]}"
+void test_json_pack_bug5336()
+{
+    int ret;
+    char *json_valid = JSON_BUG5336;
+    size_t len = strlen(json_valid);
+
+    char *json_incomplete = JSON_BUG5336 JSON_BUG5336;
+    char *out = NULL;
+    int out_size;
+    struct flb_pack_state state;
+    int i;
+
+    msgpack_unpacked result;
+    msgpack_object obj;
+    size_t off = 0;
+
+    int loop_cnt = 0;
+
+    for (i=len; i<len*2; i++) {
+        loop_cnt++;
+
+        flb_pack_state_init(&state);
+
+        /* Pass small string size to create incomplete JSON */
+        ret = flb_pack_json_state(json_incomplete, i, &out, &out_size, &state);
+        if (!TEST_CHECK(ret != FLB_ERR_JSON_INVAL)) {
+            TEST_MSG("%ld: FLB_ERR_JSON_INVAL\njson=%.*s", i-len, i, json_incomplete);
+            exit(EXIT_FAILURE);
+        }
+        else if(!TEST_CHECK(ret != FLB_ERR_JSON_PART)) {
+            TEST_MSG("%ld: FLB_ERR_JSON_PART\njson=%.*s", i-len, i, json_incomplete);
+            exit(EXIT_FAILURE);
+        }
+
+        /* unpack parsed data */
+        msgpack_unpacked_init(&result);
+        off = 0;
+        TEST_CHECK(msgpack_unpack_next(&result, out, out_size, &off) == MSGPACK_UNPACK_SUCCESS);
+
+        TEST_CHECK(check_msgpack_val(result.data, MSGPACK_OBJECT_MAP, "4" /*map size*/) == 0);
+
+        /* "int":10 */
+        obj = result.data.via.map.ptr[0].key;
+        TEST_CHECK(check_msgpack_val(obj, MSGPACK_OBJECT_STR, "int") == 0);
+        obj = result.data.via.map.ptr[0].val;
+        TEST_CHECK(check_msgpack_val(obj, MSGPACK_OBJECT_POSITIVE_INTEGER, "10") == 0);
+
+        /* "string":"hello"*/
+        obj = result.data.via.map.ptr[1].key;
+        TEST_CHECK(check_msgpack_val(obj, MSGPACK_OBJECT_STR, "string") == 0);
+        obj = result.data.via.map.ptr[1].val;
+        TEST_CHECK(check_msgpack_val(obj, MSGPACK_OBJECT_STR, "hello") == 0);
+
+        /* "bool":true */
+        obj = result.data.via.map.ptr[2].key;
+        TEST_CHECK(check_msgpack_val(obj, MSGPACK_OBJECT_STR, "bool") == 0);
+        obj = result.data.via.map.ptr[2].val;
+        TEST_CHECK(check_msgpack_val(obj, MSGPACK_OBJECT_BOOLEAN, "true") == 0);
+
+        /* "array":[0,1,2] */
+        obj = result.data.via.map.ptr[3].key;
+        TEST_CHECK(check_msgpack_val(obj, MSGPACK_OBJECT_STR, "array") == 0);
+        obj = result.data.via.map.ptr[3].val;
+        TEST_CHECK(check_msgpack_val(obj, MSGPACK_OBJECT_ARRAY, "3" /*array size*/) == 0);
+        TEST_CHECK(check_msgpack_val(obj.via.array.ptr[0], MSGPACK_OBJECT_POSITIVE_INTEGER, "0") == 0);
+        TEST_CHECK(check_msgpack_val(obj.via.array.ptr[1], MSGPACK_OBJECT_POSITIVE_INTEGER, "1") == 0);
+        TEST_CHECK(check_msgpack_val(obj.via.array.ptr[2], MSGPACK_OBJECT_POSITIVE_INTEGER, "2") == 0);
+
+        msgpack_unpacked_destroy(&result);
+        flb_free(out);
+        flb_pack_state_reset(&state);
+    }
+
+    if(!TEST_CHECK(loop_cnt == len)) {
+        TEST_MSG("loop_cnt expect=%ld got=%d", len, loop_cnt);
+    }
+}
+
+const char input_msgpack[] = {0x92,/* array 2 */
+                            0xd7, 0x00, /* event time*/
+                            0x07, 0x5b, 0xcd, 0x15, /* second = 123456789 = 1973/11/29 21:33:09 */
+                            0x07, 0x5b, 0xcd, 0x15, /* nanosecond = 123456789 */
+                            0x81, 0xa2, 0x61, 0x61, 0xa2, 0x62, 0x62 /* {"aa":"bb"} */
+};
+
+void test_json_date(char* expect, int date_format)
+{
+    flb_sds_t json_key;
+    flb_sds_t ret;
+
+    json_key = flb_sds_create("date");
+    if (!TEST_CHECK(json_key != NULL)) {
+        TEST_MSG("flb_sds_create failed");
+        exit(1);
+    }
+
+    ret = flb_pack_msgpack_to_json_format((const char*)&input_msgpack[0], sizeof(input_msgpack),
+                                          FLB_PACK_JSON_FORMAT_JSON, date_format,
+                                          json_key);
+    if (!TEST_CHECK(ret != NULL)) {
+        TEST_MSG("flb_pack_msgpack_to_json_format failed");
+        flb_sds_destroy(json_key);
+        exit(1);
+    }
+    flb_sds_destroy(json_key);
+
+    if (!TEST_CHECK(strstr(ret, expect) != NULL)) {
+        TEST_MSG("mismatch. Got=%s expect=%s", ret, expect);
+    }
+
+    flb_sds_destroy(ret);
+}
+
+void test_json_date_iso8601()
+{
+    test_json_date("1973-11-29T21:33:09.123456Z", FLB_PACK_JSON_DATE_ISO8601);
+}
+
+void test_json_date_double()
+{
+    test_json_date("123456789.123456", FLB_PACK_JSON_DATE_DOUBLE);
+}
+
+void test_json_date_java_sql()
+{
+    test_json_date("1973-11-29 21:33:09.123456", FLB_PACK_JSON_DATE_JAVA_SQL_TIMESTAMP);
+}
+
+void test_json_date_epoch()
+{
+    test_json_date("123456789", FLB_PACK_JSON_DATE_EPOCH);
+}
+
+void test_json_date_epoch_ms()
+{
+    test_json_date("123456789123", FLB_PACK_JSON_DATE_EPOCH_MS);
+}
+
+TEST_LIST = {
+    /* JSON maps iteration */
+    { "json_pack"          , test_json_pack },
+    { "json_pack_iter"     , test_json_pack_iter},
+    { "json_pack_mult"     , test_json_pack_mult},
+    { "json_pack_mult_iter", test_json_pack_mult_iter},
+    { "json_macros"        , test_msgpack_to_json_macros},
+    { "json_dup_keys"      , test_json_dup_keys},
+    { "json_pack_bug342"   , test_json_pack_bug342},
+    { "json_pack_bug1278"  , test_json_pack_bug1278},
+    { "json_pack_nan"      , test_json_pack_nan},
+    { "json_pack_bug5336"  , test_json_pack_bug5336},
+    { "json_date_iso8601" , test_json_date_iso8601},
+    { "json_date_double" , test_json_date_double},
+    { "json_date_java_sql" , test_json_date_java_sql},
+    { "json_date_epoch" , test_json_date_epoch},
+    { "json_date_epoch_ms" , test_json_date_epoch_ms},
+
+    /* Mixed bytes, check JSON encoding */
+    { "utf8_to_json", test_utf8_to_json},
+    { 0 }
+};