htrace-c/src/test/test.h

/**
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef APACHE_HTRACE_TEST_TEST_H
#define APACHE_HTRACE_TEST_TEST_H

#include <inttypes.h> /* for PRIdPTR */
#include <stdarg.h> /* for va_list */
#include <unistd.h> /* for size_t */

#define TEST_ERROR_EQ 0
#define TEST_ERROR_GE 1
#define TEST_ERROR_GT 2
#define TEST_ERROR_LE 3
#define TEST_ERROR_LT 4
#define TEST_ERROR_NE 5

/**
 * Fail with an error message.
 *
 * @param fmt       printf-style format string.
 * @param ...       printf-style arguments.
 */
void fail(const char *fmt, ...);

/**
 * Check for a test condition.
 *
 * @param expected  The string which is expected.
 * @param text      Some text that will be printed out if the test
 *                      condition fails.
 * @param ty        Comparison type.  See TEST_ERROR_* constants.
 * @param fmt       printf-style format string.
 * @param ap        printf-style arguments.
 *
 * @return      0 on success; 1 on failure.
 */
int vexpect(const char *expected, const char *text, int ty,
        const char *fmt, va_list ap);

/**
 * Check for a test condition.
 *
 * @param expected  The string which is expected.
 * @param text      Some text that will be printed out if the test
 *                      condition fails.
 * @param ty        Comparison type.  See TEST_ERROR_* constants.
 * @param fmt       printf-style format string.
 * @param ...       printf-style arguments.
 *
 * @return          0 on success; 1 on failure.
 */
int expect(const char *expected, const char *text, int ty,
        const char *fmt, ...) __attribute__((format(printf, 4, 5)));

/**
 * Allocate a zero-initialized region of memory, or die.
 *
 * @param len       The length
 *
 * @return          A pointer to a zero-initialized malloc'ed region.
 */
void *xcalloc(size_t len);

/**
 * Copy a string, or die.
 *
 * @param in        The string to copy
 *
 * @return          A dynamically allocated copy of the input string.
 */
char *xstrdup(const char *in);

/**
 * Dump a set of bytes to a buffer in hexadecimal form.
 *
 * @param in        The input.
 * @param buf_len   Length of the input buffer.
 * @param out       The buffer to dump to.
 * @param out_len   Length of the buffer to dump to.  If the output buffer is
 *                      not long enough, not all the output will be written.
 */
void hexdump(void *in, int in_len, char *buf, int buf_len);

#define TEST_ERROR_GET_LINE_HELPER2(x) #x
#define TEST_ERROR_GET_LINE_HELPER(x) TEST_ERROR_GET_LINE_HELPER2(x)
#define TEST_ERROR_LOCATION_TEXT __FILE__ " at line " \
    TEST_ERROR_GET_LINE_HELPER(__LINE__)

#define EXPECT(...) do { if (expect(__VA_ARGS__)) return 1; } while (0);

#define EXPECT_EQ(expected, fmt, ...) \
    EXPECT(expected, TEST_ERROR_LOCATION_TEXT, TEST_ERROR_EQ, \
           fmt, __VA_ARGS__);

#define EXPECT_STR_EQ(expected, str) \
    EXPECT_EQ(expected, "%s", str)

#define EXPECT_GE(expected, fmt, ...) \
    EXPECT(expected, TEST_ERROR_LOCATION_TEXT, TEST_ERROR_GE, \
           fmt, __VA_ARGS__);

#define EXPECT_GT(expected, fmt, ...) \
    EXPECT(expected, TEST_ERROR_LOCATION_TEXT, TEST_ERROR_GT, \
           fmt, __VA_ARGS__);

#define EXPECT_LE(expected, fmt, ...) \
    EXPECT(expected, TEST_ERROR_LOCATION_TEXT, TEST_ERROR_LE, \
           fmt, __VA_ARGS__);

#define EXPECT_LT(expected, fmt, ...) \
    EXPECT(expected, TEST_ERROR_LOCATION_TEXT, TEST_ERROR_LT, \
           fmt, __VA_ARGS__);

#define EXPECT_NE(expected, fmt, ...) \
    EXPECT(expected, TEST_ERROR_LOCATION_TEXT, TEST_ERROR_NE, \
           fmt, __VA_ARGS__);

