aboutsummaryrefslogtreecommitdiffhomepage
diff options
context:
space:
mode:
Diffstat
-rw-r--r--include/grpc/census.h45
-rw-r--r--src/core/census/tag_set.c187
-rw-r--r--test/core/census/tag_set_test.c77
3 files changed, 167 insertions, 142 deletions
diff --git a/include/grpc/census.h b/include/grpc/census.h
index 2a62f4daca..1d7e65cdd9 100644
--- a/include/grpc/census.h
+++ b/include/grpc/census.h
@@ -354,8 +354,21 @@ typedef struct {
#define CENSUS_TAG_IS_STATS(flags) (flags & CENSUS_TAG_STATS)
#define CENSUS_TAG_IS_BINARY(flags) (flags & CENSUS_TAG_BINARY)
-#define CENSUS_MAX_TAG_KV_LEN 255 /* Maximum length of key/value in a tag. */
-#define CENSUS_MAX_TAGS 255 /* Maximum number of tags in a tag set. */
+/* Maximum length of key/value in a tag. */
+#define CENSUS_MAX_TAG_KV_LEN 255
+/* Maximum number of propagatable tags. */
+#define CENSUS_MAX_PROPAGATED_TAGS 255
+
+typedef struct {
+ int n_propagated_tags; /* number of propagated printable tags */
+ int n_propagated_binary_tags; /* number of propagated binary tags */
+ int n_local_tags; /* number of non-propagated (local) tags */
+ int n_deleted_tags; /* number of tags that were deleted */
+ int n_added_tags; /* number of tags that were added */
+ int n_modified_tags; /* number of tags that were modified */
+ int n_invalid_tags; /* number of tags with bad keys or values (e.g.
+ longer than CENSUS_MAX_TAG_KV_LEN) */
+} census_tag_set_create_stats;
/* Create a new tag set, adding and removing tags from an existing tag set.
@param base Base tag set to build upon. Can be NULL.
@@ -365,9 +378,12 @@ typedef struct {
both, but with NULL or zero-length values, will be deleted from the
tag set.
@param ntags number of tags in 'tags'
+ @param stats Information about the tag set created and actions taken during
+ its creation.
*/
census_tag_set *census_tag_set_create(const census_tag_set *base,
- const census_tag *tags, int ntags);
+ const census_tag *tags, int ntags,
+ census_tag_set_create_stats *stats);
/* Destroy a tag set created by census_tag_set_create(). Once this function
has been called, the tag set cannot be reused. */
@@ -376,10 +392,25 @@ void census_tag_set_destroy(census_tag_set *tags);
/* Get the number of tags in the tag set. */
int census_tag_set_ntags(const census_tag_set *tags);
-/* Get a tag by it's index in the tag set. Returns 0 if the index is invalid
- (<0 or >= census_tag_set_ntags). There is no guarantee on tag ordering. */
-int census_tag_set_get_tag_by_index(const census_tag_set *tags, int index,
- census_tag *tag);
+/* Structure used for tag set iteration. API clients should not use or
+ reference internal fields - neither their contents or presence/absence are
+ guaranteed. */
+typedef struct {
+ const census_tag_set *tags;
+ int base;
+ int index;
+ char *kvm;
+} census_tag_set_iterator;
+
+/* Initialize a tag set iterator. Must be called before first use of the
+ iterator. */
+void census_tag_set_initialize_iterator(const census_tag_set *tags,
+ census_tag_set_iterator *iterator);
+
+/* Get the contents of the "next" tag in the tag set. If there are no more
+ tags in the tag set, returns 0 (and 'tag' contents will be unchanged),
+ otherwise returns 1. */
+int census_tag_set_next_tag(census_tag_set_iterator *iterator, census_tag *tag);
/* Get a tag by its key. Returns 0 if the key is not present in the tag
set. */
diff --git a/src/core/census/tag_set.c b/src/core/census/tag_set.c
index e879ac0606..3b8efb1935 100644
--- a/src/core/census/tag_set.c
+++ b/src/core/census/tag_set.c
@@ -30,6 +30,13 @@
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
+/*
+- ability to add extra tags in encode?
+- add drops error count to create_ts
+- add mask to ntags?
+- comment about key/value ptrs being to mem
+- add comment about encode/decode being for RPC use only.
+*/
#include <grpc/census.h>
#include <grpc/support/alloc.h>
@@ -112,11 +119,14 @@ struct raw_tag {
// tag_set structs, one for each of the binary/printable propagated tags, and
// one for everything else.
struct census_tag_set {
- struct tag_set propagated_tags;
- struct tag_set propagated_binary_tags;
- struct tag_set local_tags;
+ struct tag_set tags[3];
};
+// Indices into the tags member of census_tag_set
+#define PROPAGATED_TAGS 0
+#define PROPAGATED_BINARY_TAGS 1
+#define LOCAL_TAGS 2
+
// Extract a raw tag given a pointer (raw) to the tag header. Allow for some
// extra bytes in the tag header (see encode/decode for usage: allows for
// future expansion of the tag header).
@@ -156,44 +166,19 @@ static bool tag_set_delete_tag(struct tag_set *tags, const char *key,
return false;
}
-// Delete a tag from a tag set.
-static void cts_delete_tag(census_tag_set *tags, const census_tag *tag,
+// Delete a tag from a tag set, return true if it existed.
+static bool cts_delete_tag(census_tag_set *tags, const census_tag *tag,
size_t key_len) {
- // use the to-be-deleted tag flags as a hint to determine the order in which
- // we delete from the underlying tag sets.
- if (CENSUS_TAG_IS_PROPAGATED(tag->flags)) {
- if (CENSUS_TAG_IS_BINARY(tag->flags)) {
- if (tag_set_delete_tag(&tags->propagated_binary_tags, tag->key,
- key_len)) {
- return;
- }
- if (tag_set_delete_tag(&tags->propagated_tags, tag->key, key_len)) return;
- tag_set_delete_tag(&tags->local_tags, tag->key, key_len);
- } else {
- if (tag_set_delete_tag(&tags->propagated_tags, tag->key, key_len)) {
- return;
- }
- if (tag_set_delete_tag(&tags->propagated_binary_tags, tag->key, key_len))
- return;
- tag_set_delete_tag(&tags->local_tags, tag->key, key_len);
- }
- } else {
- if (tag_set_delete_tag(&tags->local_tags, tag->key, key_len)) {
- return;
- }
- if (tag_set_delete_tag(&tags->propagated_tags, tag->key, key_len)) return;
- tag_set_delete_tag(&tags->propagated_binary_tags, tag->key, key_len);
- }
+ return (tag_set_delete_tag(&tags->tags[LOCAL_TAGS], tag->key, key_len) ||
+ tag_set_delete_tag(&tags->tags[PROPAGATED_TAGS], tag->key, key_len) ||
+ tag_set_delete_tag(&tags->tags[PROPAGATED_BINARY_TAGS], tag->key,
+ key_len));
}
// Add a tag to a tag set.
static void tag_set_add_tag(struct tag_set *tags, const census_tag *tag,
size_t key_len) {
const size_t tag_size = key_len + tag->value_len + TAG_HEADER_SIZE;
- // drop tag if too many.
- if (tags->ntags == CENSUS_MAX_TAGS) {
- return;
- }
if (tags->kvm_used + tag_size > tags->kvm_size) {
// allocate new memory if needed
tags->kvm_size += 2 * CENSUS_MAX_TAG_KV_LEN + TAG_HEADER_SIZE;
@@ -224,12 +209,12 @@ static void cts_add_tag(census_tag_set *tags, const census_tag *tag,
if (tag->value != NULL && tag->value_len != 0) {
if (CENSUS_TAG_IS_PROPAGATED(tag->flags)) {
if (CENSUS_TAG_IS_BINARY(tag->flags)) {
- tag_set_add_tag(&tags->propagated_binary_tags, tag, key_len);
+ tag_set_add_tag(&tags->tags[PROPAGATED_BINARY_TAGS], tag, key_len);
} else {
- tag_set_add_tag(&tags->propagated_tags, tag, key_len);
+ tag_set_add_tag(&tags->tags[PROPAGATED_TAGS], tag, key_len);
}
} else {
- tag_set_add_tag(&tags->local_tags, tag, key_len);
+ tag_set_add_tag(&tags->tags[LOCAL_TAGS], tag, key_len);
}
}
}
@@ -242,7 +227,7 @@ static void cts_add_tag(census_tag_set *tags, const census_tag *tag,
// 4) if we are still looking for a not-deleted tag, then all the end portion
// of the kvm is deleted. Just reduce the used amount of memory by the
// appropriate amount.
-static void tag_set_compress(struct tag_set *tags) {
+static void tag_set_flatten(struct tag_set *tags) {
if (tags->ntags == tags->ntags_alloc) return;
bool find_deleted = true; // are we looking for deleted tags?
char *kvp = tags->kvm;
@@ -277,15 +262,17 @@ static void tag_set_compress(struct tag_set *tags) {
}
census_tag_set *census_tag_set_create(const census_tag_set *base,
- const census_tag *tags, int ntags) {
+ const census_tag *tags, int ntags,
+ census_tag_set_create_stats *stats) {
+ int n_invalid_tags = 0;
census_tag_set *new_ts = gpr_malloc(sizeof(census_tag_set));
if (base == NULL) {
memset(new_ts, 0, sizeof(census_tag_set));
} else {
- tag_set_copy(&new_ts->propagated_tags, &base->propagated_tags);
- tag_set_copy(&new_ts->propagated_binary_tags,
- &base->propagated_binary_tags);
- tag_set_copy(&new_ts->local_tags, &base->local_tags);
+ tag_set_copy(&new_ts->tags[PROPAGATED_TAGS], &base->tags[PROPAGATED_TAGS]);
+ tag_set_copy(&new_ts->tags[PROPAGATED_BINARY_TAGS],
+ &base->tags[PROPAGATED_BINARY_TAGS]);
+ tag_set_copy(&new_ts->tags[LOCAL_TAGS], &base->tags[LOCAL_TAGS]);
}
for (int i = 0; i < ntags; i++) {
const census_tag *tag = &tags[i];
@@ -294,61 +281,81 @@ census_tag_set *census_tag_set_create(const census_tag_set *base,
if (key_len != 1 && key_len <= CENSUS_MAX_TAG_KV_LEN &&
tag->value_len <= CENSUS_MAX_TAG_KV_LEN) {
cts_add_tag(new_ts, tag, key_len);
+ } else {
+ n_invalid_tags++;
}
}
- tag_set_compress(&new_ts->propagated_tags);
- tag_set_compress(&new_ts->propagated_binary_tags);
- tag_set_compress(&new_ts->local_tags);
+ tag_set_flatten(&new_ts->tags[PROPAGATED_TAGS]);
+ tag_set_flatten(&new_ts->tags[PROPAGATED_BINARY_TAGS]);
+ tag_set_flatten(&new_ts->tags[LOCAL_TAGS]);
+ if (stats != NULL) {
+ stats->n_propagated_tags = new_ts->tags[PROPAGATED_TAGS].ntags;
+ stats->n_propagated_binary_tags =
+ new_ts->tags[PROPAGATED_BINARY_TAGS].ntags;
+ stats->n_local_tags = new_ts->tags[LOCAL_TAGS].ntags;
+ stats->n_invalid_tags = n_invalid_tags;
+ }
return new_ts;
}
void census_tag_set_destroy(census_tag_set *tags) {
- gpr_free(tags->propagated_tags.kvm);
- gpr_free(tags->propagated_binary_tags.kvm);
- gpr_free(tags->local_tags.kvm);
+ gpr_free(tags->tags[PROPAGATED_TAGS].kvm);
+ gpr_free(tags->tags[PROPAGATED_BINARY_TAGS].kvm);
+ gpr_free(tags->tags[LOCAL_TAGS].kvm);
gpr_free(tags);
}
int census_tag_set_ntags(const census_tag_set *tags) {
- return tags->propagated_tags.ntags + tags->propagated_binary_tags.ntags +
- tags->local_tags.ntags;
+ return tags->tags[PROPAGATED_TAGS].ntags +
+ tags->tags[PROPAGATED_BINARY_TAGS].ntags +
+ tags->tags[LOCAL_TAGS].ntags;
}
-// Get the nth tag in a tag set. The caller must validate that index is
-// in range.
-static void tag_set_get_tag_by_index(const struct tag_set *tags, int index,
- census_tag *tag) {
- GPR_ASSERT(index < tags->ntags);
- char *kvp = tags->kvm;
- struct raw_tag raw;
- kvp = decode_tag(&raw, kvp, 0);
- for (int i = 0; i < index; i++) {
- kvp = decode_tag(&raw, kvp, 0);
+/* Initialize a tag set iterator. Must be called before first use of the
+ iterator. */
+void census_tag_set_initialize_iterator(const census_tag_set *tags,
+ census_tag_set_iterator *iterator) {
+ iterator->tags = tags;
+ iterator->index = 0;
+ if (tags->tags[PROPAGATED_TAGS].ntags != 0) {
+ iterator->base = PROPAGATED_TAGS;
+ iterator->kvm = tags->tags[PROPAGATED_TAGS].kvm;
+ } else if (tags->tags[PROPAGATED_BINARY_TAGS].ntags != 0) {
+ iterator->base = PROPAGATED_BINARY_TAGS;
+ iterator->kvm = tags->tags[PROPAGATED_BINARY_TAGS].kvm;
+ } else if (tags->tags[LOCAL_TAGS].ntags != 0) {
+ iterator->base = LOCAL_TAGS;
+ iterator->kvm = tags->tags[LOCAL_TAGS].kvm;
+ } else {
+ iterator->base = -1;
+ }
+}
+
+/* Get the contents of the "next" tag in the tag set. If there are no more
+ tags in the tag set, returns 0 (and 'tag' contents will be unchanged),
+ otherwise returns 1. */
+int census_tag_set_next_tag(census_tag_set_iterator *iterator,
+ census_tag *tag) {
+ if (iterator->base < 0) {
+ return 0;
}
+ struct raw_tag raw;
+ iterator->kvm = decode_tag(&raw, iterator->kvm, 0);
tag->key = raw.key;
tag->value = raw.value;
tag->value_len = raw.value_len;
tag->flags = raw.flags;
-}
-
-int census_tag_set_get_tag_by_index(const census_tag_set *tags, int index,
- census_tag *tag) {
- if (index < 0) return 0;
- if (index < tags->propagated_tags.ntags) {
- tag_set_get_tag_by_index(&tags->propagated_tags, index, tag);
- return 1;
- }
- index -= tags->propagated_tags.ntags;
- if (index < tags->propagated_binary_tags.ntags) {
- tag_set_get_tag_by_index(&tags->propagated_binary_tags, index, tag);
- return 1;
- }
- index -= tags->propagated_binary_tags.ntags;
- if (index < tags->local_tags.ntags) {
- tag_set_get_tag_by_index(&tags->local_tags, index, tag);
- return 1;
+ if (++iterator->index == iterator->tags->tags[iterator->base].ntags) {
+ do {
+ if (iterator->base == LOCAL_TAGS) {
+ iterator->base = -1;
+ return 1;
+ }
+ } while (iterator->tags->tags[++iterator->base].ntags == 0);
+ iterator->index = 0;
+ iterator->kvm = iterator->tags->tags[iterator->base].kvm;
}
- return 0;
+ return 1;
}
// Find a tag in a tag_set by key. Return true if found, false otherwise.
@@ -375,10 +382,10 @@ int census_tag_set_get_tag_by_key(const census_tag_set *tags, const char *key,
if (key_len == 1) {
return 0;
}
- if (tag_set_get_tag_by_key(&tags->propagated_tags, key, key_len, tag) ||
- tag_set_get_tag_by_key(&tags->propagated_binary_tags, key, key_len,
+ if (tag_set_get_tag_by_key(&tags->tags[PROPAGATED_TAGS], key, key_len, tag) ||
+ tag_set_get_tag_by_key(&tags->tags[PROPAGATED_BINARY_TAGS], key, key_len,
tag) ||
- tag_set_get_tag_by_key(&tags->local_tags, key, key_len, tag)) {
+ tag_set_get_tag_by_key(&tags->tags[LOCAL_TAGS], key, key_len, tag)) {
return 1;
}
return 0;
@@ -422,12 +429,12 @@ static size_t tag_set_encode(const struct tag_set *tags, char *buffer,
size_t census_tag_set_encode_propagated(const census_tag_set *tags,
char *buffer, size_t buf_size) {
- return tag_set_encode(&tags->propagated_tags, buffer, buf_size);
+ return tag_set_encode(&tags->tags[PROPAGATED_TAGS], buffer, buf_size);
}
size_t census_tag_set_encode_propagated_binary(const census_tag_set *tags,
char *buffer, size_t buf_size) {
- return tag_set_encode(&tags->propagated_binary_tags, buffer, buf_size);
+ return tag_set_encode(&tags->tags[PROPAGATED_BINARY_TAGS], buffer, buf_size);
}
// Decode a tag set.
@@ -475,16 +482,16 @@ static void tag_set_decode(struct tag_set *tags, const char *buffer,
census_tag_set *census_tag_set_decode(const char *buffer, size_t size,
const char *bin_buffer, size_t bin_size) {
census_tag_set *new_ts = gpr_malloc(sizeof(census_tag_set));
- memset(&new_ts->local_tags, 0, sizeof(struct tag_set));
+ memset(&new_ts->tags[LOCAL_TAGS], 0, sizeof(struct tag_set));
if (buffer == NULL) {
- memset(&new_ts->propagated_tags, 0, sizeof(struct tag_set));
+ memset(&new_ts->tags[PROPAGATED_TAGS], 0, sizeof(struct tag_set));
} else {
- tag_set_decode(&new_ts->propagated_tags, buffer, size);
+ tag_set_decode(&new_ts->tags[PROPAGATED_TAGS], buffer, size);
}
if (bin_buffer == NULL) {
- memset(&new_ts->propagated_binary_tags, 0, sizeof(struct tag_set));
+ memset(&new_ts->tags[PROPAGATED_BINARY_TAGS], 0, sizeof(struct tag_set));
} else {
- tag_set_decode(&new_ts->propagated_binary_tags, bin_buffer, bin_size);
+ tag_set_decode(&new_ts->tags[PROPAGATED_BINARY_TAGS], bin_buffer, bin_size);
}
// TODO(aveitch): check that BINARY flag is correct for each type.
return new_ts;
diff --git a/test/core/census/tag_set_test.c b/test/core/census/tag_set_test.c
index 4c286b3e4f..140aa8117b 100644
--- a/test/core/census/tag_set_test.c
+++ b/test/core/census/tag_set_test.c
@@ -108,46 +108,34 @@ static bool validate_tag(const census_tag_set *cts, const census_tag *tag) {
// Create an empty tag_set.
static void empty_test(void) {
- struct census_tag_set *cts = census_tag_set_create(NULL, NULL, 0);
+ struct census_tag_set *cts = census_tag_set_create(NULL, NULL, 0, NULL);
GPR_ASSERT(census_tag_set_ntags(cts) == 0);
census_tag_set_destroy(cts);
}
-// Create basic tag set, and test that retreiving tag by index works.
+// Test create and iteration over basic tag set.
static void basic_test(void) {
struct census_tag_set *cts =
- census_tag_set_create(NULL, basic_tags, BASIC_TAG_COUNT);
+ census_tag_set_create(NULL, basic_tags, BASIC_TAG_COUNT, NULL);
GPR_ASSERT(census_tag_set_ntags(cts) == BASIC_TAG_COUNT);
- for (int i = 0; i < census_tag_set_ntags(cts); i++) {
- census_tag tag;
- GPR_ASSERT(census_tag_set_get_tag_by_index(cts, i, &tag) == 1);
+ 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 j = 0; j < BASIC_TAG_COUNT; j++) {
- if (compare_tag(&tag, &basic_tags[j])) matches++;
+ 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);
}
-// Try census_tag_set_get_tag_by_index() with bad indices.
-static void bad_index_test(void) {
- struct census_tag_set *cts =
- census_tag_set_create(NULL, basic_tags, BASIC_TAG_COUNT);
- GPR_ASSERT(census_tag_set_ntags(cts) == BASIC_TAG_COUNT);
- census_tag tag;
- GPR_ASSERT(census_tag_set_get_tag_by_index(cts, -1, &tag) == 0);
- GPR_ASSERT(census_tag_set_get_tag_by_index(cts, BASIC_TAG_COUNT, &tag) == 0);
- GPR_ASSERT(census_tag_set_get_tag_by_index(cts, BASIC_TAG_COUNT + 1, &tag) ==
- 0);
- 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);
+ census_tag_set_create(NULL, basic_tags, BASIC_TAG_COUNT, NULL);
GPR_ASSERT(census_tag_set_ntags(cts) == BASIC_TAG_COUNT);
census_tag tag;
for (int i = 0; i < census_tag_set_ntags(cts); i++) {
@@ -175,35 +163,35 @@ static void invalid_test(void) {
// long keys, short value. Key lengths (including terminator) should be
// <= 255 (CENSUS_MAX_TAG_KV_LEN)
GPR_ASSERT(strlen(key) == 299);
- struct census_tag_set *cts = census_tag_set_create(NULL, &tag, 1);
+ struct census_tag_set *cts = census_tag_set_create(NULL, &tag, 1, NULL);
GPR_ASSERT(census_tag_set_ntags(cts) == 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);
+ cts = census_tag_set_create(NULL, &tag, 1, NULL);
GPR_ASSERT(census_tag_set_ntags(cts) == 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);
+ cts = census_tag_set_create(NULL, &tag, 1, NULL);
GPR_ASSERT(census_tag_set_ntags(cts) == 1);
census_tag_set_destroy(cts);
// now try with long values
tag.value_len = 300;
- cts = census_tag_set_create(NULL, &tag, 1);
+ cts = census_tag_set_create(NULL, &tag, 1, NULL);
GPR_ASSERT(census_tag_set_ntags(cts) == 0);
census_tag_set_destroy(cts);
tag.value_len = CENSUS_MAX_TAG_KV_LEN + 1;
- cts = census_tag_set_create(NULL, &tag, 1);
+ cts = census_tag_set_create(NULL, &tag, 1, NULL);
GPR_ASSERT(census_tag_set_ntags(cts) == 0);
census_tag_set_destroy(cts);
tag.value_len = CENSUS_MAX_TAG_KV_LEN;
- cts = census_tag_set_create(NULL, &tag, 1);
+ cts = census_tag_set_create(NULL, &tag, 1, NULL);
GPR_ASSERT(census_tag_set_ntags(cts) == 1);
census_tag_set_destroy(cts);
// 0 length key.
key[0] = 0;
- cts = census_tag_set_create(NULL, &tag, 1);
+ cts = census_tag_set_create(NULL, &tag, 1, NULL);
GPR_ASSERT(census_tag_set_ntags(cts) == 0);
census_tag_set_destroy(cts);
}
@@ -211,9 +199,9 @@ static void invalid_test(void) {
// 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);
+ census_tag_set_create(NULL, basic_tags, BASIC_TAG_COUNT, NULL);
GPR_ASSERT(census_tag_set_ntags(cts) == BASIC_TAG_COUNT);
- struct census_tag_set *cts2 = census_tag_set_create(cts, NULL, 0);
+ struct census_tag_set *cts2 = census_tag_set_create(cts, NULL, 0, NULL);
GPR_ASSERT(census_tag_set_ntags(cts2) == BASIC_TAG_COUNT);
for (int i = 0; i < census_tag_set_ntags(cts2); i++) {
census_tag tag;
@@ -228,10 +216,10 @@ static void copy_test(void) {
// 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);
+ census_tag_set_create(NULL, basic_tags, BASIC_TAG_COUNT, NULL);
GPR_ASSERT(census_tag_set_ntags(cts) == BASIC_TAG_COUNT);
struct census_tag_set *cts2 =
- census_tag_set_create(cts, modify_tags + REPLACE_VALUE_OFFSET, 1);
+ census_tag_set_create(cts, modify_tags + REPLACE_VALUE_OFFSET, 1, NULL);
GPR_ASSERT(census_tag_set_ntags(cts2) == BASIC_TAG_COUNT);
census_tag tag;
GPR_ASSERT(census_tag_set_get_tag_by_key(
@@ -244,10 +232,10 @@ static void replace_value_test(void) {
// 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);
+ census_tag_set_create(NULL, basic_tags, BASIC_TAG_COUNT, NULL);
GPR_ASSERT(census_tag_set_ntags(cts) == BASIC_TAG_COUNT);
struct census_tag_set *cts2 =
- census_tag_set_create(cts, modify_tags + REPLACE_FLAG_OFFSET, 1);
+ census_tag_set_create(cts, modify_tags + REPLACE_FLAG_OFFSET, 1, NULL);
GPR_ASSERT(census_tag_set_ntags(cts2) == BASIC_TAG_COUNT);
census_tag tag;
GPR_ASSERT(census_tag_set_get_tag_by_key(
@@ -260,10 +248,10 @@ static void replace_flags_test(void) {
// 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);
+ census_tag_set_create(NULL, basic_tags, BASIC_TAG_COUNT, NULL);
GPR_ASSERT(census_tag_set_ntags(cts) == BASIC_TAG_COUNT);
struct census_tag_set *cts2 =
- census_tag_set_create(cts, modify_tags + DELETE_TAG_OFFSET, 1);
+ census_tag_set_create(cts, modify_tags + DELETE_TAG_OFFSET, 1, NULL);
GPR_ASSERT(census_tag_set_ntags(cts2) == BASIC_TAG_COUNT - 1);
census_tag tag;
GPR_ASSERT(census_tag_set_get_tag_by_key(
@@ -275,10 +263,10 @@ static void delete_tag_test(void) {
// 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);
+ census_tag_set_create(NULL, basic_tags, BASIC_TAG_COUNT, NULL);
GPR_ASSERT(census_tag_set_ntags(cts) == BASIC_TAG_COUNT);
struct census_tag_set *cts2 =
- census_tag_set_create(cts, modify_tags + ADD_TAG_OFFSET, 1);
+ census_tag_set_create(cts, modify_tags + ADD_TAG_OFFSET, 1, NULL);
GPR_ASSERT(census_tag_set_ntags(cts2) == BASIC_TAG_COUNT + 1);
census_tag tag;
GPR_ASSERT(census_tag_set_get_tag_by_key(
@@ -291,10 +279,10 @@ static void add_tag_test(void) {
// 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);
+ census_tag_set_create(NULL, basic_tags, BASIC_TAG_COUNT, NULL);
GPR_ASSERT(census_tag_set_ntags(cts) == BASIC_TAG_COUNT);
struct census_tag_set *cts2 =
- census_tag_set_create(cts, modify_tags, MODIFY_TAG_COUNT);
+ census_tag_set_create(cts, modify_tags, MODIFY_TAG_COUNT, NULL);
GPR_ASSERT(census_tag_set_ntags(cts2) == 8);
// validate tag set contents. Use specific indices into the two arrays
// holding tag values.
@@ -321,7 +309,7 @@ static void simple_encode_decode_test(void) {
char buf1[1000];
char buf2[1000];
struct census_tag_set *cts =
- census_tag_set_create(NULL, basic_tags, BASIC_TAG_COUNT);
+ census_tag_set_create(NULL, basic_tags, BASIC_TAG_COUNT, NULL);
GPR_ASSERT(census_tag_set_ntags(cts) == BASIC_TAG_COUNT);
GPR_ASSERT(census_tag_set_encode_propagated(cts, buf1, 1) == 0);
size_t b1 = census_tag_set_encode_propagated(cts, buf1, 1000);
@@ -352,10 +340,10 @@ static void complex_encode_decode_test(void) {
char buf1[500];
char buf2[500];
struct census_tag_set *cts =
- census_tag_set_create(NULL, basic_tags, BASIC_TAG_COUNT);
+ census_tag_set_create(NULL, basic_tags, BASIC_TAG_COUNT, NULL);
GPR_ASSERT(census_tag_set_ntags(cts) == BASIC_TAG_COUNT);
struct census_tag_set *cts2 =
- census_tag_set_create(cts, modify_tags, MODIFY_TAG_COUNT);
+ census_tag_set_create(cts, modify_tags, MODIFY_TAG_COUNT, NULL);
GPR_ASSERT(census_tag_set_ntags(cts2) == 8);
size_t b1 = census_tag_set_encode_propagated(cts2, buf1, 500);
@@ -376,7 +364,6 @@ int main(int argc, char *argv[]) {
grpc_test_init(argc, argv);
empty_test();
basic_test();
- bad_index_test();
lookup_by_key_test();
invalid_test();
copy_test();
generated by cgit v1.2.3 (git 2.39.1) at 2024-07-01 22:53:32 +0000