diff options
author | 2016-01-22 15:34:34 -0800 | |
---|---|---|
committer | 2016-01-22 15:34:34 -0800 | |
commit | fc65bf07e60cd17144bcfbd156a47467b609b1e9 (patch) | |
tree | 5cbf556c7b1c670354018bbb7b4f0bf676059f58 /test | |
parent | 92b200ebf5940e2c101244e9e58e2a337b32eab0 (diff) | |
parent | ff14b44154b4667e666531763898e503f9f00bfd (diff) |
Merge pull request #4750 from a-veitch/tag_set
Census Tag Set API and implementation
Diffstat (limited to 'test')
-rw-r--r-- | test/core/census/tag_set_test.c | 374 |
1 files changed, 374 insertions, 0 deletions
diff --git a/test/core/census/tag_set_test.c b/test/core/census/tag_set_test.c new file mode 100644 index 0000000000..8e09e6c1c6 --- /dev/null +++ b/test/core/census/tag_set_test.c @@ -0,0 +1,374 @@ +/* + * + * 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_tag_set 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 tag_set 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 tag_set. 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 tag set. +static bool validate_tag(const census_tag_set *cts, const census_tag *tag) { + census_tag tag2; + if (census_tag_set_get_tag_by_key(cts, tag->key, &tag2) != 1) return false; + return compare_tag(tag, &tag2); +} + +// Create an empty tag_set. +static void empty_test(void) { + struct census_tag_set *cts = census_tag_set_create(NULL, NULL, 0, NULL); + GPR_ASSERT(cts != NULL); + const census_tag_set_create_status *status = + census_tag_set_get_create_status(cts); + census_tag_set_create_status expected = {0, 0, 0, 0, 0, 0, 0, 0}; + GPR_ASSERT(memcmp(status, &expected, sizeof(expected)) == 0); + census_tag_set_destroy(cts); +} + +// Test create and iteration over basic tag set. +static void basic_test(void) { + const census_tag_set_create_status *status; + struct census_tag_set *cts = + census_tag_set_create(NULL, basic_tags, BASIC_TAG_COUNT, &status); + census_tag_set_create_status expected = {2, 2, 4, 0, 8, 0, 0, 0}; + GPR_ASSERT(memcmp(status, &expected, sizeof(expected)) == 0); + census_tag_set_iterator it; + census_tag_set_initialize_iterator(cts, &it); + census_tag tag; + while (census_tag_set_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_tag_set_destroy(cts); +} + +// Test that census_tag_set_get_tag_by_key(). +static void lookup_by_key_test(void) { + struct census_tag_set *cts = + census_tag_set_create(NULL, basic_tags, BASIC_TAG_COUNT, NULL); + census_tag tag; + for (int i = 0; i < BASIC_TAG_COUNT; i++) { + GPR_ASSERT(census_tag_set_get_tag_by_key(cts, basic_tags[i].key, &tag) == + 1); + GPR_ASSERT(compare_tag(&tag, &basic_tags[i])); + } + // non-existent keys + GPR_ASSERT(census_tag_set_get_tag_by_key(cts, "key", &tag) == 0); + GPR_ASSERT(census_tag_set_get_tag_by_key(cts, "key01", &tag) == 0); + GPR_ASSERT(census_tag_set_get_tag_by_key(cts, "k9", &tag) == 0); + GPR_ASSERT(census_tag_set_get_tag_by_key(cts, "random", &tag) == 0); + GPR_ASSERT(census_tag_set_get_tag_by_key(cts, "", &tag) == 0); + census_tag_set_destroy(cts); +} + +// Try creating tag set 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_tag_set_create_status *status; + struct census_tag_set *cts = census_tag_set_create(NULL, &tag, 1, &status); + census_tag_set_create_status expected = {0, 0, 0, 0, 0, 0, 1, 0}; + GPR_ASSERT(memcmp(status, &expected, sizeof(expected)) == 0); + census_tag_set_destroy(cts); + key[CENSUS_MAX_TAG_KV_LEN] = 0; + GPR_ASSERT(strlen(key) == CENSUS_MAX_TAG_KV_LEN); + cts = census_tag_set_create(NULL, &tag, 1, &status); + GPR_ASSERT(memcmp(status, &expected, sizeof(expected)) == 0); + census_tag_set_destroy(cts); + key[CENSUS_MAX_TAG_KV_LEN - 1] = 0; + GPR_ASSERT(strlen(key) == CENSUS_MAX_TAG_KV_LEN - 1); + cts = census_tag_set_create(NULL, &tag, 1, &status); + census_tag_set_create_status expected2 = {0, 0, 1, 0, 1, 0, 0, 0}; + GPR_ASSERT(memcmp(status, &expected2, sizeof(expected2)) == 0); + census_tag_set_destroy(cts); + // now try with long values + tag.value_len = 300; + cts = census_tag_set_create(NULL, &tag, 1, &status); + GPR_ASSERT(memcmp(status, &expected, sizeof(expected)) == 0); + census_tag_set_destroy(cts); + tag.value_len = CENSUS_MAX_TAG_KV_LEN + 1; + cts = census_tag_set_create(NULL, &tag, 1, &status); + GPR_ASSERT(memcmp(status, &expected, sizeof(expected)) == 0); + census_tag_set_destroy(cts); + tag.value_len = CENSUS_MAX_TAG_KV_LEN; + cts = census_tag_set_create(NULL, &tag, 1, &status); + GPR_ASSERT(memcmp(status, &expected2, sizeof(expected2)) == 0); + census_tag_set_destroy(cts); + // 0 length key. + key[0] = 0; + cts = census_tag_set_create(NULL, &tag, 1, &status); + GPR_ASSERT(memcmp(status, &expected, sizeof(expected)) == 0); + census_tag_set_destroy(cts); +} + +// Make a copy of a tag set +static void copy_test(void) { + struct census_tag_set *cts = + census_tag_set_create(NULL, basic_tags, BASIC_TAG_COUNT, NULL); + const census_tag_set_create_status *status; + struct census_tag_set *cts2 = census_tag_set_create(cts, NULL, 0, &status); + census_tag_set_create_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_tag_set_get_tag_by_key(cts2, basic_tags[i].key, &tag) == + 1); + GPR_ASSERT(compare_tag(&tag, &basic_tags[i])); + } + census_tag_set_destroy(cts); + census_tag_set_destroy(cts2); +} + +// replace a single tag value +static void replace_value_test(void) { + struct census_tag_set *cts = + census_tag_set_create(NULL, basic_tags, BASIC_TAG_COUNT, NULL); + const census_tag_set_create_status *status; + struct census_tag_set *cts2 = census_tag_set_create( + cts, modify_tags + REPLACE_VALUE_OFFSET, 1, &status); + census_tag_set_create_status expected = {2, 2, 4, 0, 0, 1, 0, 0}; + GPR_ASSERT(memcmp(status, &expected, sizeof(expected)) == 0); + census_tag tag; + GPR_ASSERT(census_tag_set_get_tag_by_key( + cts2, modify_tags[REPLACE_VALUE_OFFSET].key, &tag) == 1); + GPR_ASSERT(compare_tag(&tag, &modify_tags[REPLACE_VALUE_OFFSET])); + census_tag_set_destroy(cts); + census_tag_set_destroy(cts2); +} + +// replace a single tags flags +static void replace_flags_test(void) { + struct census_tag_set *cts = + census_tag_set_create(NULL, basic_tags, BASIC_TAG_COUNT, NULL); + const census_tag_set_create_status *status; + struct census_tag_set *cts2 = + census_tag_set_create(cts, modify_tags + REPLACE_FLAG_OFFSET, 1, &status); + census_tag_set_create_status expected = {1, 2, 5, 0, 0, 1, 0, 0}; + GPR_ASSERT(memcmp(status, &expected, sizeof(expected)) == 0); + census_tag tag; + GPR_ASSERT(census_tag_set_get_tag_by_key( + cts2, modify_tags[REPLACE_FLAG_OFFSET].key, &tag) == 1); + GPR_ASSERT(compare_tag(&tag, &modify_tags[REPLACE_FLAG_OFFSET])); + census_tag_set_destroy(cts); + census_tag_set_destroy(cts2); +} + +// delete a single tag. +static void delete_tag_test(void) { + struct census_tag_set *cts = + census_tag_set_create(NULL, basic_tags, BASIC_TAG_COUNT, NULL); + const census_tag_set_create_status *status; + struct census_tag_set *cts2 = + census_tag_set_create(cts, modify_tags + DELETE_TAG_OFFSET, 1, &status); + census_tag_set_create_status expected = {2, 1, 4, 1, 0, 0, 0, 0}; + GPR_ASSERT(memcmp(status, &expected, sizeof(expected)) == 0); + census_tag tag; + GPR_ASSERT(census_tag_set_get_tag_by_key( + cts2, modify_tags[DELETE_TAG_OFFSET].key, &tag) == 0); + census_tag_set_destroy(cts); + census_tag_set_destroy(cts2); +} + +// add a single new tag. +static void add_tag_test(void) { + struct census_tag_set *cts = + census_tag_set_create(NULL, basic_tags, BASIC_TAG_COUNT, NULL); + const census_tag_set_create_status *status; + struct census_tag_set *cts2 = + census_tag_set_create(cts, modify_tags + ADD_TAG_OFFSET, 1, &status); + census_tag_set_create_status expected = {2, 2, 5, 0, 1, 0, 0, 0}; + GPR_ASSERT(memcmp(status, &expected, sizeof(expected)) == 0); + census_tag tag; + GPR_ASSERT(census_tag_set_get_tag_by_key( + cts2, modify_tags[ADD_TAG_OFFSET].key, &tag) == 1); + GPR_ASSERT(compare_tag(&tag, &modify_tags[ADD_TAG_OFFSET])); + census_tag_set_destroy(cts); + census_tag_set_destroy(cts2); +} + +// test many changes at once. +static void replace_add_delete_test(void) { + struct census_tag_set *cts = + census_tag_set_create(NULL, basic_tags, BASIC_TAG_COUNT, NULL); + const census_tag_set_create_status *status; + struct census_tag_set *cts2 = + census_tag_set_create(cts, modify_tags, MODIFY_TAG_COUNT, &status); + census_tag_set_create_status expected = {2, 1, 6, 2, 3, 4, 0, 2}; + GPR_ASSERT(memcmp(status, &expected, sizeof(expected)) == 0); + // validate tag set contents. Use specific indices into the two arrays + // holding tag values. + GPR_ASSERT(validate_tag(cts2, &basic_tags[3])); + GPR_ASSERT(validate_tag(cts2, &basic_tags[4])); + GPR_ASSERT(validate_tag(cts2, &modify_tags[0])); + GPR_ASSERT(validate_tag(cts2, &modify_tags[1])); + GPR_ASSERT(validate_tag(cts2, &modify_tags[6])); + GPR_ASSERT(validate_tag(cts2, &modify_tags[7])); + GPR_ASSERT(validate_tag(cts2, &modify_tags[8])); + GPR_ASSERT(validate_tag(cts2, &modify_tags[9])); + GPR_ASSERT(validate_tag(cts2, &modify_tags[10])); + GPR_ASSERT(!validate_tag(cts2, &basic_tags[0])); + GPR_ASSERT(!validate_tag(cts2, &basic_tags[1])); + GPR_ASSERT(!validate_tag(cts2, &basic_tags[2])); + GPR_ASSERT(!validate_tag(cts2, &basic_tags[5])); + GPR_ASSERT(!validate_tag(cts2, &basic_tags[6])); + GPR_ASSERT(!validate_tag(cts2, &basic_tags[7])); + census_tag_set_destroy(cts); + census_tag_set_destroy(cts2); +} + +// test encode/decode. +static void encode_decode_test(void) { + const size_t BUF_SIZE = 200; + char buffer[BUF_SIZE]; + struct census_tag_set *cts = + census_tag_set_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_tag_set_encode(cts, buffer, 2, &print_bsize, &bin_bsize) == + NULL); + char *b_buffer = + census_tag_set_encode(cts, 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_tag_set *cts2 = + census_tag_set_decode(buffer, print_bsize, b_buffer, bin_bsize); + GPR_ASSERT(cts2 != NULL); + const census_tag_set_create_status *status = + census_tag_set_get_create_status(cts2); + census_tag_set_create_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_tag_set_get_tag_by_key(cts2, basic_tags[i].key, &tag) == + 1); + GPR_ASSERT(compare_tag(&tag, &basic_tags[i])); + } else { + GPR_ASSERT(census_tag_set_get_tag_by_key(cts2, basic_tags[i].key, &tag) == + 0); + } + } + census_tag_set_destroy(cts2); + census_tag_set_destroy(cts); +} + +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; +} |