#define COMMON_TEST__TO_STR(x) #x
#define COMMON_TEST__TO_STR2(x) COMMON_TEST__TO_STR(x)

#define EXPECT_INT_EQ(expected, x) do { \
  char expected_buf[16] = { 0 }; \
  snprintf(expected_buf, sizeof(expected_buf), "%d", expected); \
  EXPECT(expected_buf, TEST_ERROR_LOCATION_TEXT, TEST_ERROR_EQ, "%d", x); \
} while(0);

#define EXPECT_INT_GE(expected, x) do { \
  char expected_buf[16] = { 0 }; \
  snprintf(expected_buf, sizeof(expected_buf), "%d", expected); \
  EXPECT(expected_buf, TEST_ERROR_LOCATION_TEXT, TEST_ERROR_GE, "%d", x); \
} while(0);

#define EXPECT_INT_GT(expected, x) do { \
  char expected_buf[16] = { 0 }; \
  snprintf(expected_buf, sizeof(expected_buf), "%d", expected); \
  EXPECT(expected_buf, TEST_ERROR_LOCATION_TEXT, TEST_ERROR_GT, "%d", x); \
} while(0);

#define EXPECT_UINT64_EQ(expected, x) do { \
  char expected_buf[32] = { 0 }; \
  snprintf(expected_buf, sizeof(expected_buf), "%" PRIu64, expected); \
  EXPECT(expected_buf, TEST_ERROR_LOCATION_TEXT, TEST_ERROR_EQ, \
         "%" PRIu64, x); \
} while(0);

#define EXPECT_UINT64_GE(expected, x) do { \
  char expected_buf[32] = { 0 }; \
  snprintf(expected_buf, sizeof(expected_buf), "%" PRIu64, expected); \
  EXPECT(expected_buf, TEST_ERROR_LOCATION_TEXT, TEST_ERROR_GE, \
         "%" PRIu64, x); \
} while(0);

#define EXPECT_UINT64_GT(expected, x) do { \
  char expected_buf[32] = { 0 }; \
  snprintf(expected_buf, sizeof(expected_buf), "%" PRIu64, expected); \
  EXPECT(expected_buf, TEST_ERROR_LOCATION_TEXT, TEST_ERROR_GT, \
         "%" PRIu64, x); \
} while(0);

#define EXPECT_INT64_EQ(expected, x) do { \
  char expected_buf[32] = { 0 }; \
  snprintf(expected_buf, sizeof(expected_buf), "%" PRId64, expected); \
  EXPECT(expected_buf, TEST_ERROR_LOCATION_TEXT, TEST_ERROR_EQ, \
         "%" PRId64, x); \
} while(0);

#define EXPECT_UINTPTR_EQ(expected, x) do { \
  char expected_buf[32] = { 0 }; \
  snprintf(expected_buf, sizeof(expected_buf), "%" PRIuPTR, expected); \
  EXPECT(expected_buf, TEST_ERROR_LOCATION_TEXT, TEST_ERROR_EQ, \
         "%" PRIuPTR, x); \
} while(0);

#define EXPECT_INT_ZERO(x) \
    EXPECT("0", TEST_ERROR_LOCATION_TEXT, TEST_ERROR_EQ, \
           "%d", x);

#define EXPECT_TRUE(x) \
    EXPECT("1", TEST_ERROR_LOCATION_TEXT, TEST_ERROR_EQ, \
           "%d", (!!x));

#define EXPECT_FALSE(x) \
    EXPECT("0", TEST_ERROR_LOCATION_TEXT, TEST_ERROR_EQ, \
           "%d", (!!x));

#define EXPECT_NONNULL(x) \
    EXPECT("0", TEST_ERROR_LOCATION_TEXT, TEST_ERROR_NE, \
           "%"PRIuPTR, (uintptr_t)x);

#define EXPECT_NULL(x) \
    EXPECT("0", TEST_ERROR_LOCATION_TEXT, TEST_ERROR_EQ, \
           "%"PRIuPTR, (uintptr_t)x);
#endif

// vim: ts=4:sw=4:tw=79:et