test/core/census/tag_set_test.c

/*
 *
 * 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);
}

#define BUF_SIZE 200

// test encode/decode.
static void encode_decode_test(void) {
  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;
}