diff options
Diffstat (limited to 'test/core/census/context_test.c')
| -rw-r--r-- | test/core/census/context_test.c | 373 |
1 files changed, 373 insertions, 0 deletions
diff --git a/test/core/census/context_test.c b/test/core/census/context_test.c new file mode 100644 index 0000000000..63e7103ddc --- /dev/null +++ b/test/core/census/context_test.c @@ -0,0 +1,373 @@ +/* + * + * Copyright 2015-2016, Google Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ + +// Test census_context functions, including encoding/decoding + +#include <grpc/census.h> +#include <grpc/support/log.h> +#include <grpc/support/time.h> +#include <stdbool.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include "test/core/util/test_config.h" + +static uint8_t one_byte_val = 7; +static uint32_t four_byte_val = 0x12345678; +static uint64_t eight_byte_val = 0x1234567890abcdef; + +// A set of tags Used to create a basic context for testing. Each tag has a +// unique set of flags. Note that replace_add_delete_test() relies on specific +// offsets into this array - if you add or delete entries, you will also need +// to change the test. +#define BASIC_TAG_COUNT 8 +static census_tag basic_tags[BASIC_TAG_COUNT] = { + /* 0 */ {"key0", "printable", 10, 0}, + /* 1 */ {"k1", "a", 2, CENSUS_TAG_PROPAGATE}, + /* 2 */ {"k2", "longer printable string", 24, CENSUS_TAG_STATS}, + /* 3 */ {"key_three", (char *)&one_byte_val, 1, CENSUS_TAG_BINARY}, + /* 4 */ {"really_long_key_4", "random", 7, + CENSUS_TAG_PROPAGATE | CENSUS_TAG_STATS}, + /* 5 */ {"k5", (char *)&four_byte_val, 4, + CENSUS_TAG_PROPAGATE | CENSUS_TAG_BINARY}, + /* 6 */ {"k6", (char *)&eight_byte_val, 8, + CENSUS_TAG_STATS | CENSUS_TAG_BINARY}, + /* 7 */ {"k7", (char *)&four_byte_val, 4, + CENSUS_TAG_PROPAGATE | CENSUS_TAG_STATS | CENSUS_TAG_BINARY}}; + +// Set of tags used to modify the basic context. Note that +// replace_add_delete_test() relies on specific offsets into this array - if +// you add or delete entries, you will also need to change the test. Other +// tests that rely on specific instances have XXX_XXX_OFFSET definitions (also +// change the defines below if you add/delete entires). +#define MODIFY_TAG_COUNT 11 +static census_tag modify_tags[MODIFY_TAG_COUNT] = { +#define REPLACE_VALUE_OFFSET 0 + /* 0 */ {"key0", "replace printable", 18, 0}, // replaces tag value only +#define ADD_TAG_OFFSET 1 + /* 1 */ {"new_key", "xyzzy", 6, CENSUS_TAG_STATS}, // new tag +#define DELETE_TAG_OFFSET 2 + /* 2 */ {"k5", NULL, 5, + 0}, // should delete tag, despite bogus value length + /* 3 */ {"k6", "foo", 0, 0}, // should delete tag, despite bogus value + /* 4 */ {"k6", "foo", 0, 0}, // try deleting already-deleted tag + /* 5 */ {"non-existent", NULL, 0, 0}, // another non-existent tag +#define REPLACE_FLAG_OFFSET 6 + /* 6 */ {"k1", "a", 2, 0}, // change flags only + /* 7 */ {"k7", "bar", 4, CENSUS_TAG_STATS}, // change flags and value + /* 8 */ {"k2", (char *)&eight_byte_val, 8, + CENSUS_TAG_BINARY | CENSUS_TAG_PROPAGATE}, // more flags change + // non-binary -> binary + /* 9 */ {"k6", "bar", 4, 0}, // add back tag, with different value + /* 10 */ {"foo", "bar", 4, CENSUS_TAG_PROPAGATE}, // another new tag +}; + +// Utility function to compare tags. Returns true if all fields match. +static bool compare_tag(const census_tag *t1, const census_tag *t2) { + return (strcmp(t1->key, t2->key) == 0 && t1->value_len == t2->value_len && + memcmp(t1->value, t2->value, t1->value_len) == 0 && + t1->flags == t2->flags); +} + +// Utility function to validate a tag exists in context. +static bool validate_tag(const census_context *context, const census_tag *tag) { + census_tag tag2; + if (census_context_get_tag(context, tag->key, &tag2) != 1) return false; + return compare_tag(tag, &tag2); +} + +// Create an empty context. +static void empty_test(void) { + struct census_context *context = census_context_create(NULL, NULL, 0, NULL); + GPR_ASSERT(context != NULL); + const census_context_status *status = census_context_get_status(context); + census_context_status expected = {0, 0, 0, 0, 0, 0, 0, 0}; + GPR_ASSERT(memcmp(status, &expected, sizeof(expected)) == 0); + census_context_destroy(context); +} + +// Test create and iteration over basic context. +static void basic_test(void) { + const census_context_status *status; + struct census_context *context = + census_context_create(NULL, basic_tags, BASIC_TAG_COUNT, &status); + census_context_status expected = {2, 2, 4, 0, 8, 0, 0, 0}; + GPR_ASSERT(memcmp(status, &expected, sizeof(expected)) == 0); + census_context_iterator it; + census_context_initialize_iterator(context, &it); + census_tag tag; + while (census_context_next_tag(&it, &tag)) { + // can't rely on tag return order: make sure it matches exactly one. + int matches = 0; + for (int i = 0; i < BASIC_TAG_COUNT; i++) { + if (compare_tag(&tag, &basic_tags[i])) matches++; + } + GPR_ASSERT(matches == 1); + } + census_context_destroy(context); +} + +// Test census_context_get_tag(). +static void lookup_by_key_test(void) { + struct census_context *context = + census_context_create(NULL, basic_tags, BASIC_TAG_COUNT, NULL); + census_tag tag; + for (int i = 0; i < BASIC_TAG_COUNT; i++) { + GPR_ASSERT(census_context_get_tag(context, basic_tags[i].key, &tag) == 1); + GPR_ASSERT(compare_tag(&tag, &basic_tags[i])); + } + // non-existent keys + GPR_ASSERT(census_context_get_tag(context, "key", &tag) == 0); + GPR_ASSERT(census_context_get_tag(context, "key01", &tag) == 0); + GPR_ASSERT(census_context_get_tag(context, "k9", &tag) == 0); + GPR_ASSERT(census_context_get_tag(context, "random", &tag) == 0); + GPR_ASSERT(census_context_get_tag(context, "", &tag) == 0); + census_context_destroy(context); +} + +// Try creating context with invalid entries. +static void invalid_test(void) { + char key[300]; + memset(key, 'k', 299); + key[299] = 0; + char value[300]; + memset(value, 'v', 300); + census_tag tag = {key, value, 3, CENSUS_TAG_BINARY}; + // long keys, short value. Key lengths (including terminator) should be + // <= 255 (CENSUS_MAX_TAG_KV_LEN) + GPR_ASSERT(strlen(key) == 299); + const census_context_status *status; + struct census_context *context = + census_context_create(NULL, &tag, 1, &status); + census_context_status expected = {0, 0, 0, 0, 0, 0, 1, 0}; + GPR_ASSERT(memcmp(status, &expected, sizeof(expected)) == 0); + census_context_destroy(context); + key[CENSUS_MAX_TAG_KV_LEN] = 0; + GPR_ASSERT(strlen(key) == CENSUS_MAX_TAG_KV_LEN); + context = census_context_create(NULL, &tag, 1, &status); + GPR_ASSERT(memcmp(status, &expected, sizeof(expected)) == 0); + census_context_destroy(context); + key[CENSUS_MAX_TAG_KV_LEN - 1] = 0; + GPR_ASSERT(strlen(key) == CENSUS_MAX_TAG_KV_LEN - 1); + context = census_context_create(NULL, &tag, 1, &status); + census_context_status expected2 = {0, 0, 1, 0, 1, 0, 0, 0}; + GPR_ASSERT(memcmp(status, &expected2, sizeof(expected2)) == 0); + census_context_destroy(context); + // now try with long values + tag.value_len = 300; + context = census_context_create(NULL, &tag, 1, &status); + GPR_ASSERT(memcmp(status, &expected, sizeof(expected)) == 0); + census_context_destroy(context); + tag.value_len = CENSUS_MAX_TAG_KV_LEN + 1; + context = census_context_create(NULL, &tag, 1, &status); + GPR_ASSERT(memcmp(status, &expected, sizeof(expected)) == 0); + census_context_destroy(context); + tag.value_len = CENSUS_MAX_TAG_KV_LEN; + context = census_context_create(NULL, &tag, 1, &status); + GPR_ASSERT(memcmp(status, &expected2, sizeof(expected2)) == 0); + census_context_destroy(context); + // 0 length key. + key[0] = 0; + context = census_context_create(NULL, &tag, 1, &status); + GPR_ASSERT(memcmp(status, &expected, sizeof(expected)) == 0); + census_context_destroy(context); +} + +// Make a copy of a context +static void copy_test(void) { + struct census_context *context = + census_context_create(NULL, basic_tags, BASIC_TAG_COUNT, NULL); + const census_context_status *status; + struct census_context *context2 = + census_context_create(context, NULL, 0, &status); + census_context_status expected = {2, 2, 4, 0, 0, 0, 0, 0}; + GPR_ASSERT(memcmp(status, &expected, sizeof(expected)) == 0); + for (int i = 0; i < BASIC_TAG_COUNT; i++) { + census_tag tag; + GPR_ASSERT(census_context_get_tag(context2, basic_tags[i].key, &tag) == 1); + GPR_ASSERT(compare_tag(&tag, &basic_tags[i])); + } + census_context_destroy(context); + census_context_destroy(context2); +} + +// replace a single tag value +static void replace_value_test(void) { + struct census_context *context = + census_context_create(NULL, basic_tags, BASIC_TAG_COUNT, NULL); + const census_context_status *status; + struct census_context *context2 = census_context_create( + context, modify_tags + REPLACE_VALUE_OFFSET, 1, &status); + census_context_status expected = {2, 2, 4, 0, 0, 1, 0, 0}; + GPR_ASSERT(memcmp(status, &expected, sizeof(expected)) == 0); + census_tag tag; + GPR_ASSERT(census_context_get_tag( + context2, modify_tags[REPLACE_VALUE_OFFSET].key, &tag) == 1); + GPR_ASSERT(compare_tag(&tag, &modify_tags[REPLACE_VALUE_OFFSET])); + census_context_destroy(context); + census_context_destroy(context2); +} + +// replace a single tags flags +static void replace_flags_test(void) { + struct census_context *context = + census_context_create(NULL, basic_tags, BASIC_TAG_COUNT, NULL); + const census_context_status *status; + struct census_context *context2 = census_context_create( + context, modify_tags + REPLACE_FLAG_OFFSET, 1, &status); + census_context_status expected = {1, 2, 5, 0, 0, 1, 0, 0}; + GPR_ASSERT(memcmp(status, &expected, sizeof(expected)) == 0); + census_tag tag; + GPR_ASSERT(census_context_get_tag( + context2, modify_tags[REPLACE_FLAG_OFFSET].key, &tag) == 1); + GPR_ASSERT(compare_tag(&tag, &modify_tags[REPLACE_FLAG_OFFSET])); + census_context_destroy(context); + census_context_destroy(context2); +} + +// delete a single tag. +static void delete_tag_test(void) { + struct census_context *context = + census_context_create(NULL, basic_tags, BASIC_TAG_COUNT, NULL); + const census_context_status *status; + struct census_context *context2 = census_context_create( + context, modify_tags + DELETE_TAG_OFFSET, 1, &status); + census_context_status expected = {2, 1, 4, 1, 0, 0, 0, 0}; + GPR_ASSERT(memcmp(status, &expected, sizeof(expected)) == 0); + census_tag tag; + GPR_ASSERT(census_context_get_tag( + context2, modify_tags[DELETE_TAG_OFFSET].key, &tag) == 0); + census_context_destroy(context); + census_context_destroy(context2); +} + +// add a single new tag. +static void add_tag_test(void) { + struct census_context *context = + census_context_create(NULL, basic_tags, BASIC_TAG_COUNT, NULL); + const census_context_status *status; + struct census_context *context2 = + census_context_create(context, modify_tags + ADD_TAG_OFFSET, 1, &status); + census_context_status expected = {2, 2, 5, 0, 1, 0, 0, 0}; + GPR_ASSERT(memcmp(status, &expected, sizeof(expected)) == 0); + census_tag tag; + GPR_ASSERT(census_context_get_tag(context2, modify_tags[ADD_TAG_OFFSET].key, + &tag) == 1); + GPR_ASSERT(compare_tag(&tag, &modify_tags[ADD_TAG_OFFSET])); + census_context_destroy(context); + census_context_destroy(context2); +} + +// test many changes at once. +static void replace_add_delete_test(void) { + struct census_context *context = + census_context_create(NULL, basic_tags, BASIC_TAG_COUNT, NULL); + const census_context_status *status; + struct census_context *context2 = + census_context_create(context, modify_tags, MODIFY_TAG_COUNT, &status); + census_context_status expected = {2, 1, 6, 2, 3, 4, 0, 2}; + GPR_ASSERT(memcmp(status, &expected, sizeof(expected)) == 0); + // validate context contents. Use specific indices into the two arrays + // holding tag values. + GPR_ASSERT(validate_tag(context2, &basic_tags[3])); + GPR_ASSERT(validate_tag(context2, &basic_tags[4])); + GPR_ASSERT(validate_tag(context2, &modify_tags[0])); + GPR_ASSERT(validate_tag(context2, &modify_tags[1])); + GPR_ASSERT(validate_tag(context2, &modify_tags[6])); + GPR_ASSERT(validate_tag(context2, &modify_tags[7])); + GPR_ASSERT(validate_tag(context2, &modify_tags[8])); + GPR_ASSERT(validate_tag(context2, &modify_tags[9])); + GPR_ASSERT(validate_tag(context2, &modify_tags[10])); + GPR_ASSERT(!validate_tag(context2, &basic_tags[0])); + GPR_ASSERT(!validate_tag(context2, &basic_tags[1])); + GPR_ASSERT(!validate_tag(context2, &basic_tags[2])); + GPR_ASSERT(!validate_tag(context2, &basic_tags[5])); + GPR_ASSERT(!validate_tag(context2, &basic_tags[6])); + GPR_ASSERT(!validate_tag(context2, &basic_tags[7])); + census_context_destroy(context); + census_context_destroy(context2); +} + +#define BUF_SIZE 200 + +// test encode/decode. +static void encode_decode_test(void) { + char buffer[BUF_SIZE]; + struct census_context *context = + census_context_create(NULL, basic_tags, BASIC_TAG_COUNT, NULL); + size_t print_bsize; + size_t bin_bsize; + // Test with too small a buffer + GPR_ASSERT(census_context_encode(context, buffer, 2, &print_bsize, + &bin_bsize) == NULL); + char *b_buffer = census_context_encode(context, buffer, BUF_SIZE, + &print_bsize, &bin_bsize); + GPR_ASSERT(b_buffer != NULL && print_bsize > 0 && bin_bsize > 0 && + print_bsize + bin_bsize <= BUF_SIZE && + b_buffer == buffer + print_bsize); + census_context *context2 = + census_context_decode(buffer, print_bsize, b_buffer, bin_bsize); + GPR_ASSERT(context2 != NULL); + const census_context_status *status = census_context_get_status(context2); + census_context_status expected = {2, 2, 0, 0, 0, 0, 0, 0}; + GPR_ASSERT(memcmp(status, &expected, sizeof(expected)) == 0); + for (int i = 0; i < BASIC_TAG_COUNT; i++) { + census_tag tag; + if (CENSUS_TAG_IS_PROPAGATED(basic_tags[i].flags)) { + GPR_ASSERT(census_context_get_tag(context2, basic_tags[i].key, &tag) == + 1); + GPR_ASSERT(compare_tag(&tag, &basic_tags[i])); + } else { + GPR_ASSERT(census_context_get_tag(context2, basic_tags[i].key, &tag) == + 0); + } + } + census_context_destroy(context2); + census_context_destroy(context); +} + +int main(int argc, char *argv[]) { + grpc_test_init(argc, argv); + empty_test(); + basic_test(); + lookup_by_key_test(); + invalid_test(); + copy_test(); + replace_value_test(); + replace_flags_test(); + delete_tag_test(); + add_tag_test(); + replace_add_delete_test(); + encode_decode_test(); + return 0; +} |