| /** |
| *Licensed to the Apache Software Foundation (ASF) under one |
| *or more contributor license agreements. See the NOTICE file |
| *distributed with this work for additional information |
| *regarding copyright ownership. The ASF licenses this file |
| *to you under the Apache License, Version 2.0 (the |
| *"License"); you may not use this file except in compliance |
| *with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| *Unless required by applicable law or agreed to in writing, |
| *software distributed under the License is distributed on an |
| *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| *specific language governing permissions and limitations |
| *under the License. |
| */ |
| |
| #include "gtest/gtest.h" |
| |
| #include <stdarg.h> |
| |
| |
| extern "C" { |
| #include "avrobin_serializer.h" |
| |
| static void stdLog(void*, int level, const char *file, int line, const char *msg, ...) { |
| va_list ap; |
| const char *levels[5] = {"NIL", "ERROR", "WARNING", "INFO", "DEBUG"}; |
| fprintf(stderr, "%s: FILE:%s, LINE:%i, MSG:",levels[level], file, line); |
| va_start(ap, msg); |
| vfprintf(stderr, msg, ap); |
| fprintf(stderr, "\n"); |
| va_end(ap); |
| } |
| |
| static const char *test1_descriptor = "I"; |
| |
| static const char *test2_descriptor = "{IIII a b c d}"; |
| |
| struct test2_type { |
| int32_t a; |
| int32_t b; |
| int32_t c; |
| int32_t d; |
| }; |
| |
| static const char *test3_descriptor = "{{I a}{I b} c d}"; |
| |
| struct test3_type_subtype1 { |
| int32_t a; |
| }; |
| |
| struct test3_type_subtype2 { |
| int32_t b; |
| }; |
| |
| struct test3_type { |
| struct test3_type_subtype1 c; |
| struct test3_type_subtype2 d; |
| }; |
| |
| static const char *test4_descriptor = "F"; |
| |
| static const char *test5_descriptor = "D"; |
| |
| static const char *test6_descriptor = "t"; |
| |
| static const char *test7_descriptor = "[I"; |
| |
| struct test7_type { |
| uint32_t cap; |
| uint32_t len; |
| int32_t *buf; |
| }; |
| |
| static const char *test8_descriptor = "[{DD one two}"; |
| |
| struct test8_subtype { |
| double one; |
| double two; |
| }; |
| |
| struct test8_type { |
| uint32_t cap; |
| uint32_t len; |
| struct test8_subtype *buf; |
| }; |
| |
| static const char *test9_descriptor = "[[F"; |
| |
| struct test9_subtype { |
| uint32_t cap; |
| uint32_t len; |
| float *buf; |
| }; |
| |
| struct test9_type { |
| uint32_t cap; |
| uint32_t len; |
| struct test9_subtype *buf; |
| }; |
| |
| static const char *test10_descriptor = "*I"; |
| |
| static const char *test11_descriptor = "{*{DD a b} c}"; |
| |
| struct test11_subtype { |
| double a; |
| double b; |
| }; |
| |
| struct test11_type { |
| struct test11_subtype *c; |
| }; |
| |
| static const char *test12_descriptor = "#OK=2;#NOK=4;#MAYBE=8;E"; |
| |
| enum test12_enum { |
| TEST12_ENUM_OK = 2, |
| TEST12_ENUM_NOK = 4, |
| TEST12_ENUM_MAYBE = 8 |
| }; |
| |
| static void generalTests() { |
| dyn_type *type; |
| void *inst; |
| uint8_t *serdata; |
| size_t serdatalen; |
| char *schema; |
| int rc; |
| |
| int32_t test1_val = -444; |
| |
| type = NULL; |
| inst = NULL; |
| serdata = NULL; |
| serdatalen = 0; |
| schema = NULL; |
| rc = dynType_parseWithStr(test1_descriptor, "test1", NULL, &type); |
| ASSERT_EQ(0, rc); |
| if (rc == 0) { |
| rc = avrobinSerializer_serialize(type, &test1_val, &serdata, &serdatalen); |
| ASSERT_EQ(0, rc); |
| if (rc == 0) { |
| rc = avrobinSerializer_deserialize(type, serdata, serdatalen, &inst); |
| ASSERT_EQ(0, rc); |
| if (rc == 0) { |
| ASSERT_EQ(-444,*(int32_t*)inst); |
| rc = avrobinSerializer_generateSchema(type, &schema); |
| ASSERT_EQ(0, rc); |
| if (rc == 0) { |
| printf("%s\n", schema); |
| rc = avrobinSerializer_saveFile("test1.avro", schema, serdata, serdatalen); |
| ASSERT_EQ(0, rc); |
| free(schema); |
| } |
| dynType_free(type, inst); |
| } |
| free(serdata); |
| } |
| dynType_destroy(type); |
| } |
| |
| struct test2_type test2_val; |
| test2_val.a = 10000; |
| test2_val.b = 20000; |
| test2_val.c = -30000; |
| test2_val.d = -40000; |
| |
| type = NULL; |
| inst = NULL; |
| serdata = NULL; |
| serdatalen = 0; |
| schema = NULL; |
| rc = dynType_parseWithStr(test2_descriptor, "test2", NULL, &type); |
| ASSERT_EQ(0, rc); |
| if (rc == 0) { |
| rc = avrobinSerializer_serialize(type, &test2_val, &serdata, &serdatalen); |
| ASSERT_EQ(0, rc); |
| if (rc == 0) { |
| rc = avrobinSerializer_deserialize(type, serdata, serdatalen, &inst); |
| ASSERT_EQ(0, rc); |
| if (rc == 0) { |
| ASSERT_EQ(10000,(*(struct test2_type*)inst).a); |
| ASSERT_EQ(20000,(*(struct test2_type*)inst).b); |
| ASSERT_EQ(-30000,(*(struct test2_type*)inst).c); |
| ASSERT_EQ(-40000,(*(struct test2_type*)inst).d); |
| rc = avrobinSerializer_generateSchema(type, &schema); |
| ASSERT_EQ(0, rc); |
| if (rc == 0) { |
| printf("%s\n", schema); |
| rc = avrobinSerializer_saveFile("test2.avro", schema, serdata, serdatalen); |
| ASSERT_EQ(0, rc); |
| free(schema); |
| } |
| dynType_free(type, inst); |
| } |
| free(serdata); |
| } |
| dynType_destroy(type); |
| } |
| |
| struct test3_type test3_val; |
| test3_val.c.a = 101; |
| test3_val.d.b = 99; |
| |
| type = NULL; |
| inst = NULL; |
| serdata = NULL; |
| serdatalen = 0; |
| schema = NULL; |
| rc = dynType_parseWithStr(test3_descriptor, "test3", NULL, &type); |
| ASSERT_EQ(0, rc); |
| if (rc == 0) { |
| rc = avrobinSerializer_serialize(type, &test3_val, &serdata, &serdatalen); |
| ASSERT_EQ(0, rc); |
| if (rc == 0) { |
| rc = avrobinSerializer_deserialize(type, serdata, serdatalen, &inst); |
| ASSERT_EQ(0, rc); |
| if (rc == 0) { |
| ASSERT_EQ(101,(*(struct test3_type*)inst).c.a); |
| ASSERT_EQ(99,(*(struct test3_type*)inst).d.b); |
| rc = avrobinSerializer_generateSchema(type, &schema); |
| ASSERT_EQ(0, rc); |
| if (rc == 0) { |
| printf("%s\n", schema); |
| rc = avrobinSerializer_saveFile("test3.avro", schema, serdata, serdatalen); |
| ASSERT_EQ(0, rc); |
| free(schema); |
| } |
| dynType_free(type, inst); |
| } |
| free(serdata); |
| } |
| dynType_destroy(type); |
| } |
| |
| float test4_val = 1.234f; |
| |
| type = NULL; |
| inst = NULL; |
| serdata = NULL; |
| serdatalen = 0; |
| schema = NULL; |
| rc = dynType_parseWithStr(test4_descriptor, "test4", NULL, &type); |
| ASSERT_EQ(0, rc); |
| if (rc == 0) { |
| rc = avrobinSerializer_serialize(type, &test4_val, &serdata, &serdatalen); |
| ASSERT_EQ(0, rc); |
| if (rc == 0) { |
| rc = avrobinSerializer_deserialize(type, serdata, serdatalen, &inst); |
| ASSERT_EQ(0, rc); |
| if (rc == 0) { |
| ASSERT_EQ(1.234f,*(float*)inst); |
| rc = avrobinSerializer_generateSchema(type, &schema); |
| ASSERT_EQ(0, rc); |
| if (rc == 0) { |
| printf("%s\n", schema); |
| rc = avrobinSerializer_saveFile("test4.avro", schema, serdata, serdatalen); |
| ASSERT_EQ(0, rc); |
| free(schema); |
| } |
| dynType_free(type, inst); |
| } |
| free(serdata); |
| } |
| dynType_destroy(type); |
| } |
| |
| double test5_val = 2.345678; |
| |
| type = NULL; |
| inst = NULL; |
| serdata = NULL; |
| serdatalen = 0; |
| schema = NULL; |
| rc = dynType_parseWithStr(test5_descriptor, "test5", NULL, &type); |
| ASSERT_EQ(0, rc); |
| if (rc == 0) { |
| rc = avrobinSerializer_serialize(type, &test5_val, &serdata, &serdatalen); |
| ASSERT_EQ(0, rc); |
| if (rc == 0) { |
| rc = avrobinSerializer_deserialize(type, serdata, serdatalen, &inst); |
| ASSERT_EQ(0, rc); |
| if (rc == 0) { |
| ASSERT_EQ(2.345678,*(double*)inst); |
| rc = avrobinSerializer_generateSchema(type, &schema); |
| ASSERT_EQ(0, rc); |
| if (rc == 0) { |
| printf("%s\n", schema); |
| rc = avrobinSerializer_saveFile("test5.avro", schema, serdata, serdatalen); |
| ASSERT_EQ(0, rc); |
| free(schema); |
| } |
| dynType_free(type, inst); |
| } |
| free(serdata); |
| } |
| dynType_destroy(type); |
| } |
| |
| const char *test6_val = "This is a string."; |
| |
| type = NULL; |
| inst = NULL; |
| serdata = NULL; |
| serdatalen = 0; |
| schema = NULL; |
| rc = dynType_parseWithStr(test6_descriptor, "test6", NULL, &type); |
| ASSERT_EQ(0, rc); |
| if (rc == 0) { |
| rc = avrobinSerializer_serialize(type, &test6_val, &serdata, &serdatalen); |
| ASSERT_EQ(0, rc); |
| if (rc == 0) { |
| rc = avrobinSerializer_deserialize(type, serdata, serdatalen, &inst); |
| ASSERT_EQ(0, rc); |
| if (rc == 0) { |
| ASSERT_STREQ("This is a string.",*(const char**)inst); |
| rc = avrobinSerializer_generateSchema(type, &schema); |
| ASSERT_EQ(0, rc); |
| if (rc == 0) { |
| printf("%s\n", schema); |
| rc = avrobinSerializer_saveFile("test6.avro", schema, serdata, serdatalen); |
| ASSERT_EQ(0, rc); |
| free(schema); |
| } |
| dynType_free(type, inst); |
| } |
| free(serdata); |
| } |
| dynType_destroy(type); |
| } |
| |
| struct test7_type test7_val; |
| test7_val.cap = 8; |
| test7_val.len = 8; |
| test7_val.buf = (int32_t*)malloc(sizeof(int32_t) * test7_val.cap); |
| for (unsigned int i=0; i<test7_val.len; i++) { |
| test7_val.buf[i] = i; |
| } |
| |
| type = NULL; |
| inst = NULL; |
| serdata = NULL; |
| serdatalen = 0; |
| schema = NULL; |
| rc = dynType_parseWithStr(test7_descriptor, "test7", NULL, &type); |
| ASSERT_EQ(0, rc); |
| if (rc == 0) { |
| rc = avrobinSerializer_serialize(type, &test7_val, &serdata, &serdatalen); |
| ASSERT_EQ(0, rc); |
| if (rc == 0) { |
| rc = avrobinSerializer_deserialize(type, serdata, serdatalen, &inst); |
| ASSERT_EQ(0, rc); |
| if (rc == 0) { |
| ASSERT_EQ(8, (*(struct test7_type*)inst).cap); |
| ASSERT_EQ(8, (*(struct test7_type*)inst).len); |
| if ((*(struct test7_type*)inst).cap == 8 && (*(struct test7_type*)inst).len == 8) { |
| for (int i=0; i<8; i++) { |
| ASSERT_EQ(i, (*(struct test7_type*)inst).buf[i]); |
| } |
| } |
| rc = avrobinSerializer_generateSchema(type, &schema); |
| ASSERT_EQ(0, rc); |
| if (rc == 0) { |
| printf("%s\n", schema); |
| rc = avrobinSerializer_saveFile("test7.avro", schema, serdata, serdatalen); |
| ASSERT_EQ(0, rc); |
| free(schema); |
| } |
| dynType_free(type, inst); |
| } |
| free(serdata); |
| } |
| dynType_destroy(type); |
| } |
| |
| free(test7_val.buf); |
| |
| struct test8_type test8_val; |
| test8_val.cap = 128; |
| test8_val.len = 64; |
| test8_val.buf = (struct test8_subtype*)malloc(sizeof(struct test8_subtype) * test8_val.cap); |
| for (int i=0; i<64; i++) { |
| (test8_val.buf[i]).one = i * 3.333; |
| (test8_val.buf[i]).two = i * 4.444; |
| } |
| |
| type = NULL; |
| inst = NULL; |
| serdata = NULL; |
| serdatalen = 0; |
| schema = NULL; |
| rc = dynType_parseWithStr(test8_descriptor, "test8", NULL, &type); |
| ASSERT_EQ(0, rc); |
| if (rc == 0) { |
| rc = avrobinSerializer_serialize(type, &test8_val, &serdata, &serdatalen); |
| ASSERT_EQ(0, rc); |
| if (rc == 0) { |
| rc = avrobinSerializer_deserialize(type, serdata, serdatalen, &inst); |
| ASSERT_EQ(0, rc); |
| if (rc == 0) { |
| ASSERT_EQ(64, (*(struct test8_type*)inst).cap); |
| ASSERT_EQ(64, (*(struct test8_type*)inst).len); |
| if ((*(struct test8_type*)inst).cap == 64 && (*(struct test8_type*)inst).len == 64) { |
| for (int i=0; i<64; i++) { |
| ASSERT_EQ( i * 3.333 , ((*(struct test8_type*)inst).buf[i]).one ); |
| ASSERT_EQ( i * 4.444 , ((*(struct test8_type*)inst).buf[i]).two ); |
| } |
| } |
| rc = avrobinSerializer_generateSchema(type, &schema); |
| ASSERT_EQ(0, rc); |
| if (rc == 0) { |
| printf("%s\n", schema); |
| rc = avrobinSerializer_saveFile("test8.avro", schema, serdata, serdatalen); |
| ASSERT_EQ(0, rc); |
| free(schema); |
| } |
| dynType_free(type, inst); |
| } |
| free(serdata); |
| } |
| dynType_destroy(type); |
| } |
| |
| free(test8_val.buf); |
| |
| struct test9_type test9_val; |
| test9_val.cap = 64; |
| test9_val.len = 64; |
| test9_val.buf = (struct test9_subtype*)malloc(sizeof(struct test9_subtype) * test9_val.cap); |
| for (int i=0; i<64; i++) { |
| (test9_val.buf[i]).cap = 8; |
| (test9_val.buf[i]).len = 8; |
| (test9_val.buf[i]).buf = (float*)malloc(sizeof(float) * 8); |
| for (int j=0; j<8; j++) { |
| (test9_val.buf[i]).buf[j] = j * 1.234f; |
| } |
| } |
| |
| type = NULL; |
| inst = NULL; |
| serdata = NULL; |
| serdatalen = 0; |
| schema = NULL; |
| rc = dynType_parseWithStr(test9_descriptor, "test9", NULL, &type); |
| ASSERT_EQ(0, rc); |
| if (rc == 0) { |
| rc = avrobinSerializer_serialize(type, &test9_val, &serdata, &serdatalen); |
| ASSERT_EQ(0, rc); |
| if (rc == 0) { |
| rc = avrobinSerializer_deserialize(type, serdata, serdatalen, &inst); |
| ASSERT_EQ(0, rc); |
| if (rc == 0) { |
| ASSERT_EQ(64, (*(struct test9_type*)inst).cap); |
| ASSERT_EQ(64, (*(struct test9_type*)inst).len); |
| if ((*(struct test9_type*)inst).cap == 64 && (*(struct test9_type*)inst).len == 64) { |
| for (int i=0; i<64; i++) { |
| ASSERT_EQ(8, ((*(struct test9_type*)inst).buf[i]).cap); |
| ASSERT_EQ(8, ((*(struct test9_type*)inst).buf[i]).len); |
| if ( ((*(struct test9_type*)inst).buf[i]).cap == 8 && ((*(struct test9_type*)inst).buf[i]).len == 8 ) { |
| for (int j=0; j<8; j++) { |
| ASSERT_EQ(j*1.234f, ((*(struct test9_type*)inst).buf[i]).buf[j]); |
| } |
| } |
| } |
| } |
| rc = avrobinSerializer_generateSchema(type, &schema); |
| ASSERT_EQ(0, rc); |
| if (rc == 0) { |
| printf("%s\n", schema); |
| rc = avrobinSerializer_saveFile("test9.avro", schema, serdata, serdatalen); |
| ASSERT_EQ(0, rc); |
| free(schema); |
| } |
| dynType_free(type, inst); |
| } |
| free(serdata); |
| } |
| dynType_destroy(type); |
| } |
| |
| for (int i=0; i<64; i++) { |
| free((test9_val.buf[i]).buf); |
| } |
| free(test9_val.buf); |
| |
| int32_t *test10_val = (int32_t*)malloc(sizeof(int32_t)); |
| *test10_val = 8765; |
| |
| type = NULL; |
| inst = NULL; |
| serdata = NULL; |
| serdatalen = 0; |
| schema = NULL; |
| rc = dynType_parseWithStr(test10_descriptor, "test10", NULL, &type); |
| ASSERT_EQ(0, rc); |
| if (rc == 0) { |
| rc = avrobinSerializer_serialize(type, &test10_val, &serdata, &serdatalen); |
| ASSERT_EQ(0, rc); |
| if (rc == 0) { |
| rc = avrobinSerializer_deserialize(type, serdata, serdatalen, &inst); |
| ASSERT_EQ(0, rc); |
| if (rc == 0) { |
| ASSERT_EQ(8765,*(*(int32_t**)inst)); |
| rc = avrobinSerializer_generateSchema(type, &schema); |
| ASSERT_EQ(0, rc); |
| if (rc == 0) { |
| printf("%s\n", schema); |
| rc = avrobinSerializer_saveFile("test10.avro", schema, serdata, serdatalen); |
| ASSERT_EQ(0, rc); |
| free(schema); |
| } |
| dynType_free(type, inst); |
| } |
| free(serdata); |
| } |
| dynType_destroy(type); |
| } |
| |
| free(test10_val); |
| |
| struct test11_type test11_val; |
| test11_val.c = (struct test11_subtype *)malloc(sizeof(struct test11_subtype)); |
| test11_val.c->a = 1.234; |
| test11_val.c->b = 2.345; |
| |
| type = NULL; |
| inst = NULL; |
| serdata = NULL; |
| serdatalen = 0; |
| schema = NULL; |
| rc = dynType_parseWithStr(test11_descriptor, "test11", NULL, &type); |
| ASSERT_EQ(0, rc); |
| if (rc == 0) { |
| rc = avrobinSerializer_serialize(type, &test11_val, &serdata, &serdatalen); |
| ASSERT_EQ(0, rc); |
| if (rc == 0) { |
| rc = avrobinSerializer_deserialize(type, serdata, serdatalen, &inst); |
| ASSERT_EQ(0, rc); |
| if (rc == 0) { |
| ASSERT_EQ(1.234,(*(struct test11_type *)inst).c->a); |
| ASSERT_EQ(2.345,(*(struct test11_type *)inst).c->b); |
| rc = avrobinSerializer_generateSchema(type, &schema); |
| ASSERT_EQ(0, rc); |
| if (rc == 0) { |
| printf("%s\n", schema); |
| rc = avrobinSerializer_saveFile("test11.avro", schema, serdata, serdatalen); |
| ASSERT_EQ(0, rc); |
| free(schema); |
| } |
| dynType_free(type, inst); |
| } |
| free(serdata); |
| } |
| dynType_destroy(type); |
| } |
| |
| free(test11_val.c); |
| |
| enum test12_enum test12_val = TEST12_ENUM_NOK; |
| |
| type = NULL; |
| inst = NULL; |
| serdata = NULL; |
| serdatalen = 0; |
| schema = NULL; |
| rc = dynType_parseWithStr(test12_descriptor, "test12", NULL, &type); |
| ASSERT_EQ(0, rc); |
| if (rc == 0) { |
| rc = avrobinSerializer_serialize(type, &test12_val, &serdata, &serdatalen); |
| ASSERT_EQ(0, rc); |
| if (rc == 0) { |
| rc = avrobinSerializer_deserialize(type, serdata, serdatalen, &inst); |
| ASSERT_EQ(0, rc); |
| if (rc == 0) { |
| ASSERT_EQ(TEST12_ENUM_NOK,*(enum test12_enum*)inst); |
| rc = avrobinSerializer_generateSchema(type, &schema); |
| ASSERT_EQ(0, rc); |
| if (rc == 0) { |
| printf("%s\n", schema); |
| rc = avrobinSerializer_saveFile("test12.avro", schema, serdata, serdatalen); |
| ASSERT_EQ(0, rc); |
| free(schema); |
| } |
| dynType_free(type, inst); |
| } |
| free(serdata); |
| } |
| dynType_destroy(type); |
| } |
| } |
| |
| } |
| |
| |
| class AvrobinSerializerTests : public ::testing::Test { |
| public: |
| AvrobinSerializerTests() { |
| int lvl = 1; |
| avrobinSerializer_logSetup(stdLog, NULL, lvl); |
| } |
| ~AvrobinSerializerTests() override { |
| } |
| |
| }; |
| |
| TEST_F(AvrobinSerializerTests, GeneralTests) { |
| generalTests(); |
| } |
