static char* test_scaling_equivalence() { load_histograms(); mu_assert( "Averages should be equivalent", compare_values( hdr_mean(cor_histogram) * 512, hdr_mean(scaled_cor_histogram), 0.000001)); mu_assert( "Total count should be equivalent", compare_int64( cor_histogram->total_count, scaled_cor_histogram->total_count)); int64_t expected_99th = hdr_value_at_percentile(cor_histogram, 99.0) * 512; int64_t scaled_99th = hdr_value_at_percentile(scaled_cor_histogram, 99.0); mu_assert( "99%'iles should be equivalent", compare_int64( hdr_lowest_equivalent_value(cor_histogram, expected_99th), hdr_lowest_equivalent_value(scaled_cor_histogram, scaled_99th))); mu_assert( "Max should be equivalent", compare_int64(hdr_max(cor_histogram) * 512, hdr_max(scaled_cor_histogram))); return 0; }
static char* test_encode_and_decode() { load_histograms(); size_t raw_histogram_size = hdr_get_memory_size(cor_histogram); uint8_t* buffer = (uint8_t*) malloc(hdr_get_memory_size(cor_histogram)); size_t encode_result = hdr_encode(cor_histogram, buffer, raw_histogram_size); mu_assert("Did not encode", encode_result != 0); mu_assert("Incorrect size", encode_result <= raw_histogram_size); struct hdr_histogram* loaded_histogram = NULL; hdr_decode(buffer, raw_histogram_size, &loaded_histogram); int compare_result = memcmp(cor_histogram, loaded_histogram, raw_histogram_size); if (compare_result != 0) { uint8_t* a = (uint8_t*) cor_histogram; uint8_t* b = (uint8_t*) loaded_histogram; for (int i = 0; i < raw_histogram_size; i++) { if (a[i] != b[i]) { printf("Mismatch at %d: %x - %x\n", i, a[i] & 0xFF, b[i] & 0xFF); } } } mu_assert("Comparison did not match", compare_result == 0); return 0; }
static char* test_encode_and_decode_compressed() { load_histograms(); size_t raw_histogram_size = hdr_get_memory_size(raw_histogram); uint8_t* buffer = (uint8_t*) malloc(hdr_get_memory_size(raw_histogram)); size_t encode_result = hdr_encode_compressed(raw_histogram, buffer, raw_histogram_size); mu_assert("Did not encode", encode_result == 0); int32_t compressed_length = hdr_get_compressed_length(buffer); struct hdr_histogram* loaded_histogram = NULL; int decode_result = hdr_decode_compressed(buffer, compressed_length, &loaded_histogram); if (decode_result != 0) { printf("%s\n", hdr_strerror(decode_result)); } mu_assert("Did not decode", decode_result == 0); mu_assert("Loaded histogram is null", loaded_histogram != NULL); int compare_result = memcmp(raw_histogram, loaded_histogram, raw_histogram_size); mu_assert("Comparison did not match", compare_result == 0); return 0; }
static char* test_encode_and_decode_compressed2() { load_histograms(); uint8_t* buffer = NULL; size_t len = 0; int rc = 0; struct hdr_histogram* actual = NULL; struct hdr_histogram* expected = cor_histogram; rc = hdr_encode_compressed(expected, &buffer, &len); mu_assert("Did not encode", validate_return_code(rc)); rc = hdr_decode_compressed(buffer, len, &actual); mu_assert("Did not decode", validate_return_code(rc)); mu_assert("Loaded histogram is null", actual != NULL); mu_assert( "Comparison did not match", compare_histogram(expected, actual)); free(actual); return 0; }
static char* test_percentiles() { load_histograms(); mu_assert("Value at 30% not 1000.0", compare_percentile(hdr_value_at_percentile(raw_histogram, 30.0), 1000.0, 0.001)); mu_assert("Value at 99% not 1000.0", compare_percentile(hdr_value_at_percentile(raw_histogram, 99.0), 1000.0, 0.001)); mu_assert("Value at 99.99% not 1000.0", compare_percentile(hdr_value_at_percentile(raw_histogram, 99.99), 1000.0, 0.001)); mu_assert("Value at 99.999% not 100000000.0", compare_percentile(hdr_value_at_percentile(raw_histogram, 99.999), 100000000.0, 0.001)); mu_assert("Value at 100% not 100000000.0", compare_percentile(hdr_value_at_percentile(raw_histogram, 100.0), 100000000.0, 0.001)); mu_assert("Value at 30% not 1000.0", compare_percentile(hdr_value_at_percentile(cor_histogram, 30.0), 1000.0, 0.001)); mu_assert("Value at 50% not 1000.0", compare_percentile(hdr_value_at_percentile(cor_histogram, 50.0), 1000.0, 0.001)); mu_assert("Value at 75% not 50000000.0", compare_percentile(hdr_value_at_percentile(cor_histogram, 75.0), 50000000.0, 0.001)); mu_assert("Value at 90% not 80000000.0", compare_percentile(hdr_value_at_percentile(cor_histogram, 90.0), 80000000.0, 0.001)); mu_assert("Value at 99% not 98000000.0", compare_percentile(hdr_value_at_percentile(cor_histogram, 99.0), 98000000.0, 0.001)); mu_assert("Value at 99.999% not 100000000.0", compare_percentile(hdr_value_at_percentile(cor_histogram, 99.999), 100000000.0, 0.001)); mu_assert("Value at 100% not 100000000.0", compare_percentile(hdr_value_at_percentile(cor_histogram, 100.0), 100000000.0, 0.001)); return 0; }
static char* test_encode_and_decode_base64() { load_histograms(); uint8_t* buffer = NULL; uint8_t* decoded = NULL; char* encoded = NULL; size_t len = 0; int rc = 0; rc = hdr_encode_compressed(cor_histogram, &buffer, &len); mu_assert("Did not encode", validate_return_code(rc)); size_t encoded_len = hdr_base64_encoded_len(len); size_t decoded_len = hdr_base64_decoded_len(encoded_len); encoded = calloc(encoded_len + 1, sizeof(char)); decoded = calloc(decoded_len, sizeof(uint8_t)); hdr_base64_encode(buffer, len, encoded, encoded_len); hdr_base64_decode(encoded, encoded_len, decoded, decoded_len); mu_assert("Should be same", memcmp(buffer, decoded, len) == 0); return 0; }
char* test_get_total_count() { load_histograms(); mu_assert("Total count is 10,001", compare_int64(10001, raw_histogram->values.total_count)); mu_assert("Total count is 20,000", compare_int64(20000, histogram->values.total_count)); return 0; }
char* test_get_max_value() { load_histograms(); mu_assert( "Max value is 100000000", hdr_dbl_values_are_equivalent(histogram, INT64_C(100) * 1000 * 1000, hdr_dbl_max(histogram))); return 0; }
char* test_get_min_value() { load_histograms(); mu_assert( "Min value is 1000", hdr_dbl_values_are_equivalent(histogram, INT64_C(1000), hdr_dbl_min(histogram))); return 0; }
static char* test_total_count() { load_histograms(); mu_assert("Total raw count != 10001", raw_histogram->total_count == 10001); mu_assert("Total corrected count != 20000", cor_histogram->total_count == 20000); return 0; }
static char* test_get_min_value() { load_histograms(); mu_assert("hdr_min(raw_histogram) != 1000", hdr_min(raw_histogram) == 1000L); mu_assert("hdr_min(cor_histogram) != 1000", hdr_min(cor_histogram) == 1000L); return 0; }
static char* test_linear_values() { load_histograms(); struct hdr_linear_iter iter; int index; // Raw Histogram hdr_linear_iter_init(&iter, raw_histogram, 100000); index = 0; while (hdr_linear_iter_next(&iter)) { int64_t count_added_in_this_bucket = iter.count_added_in_this_iteration_step; if (index == 0) { mu_assert("Count at 0 is not 10000", count_added_in_this_bucket == 10000); } else if (index == 999) { mu_assert("Count at 999 is not 1", count_added_in_this_bucket == 1); } else { mu_assert("Count should be 0", count_added_in_this_bucket == 0); } index++; } mu_assert("Should of met 1000 values", index == 1000); // Corrected Histogram hdr_linear_iter_init(&iter, cor_histogram, 10000); index = 0; int64_t total_added_count = 0; while (hdr_linear_iter_next(&iter)) { int64_t count_added_in_this_bucket = iter.count_added_in_this_iteration_step; if (index == 0) { mu_assert("Count at 0 is not 10001", count_added_in_this_bucket == 10001); } total_added_count += count_added_in_this_bucket; index++; } mu_assert("Should of met 10001 values", index == 10000); mu_assert("Should of met 20000 counts", total_added_count == 20000); return 0; }
static char* test_get_max_value() { load_histograms(); int64_t actual_raw_max = hdr_max(raw_histogram); mu_assert("hdr_max(raw_histogram) != 100000000L", hdr_values_are_equivalent(raw_histogram, actual_raw_max, 100000000L)); int64_t actual_cor_max = hdr_max(cor_histogram); mu_assert("hdr_max(cor_histogram) != 100000000L", hdr_values_are_equivalent(cor_histogram, actual_cor_max, 100000000L)); return 0; }
static char* test_logarithmic_values() { load_histograms(); struct hdr_log_iter iter; int index; hdr_log_iter_init(&iter, raw_histogram, 10000, 2.0); index = 0; while(hdr_log_iter_next(&iter)) { long count_added_in_this_bucket = iter.count_added_in_this_iteration_step; if (index == 0) { mu_assert("Raw Logarithmic 10 msec bucket # 0 added a count of 10000", 10000 == count_added_in_this_bucket); } else if (index == 14) { mu_assert("Raw Logarithmic 10 msec bucket # 14 added a count of 1", 1 == count_added_in_this_bucket); } else { mu_assert("Raw Logarithmic 10 msec bucket added a count of 0", 0 == count_added_in_this_bucket); } index++; } mu_assert("Should of seen 14 values", index - 1 == 14); hdr_log_iter_init(&iter, cor_histogram, 10000, 2.0); index = 0; int total_added_count = 0; while (hdr_log_iter_next(&iter)) { long count_added_in_this_bucket = iter.count_added_in_this_iteration_step; if (index == 0) { mu_assert("Corrected Logarithmic 10 msec bucket # 0 added a count of 10001", 10001 == count_added_in_this_bucket); } total_added_count += count_added_in_this_bucket; index++; } mu_assert("Should of seen 14 values", index - 1 == 14); mu_assert("Should of seen count of 20000", total_added_count == 20000); return 0; }
char *test_scaling_equivalence() { load_histograms(); mu_assert("total count should be the same", compare_int64(histogram->values.total_count, scaled_histogram->values.total_count)); mu_assert("averages should be equivalent", compare_double( hdr_dbl_mean(histogram) * 512, hdr_dbl_mean(scaled_histogram), hdr_dbl_mean(scaled_histogram) * 0.000001)); mu_assert("99%'iles should be equivalent", compare_double( hdr_dbl_highest_equivalent_value(scaled_histogram, hdr_dbl_value_at_percentile(histogram, 99.0)) * 512.0, hdr_dbl_highest_equivalent_value(scaled_histogram, hdr_dbl_value_at_percentile(scaled_histogram, 99.0)), hdr_dbl_highest_equivalent_value( scaled_histogram, hdr_dbl_value_at_percentile(scaled_histogram, 99.0)) * 0.000001)); mu_assert("Max should be equivalent", compare_double( hdr_dbl_highest_equivalent_value(scaled_histogram, hdr_dbl_max(histogram) * 512), hdr_dbl_max(scaled_histogram), hdr_dbl_max(scaled_histogram) * 0.000001)); mu_assert("total count should be the same", compare_int64( post_corrected_histogram->values.total_count, post_corrected_scaled_histogram->values.total_count)); mu_assert("99%'iles should be equivalent", compare_double( hdr_dbl_lowest_equivalent_value( post_corrected_histogram, hdr_dbl_value_at_percentile(post_corrected_histogram, 99.0)) * 512.0, hdr_dbl_lowest_equivalent_value( post_corrected_scaled_histogram, hdr_dbl_value_at_percentile(post_corrected_scaled_histogram, 99.0)), hdr_dbl_lowest_equivalent_value( post_corrected_scaled_histogram, hdr_dbl_value_at_percentile(post_corrected_scaled_histogram, 99.0)) * 0.000001)); mu_assert("Max should be equivalent", compare_double( hdr_dbl_highest_equivalent_value( post_corrected_scaled_histogram, hdr_dbl_max(post_corrected_histogram)) * 512, hdr_dbl_max(post_corrected_scaled_histogram), hdr_dbl_max(post_corrected_scaled_histogram))); return 0; }
static char* test_recorded_values() { load_histograms(); struct hdr_recorded_iter iter; int index; // Raw Histogram hdr_recorded_iter_init(&iter, raw_histogram); index = 0; while (hdr_recorded_iter_next(&iter)) { int64_t count_added_in_this_bucket = iter.count_added_in_this_iteration_step; if (index == 0) { mu_assert("Value at 0 is not 10000", count_added_in_this_bucket == 10000); } else { mu_assert("Value at 1 is not 1", count_added_in_this_bucket == 1); } index++; } mu_assert("Should have encountered 2 values", index == 2); // Corrected Histogram hdr_recorded_iter_init(&iter, cor_histogram); index = 0; int64_t total_added_count = 0; while (hdr_recorded_iter_next(&iter)) { int64_t count_added_in_this_bucket = iter.count_added_in_this_iteration_step; if (index == 0) { mu_assert("Count at 0 is not 10000", count_added_in_this_bucket == 10000); } mu_assert("Count should not be 0", iter.iter.count_at_index != 0); mu_assert("Count at value iterated to should be count added in this step", iter.iter.count_at_index == count_added_in_this_bucket); total_added_count += count_added_in_this_bucket; index++; } mu_assert("Total counts should be 20000", total_added_count == 20000); return 0; }
static char* test_bounds_check_on_decode() { load_histograms(); uint8_t* buffer = NULL; size_t len = 0; int rc = 0; struct hdr_histogram* actual = NULL; struct hdr_histogram* expected = cor_histogram; rc = hdr_encode_compressed(expected, &buffer, &len); mu_assert("Did not encode", validate_return_code(rc)); rc = hdr_decode_compressed(buffer, len - 1, &actual); mu_assert("Should have be invalid", compare_int64(EINVAL, rc)); mu_assert("Should not have built histogram", NULL == actual); return 0; }
static char* test_reset() { load_histograms(); // before mu_assert("Value at 99% == 0.0", hdr_value_at_percentile(raw_histogram, 99.0) != 0); mu_assert("Value at 99% == 0.0", hdr_value_at_percentile(cor_histogram, 99.0) != 0); hdr_reset(raw_histogram); hdr_reset(cor_histogram); //after mu_assert("Total raw count != 0", raw_histogram->total_count == 0); mu_assert("Total corrected count != 0", cor_histogram->total_count == 0); mu_assert("Value at 99% not 0.0", hdr_value_at_percentile(raw_histogram, 99.0) == 0); mu_assert("Value at 99% not 0.0", hdr_value_at_percentile(cor_histogram, 99.0) == 0); return 0; }