/*
 * ====================================================================
 *    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 SVN_TEST_H
#define SVN_TEST_H

#ifndef SVN_ENABLE_DEPRECATION_WARNINGS_IN_TESTS
#undef SVN_DEPRECATED
#define SVN_DEPRECATED
#endif /* ! SVN_ENABLE_DEPRECATION_WARNINGS_IN_TESTS */

#include <stdio.h>

#include <apr_pools.h>

#include "svn_delta.h"
#include "svn_path.h"
#include "svn_types.h"
#include "svn_error.h"
#include "svn_string.h"
#include "svn_auth.h"
#include "svn_time.h"

#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */


/** Handy macro to test a condition, returning SVN_ERR_TEST_FAILED if FALSE
 *
 * This macro should be used in place of SVN_ERR_ASSERT() since we don't
 * want to core-dump the test.
 */
#define SVN_TEST_ASSERT(expr)                                     \
  do {                                                            \
    if (!(expr))                                                  \
      return svn_error_createf(SVN_ERR_TEST_FAILED, NULL,         \
                               "assertion '%s' failed at %s:%d",  \
                               #expr, __FILE__, __LINE__);        \
  } while (0)

/**
 * Macro for testing assumptions when the context does not allow
 * returning an svn_error_t*.
 *
 * Will write to stderr and cause a segfault if EXPR is false.
 */
#define SVN_TEST_ASSERT_NO_RETURN(expr)                           \
  do {                                                            \
    if (!(expr))                                                  \
      {                                                           \
        unsigned int z_e_r_o_p_a_g_e__;                           \
        fprintf(stderr, "TEST ASSERTION FAILED: %s\n", #expr);    \
        z_e_r_o_p_a_g_e__ = *(volatile unsigned int*)0;           \
        *(volatile unsigned int*)0 = z_e_r_o_p_a_g_e__;           \
      }                                                           \
  } while (0)

/** Handy macro for testing an expected svn_error_t return value.
 * EXPECTED must be a real error (neither SVN_NO_ERROR nor APR_SUCCESS).
 * The error returned by EXPR will be cleared.
 */
#define SVN_TEST_ASSERT_ERROR(expr, expected)                             \
  do {                                                                    \
    svn_error_t *err__ = (expr);                                          \
    SVN_ERR_ASSERT((expected));                                           \
    if (err__ == SVN_NO_ERROR || err__->apr_err != (expected))            \
      return err__ ? svn_error_createf(SVN_ERR_TEST_FAILED, err__,        \
                                       "Expected error %s but got %s",    \
                                       svn_error_symbolic_name(expected), \
                                       svn_error_symbolic_name(           \
                                         err__->apr_err))                 \
                   : svn_error_createf(SVN_ERR_TEST_FAILED, err__,        \
                                       "Expected error %s but got %s",    \
                                       svn_error_symbolic_name(expected), \
                                        "SVN_NO_ERROR");                  \
    svn_error_clear(err__);                                               \
  } while (0)

/** Handy macro for testing that an svn_error_t is returned.
 * The result must be neither SVN_NO_ERROR nor SVN_ERR_ASSERTION_FAIL.
 * The error returned by EXPR will be cleared.
 */
#define SVN_TEST_ASSERT_ANY_ERROR(expr)                                   \
  do {                                                                    \
    svn_error_t *err__ = (expr);                                          \
    if (err__ == SVN_NO_ERROR || err__->apr_err == SVN_ERR_ASSERTION_FAIL)\
      return err__ ? svn_error_createf(SVN_ERR_TEST_FAILED, err__,        \
                                       "Expected error but got %s",       \
                                       "SVN_ERR_ASSERTION_FAIL")          \
                   : svn_error_createf(SVN_ERR_TEST_FAILED, err__,        \
                                       "Expected error but got %s",       \
                                       "SVN_NO_ERROR");                   \
    svn_error_clear(err__);                                               \
  } while (0)

/** Handy macro for testing string equality.
 *
 * EXPR and/or EXPECTED_EXPR may be NULL which compares equal to NULL and
 * not equal to any non-NULL string.
 */
#define SVN_TEST_STRING_ASSERT(expr, expected_expr)                 \
  do {                                                              \
    const char *tst_str1 = (expr);                                  \
    const char *tst_str2 = (expected_expr);                         \
                                                                    \
    if (tst_str2 == NULL && tst_str1 == NULL)                       \
      break;                                                        \
    if ((tst_str1 == NULL) || (tst_str2 == NULL)                    \
        || (strcmp(tst_str2, tst_str1) != 0))                       \
      return svn_error_createf(SVN_ERR_TEST_FAILED, NULL,           \
          "Strings not equal\n  Expected: '%s'\n  Found:    '%s'"   \
          "\n  at %s:%d",                                           \
          tst_str2, tst_str1, __FILE__, __LINE__);                  \
  } while(0)

 /** Handy macro for testing integer equality.
  */
#define SVN_TEST_INT_ASSERT(expr, expected_expr)                  \
  do {                                                            \
    apr_int64_t tst_int1 = (expr);                                \
    apr_int64_t tst_int2 = (expected_expr);                       \
                                                                  \
    if (tst_int1 != tst_int2)                                     \
      return svn_error_createf(SVN_ERR_TEST_FAILED, NULL,         \
          "Integers not equal\n"                                  \
          "  Expected: %" APR_INT64_T_FMT "\n"                    \
          "     Found: %" APR_INT64_T_FMT "\n"                    \
          "  at %s:%d",                                           \
          tst_int2, tst_int1, __FILE__, __LINE__);                \
  } while(0)

/** Handy macro for testing apr_time_t equality.
 *
 * WITHIN_EXPR specifies the proximity of the comparison.
 */
#define SVN_TEST_TIME_ASSERT(expr, expected_expr, within_expr)    \
  do {                                                            \
    apr_time_t actual_time = (expr);                              \
    apr_time_t expected_time = (expected_expr);                   \
    apr_interval_time_t within_time = (within_expr);              \
                                                                  \
    if (actual_time < expected_time - within_time ||              \
        actual_time > expected_time + within_time)                \
      {                                                           \
        svn_error_t *err =                                        \
          svn_error_create(SVN_ERR_TEST_FAILED, NULL, NULL);      \
                                                                  \
        err->message = apr_psprintf(                              \
          err->pool,                                              \
          "Time values not equal\n"                               \
          "  Expected: %s (%" APR_TIME_T_FMT ")\n"                \
          "     Found: %s (%" APR_TIME_T_FMT ")\n"                \
          " Proximity: %" APR_TIME_T_FMT "ms\n"                   \
          "  at %s:%d",                                           \
          svn_time_to_cstring(expected_time, err->pool),          \
          expected_time,                                          \
          svn_time_to_cstring(actual_time, err->pool),            \
          actual_time,                                            \
          apr_time_as_msec(within_time),                          \
          __FILE__, __LINE__);                                    \
                                                                  \
        return err;                                               \
      }                                                           \
  } while(0)


/* Baton for any arguments that need to be passed from main() to svn
 * test functions.
 */
typedef struct svn_test_opts_t
{
  /* The name of the application (to generate unique names) */
  const char *prog_name;
  /* Description of the fs backend that should be used for testing. */
  const char *fs_type;
  /* Config file. */
  const char *config_file;
  /* Source dir. */
  const char *srcdir;
  /* Repository dir: temporary directory to create repositories in as subdir */
  const char *repos_dir;
  /* Repository url: The url to access REPOS_DIR as */
  const char *repos_url;
  /* Memcached server. */
  const char *memcached_server;
  /* Repository template: pre-created repository to copy for tests */
  const char *repos_template;
  /* Minor version to use for servers and FS backends, or zero to use
     the current latest version. */
  int server_minor_version;
  svn_boolean_t verbose;
  /* Add future "arguments" here. */
} svn_test_opts_t;

/* Prototype for test driver functions. */
typedef svn_error_t* (*svn_test_driver2_t)(apr_pool_t *pool);

/* Prototype for test driver functions which need options. */
typedef svn_error_t* (*svn_test_driver_opts_t)(const svn_test_opts_t *opts,
                                               apr_pool_t *pool);

/* Prototype for test predicate functions. */
typedef svn_boolean_t (*svn_test_predicate_func_t)(const svn_test_opts_t *opts,
                                                   const char *predicate_value,
                                                   apr_pool_t *pool);

/* Test modes. */
enum svn_test_mode_t
  {
    svn_test_pass,
    svn_test_xfail,
    svn_test_skip,
    svn_test_all
  };

/* Structure for runtime test predicates. */
struct svn_test_predicate_t
{
  /* The predicate function. */
  svn_test_predicate_func_t func;

  /* The value that the predicate function tests. */
  const char *value;

  /* The test mode that's used if the predicate matches. */
  enum svn_test_mode_t alternate_mode;

  /* Description for the test log */
  const char *description;
};


/* Each test gets a test descriptor, holding the function and other
 * associated data.
 */
struct svn_test_descriptor_t
{
  /* Is the test marked XFAIL? */
  enum svn_test_mode_t mode;

  /* A pointer to the test driver function. */
  svn_test_driver2_t func2;

  /* A pointer to the test driver function. */
  svn_test_driver_opts_t func_opts;

  /* A descriptive message for this test. */
  const char *msg;

  /* An optional description of a work-in-progress test. */
  const char *wip;

  /* An optional runtiume predicate. */
  struct svn_test_predicate_t predicate;
};

/* All Subversion test programs include an array of svn_test_descriptor_t's
 * (all of our sub-tests) that begins and ends with a SVN_TEST_NULL entry.
 * This descriptor must be passed to the svn_test_main function.
 *
 * MAX_THREADS is the number of concurrent tests to run.  Set to 1 if
 * all tests must be executed serially.  Numbers less than 1 mean
 * "unbounded".
 */
int svn_test_main(int argc, const char *argv[], int max_threads,
                  struct svn_test_descriptor_t *test_funcs);

/* Boilerplate for the main function for each test program. */
#define SVN_TEST_MAIN                                 \
  int main(int argc, const char *argv[])              \
    {                                                 \
      return svn_test_main(argc, argv,                \
                           max_threads, test_funcs);  \
    }

/* A null initializer for the test descriptor. */
#define SVN_TEST_NULL  {0}

/* Initializer for PASS tests */
#define SVN_TEST_PASS2(func, msg)  {svn_test_pass, func, NULL, msg}

/* Initializer for XFAIL tests */
#define SVN_TEST_XFAIL2(func, msg) {svn_test_xfail, func, NULL, msg}

/* Initializer for conditional XFAIL tests */
#define SVN_TEST_XFAIL_COND2(func, p, msg) \
  {(p) ? svn_test_xfail : svn_test_pass, func, NULL, msg}

/* Initializer for SKIP tests */
#define SVN_TEST_SKIP2(func, p, msg) \
  {(p) ? svn_test_skip : svn_test_pass, func, NULL, msg}

/* Similar macros, but for tests needing options.  */
#define SVN_TEST_OPTS_PASS(func, msg)  {svn_test_pass, NULL, func, msg}
#define SVN_TEST_OPTS_XFAIL(func, msg) {svn_test_xfail, NULL, func, msg}
#define SVN_TEST_OPTS_XFAIL_COND(func, p, msg) \
  {(p) ? svn_test_xfail : svn_test_pass, NULL, func, msg}
#define SVN_TEST_OPTS_XFAIL_OTOH(func, msg, predicate) \
  {svn_test_xfail, NULL, func, msg, NULL, predicate}
#define SVN_TEST_OPTS_SKIP(func, p, msg) \
  {(p) ? svn_test_skip : svn_test_pass, NULL, func, msg}

/* Initializer for XFAIL tests for works-in-progress. */
#define SVN_TEST_WIMP(func, msg, wip) \
  {svn_test_xfail, func, NULL, msg, wip}
#define SVN_TEST_WIMP_COND(func, p, msg, wip) \
  {(p) ? svn_test_xfail : svn_test_pass, func, NULL, msg, wip}
#define SVN_TEST_OPTS_WIMP(func, msg, wip) \
  {svn_test_xfail, NULL, func, msg, wip}
#define SVN_TEST_OPTS_WIMP_COND(func, p, msg, wip) \
  {(p) ? svn_test_xfail : svn_test_pass, NULL, func, msg, wip}


/* Return a pseudo-random number based on SEED, and modify SEED.
 *
 * This is a "good" pseudo-random number generator, intended to replace
 * all those "bad" rand() implementations out there.
 */
apr_uint32_t svn_test_rand(apr_uint32_t *seed);


/* Add PATH to the test cleanup list.  */
void svn_test_add_dir_cleanup(const char *path);


/* A simple representation for a tree node. */
typedef struct svn_test__tree_entry_t
{
  const char *path;     /* relpath of this node */
  const char *contents; /* text contents, or NULL for a directory */
}
svn_test__tree_entry_t;

/* Wrapper for an array of svn_test__tree_entry_t's. */
typedef struct svn_test__tree_t
{
  svn_test__tree_entry_t *entries;
  int num_entries;
}
svn_test__tree_t;


/* The standard Greek tree, terminated by a node with path=NULL. */
extern const svn_test__tree_entry_t svn_test__greek_tree_nodes[21];


/* Returns a path to BASENAME within the transient data area for the
   current test. */
const char *
svn_test_data_path(const char* basename, apr_pool_t *result_pool);


/* Some tests require the --srcdir option and should use this function
 * to get it. If not provided, print a warning and attempt to run the
 * tests under the assumption that --srcdir is the current directory. */
svn_error_t *
svn_test_get_srcdir(const char **srcdir,
                    const svn_test_opts_t *opts,
                    apr_pool_t *pool);

/* Initializes a standard auth baton for accessing the repositories */
svn_error_t *
svn_test__init_auth_baton(svn_auth_baton_t **baton,
                          apr_pool_t *result_pool);

/* Create a temp folder for test & schedule it for automatic cleanup.
 * Uses POOL for all allocations. */
svn_error_t *
svn_test_make_sandbox_dir(const char **sb_dir_p,
                          const char *sb_name,
                          apr_pool_t *pool);

/*
 * Test predicates
 */

#define SVN_TEST_PASS_IF_FS_TYPE_IS(fs_type) \
  { svn_test__fs_type_is, fs_type, svn_test_pass, \
    "PASS if fs-type = " fs_type }

#define SVN_TEST_PASS_IF_FS_TYPE_IS_NOT(fs_type) \
  { svn_test__fs_type_not, fs_type, svn_test_pass, \
    "PASS if fs-type != " fs_type }

/* Return TRUE if the fs-type in OPTS matches PREDICATE_VALUE. */
svn_boolean_t
svn_test__fs_type_is(const svn_test_opts_t *opts,
                     const char *predicate_value,
                     apr_pool_t *pool);


/* Return TRUE if the fs-type in OPTS does not matches PREDICATE_VALUE. */
svn_boolean_t
svn_test__fs_type_not(const svn_test_opts_t *opts,
                      const char *predicate_value,
                      apr_pool_t *pool);


#ifdef __cplusplus
}
#endif /* __cplusplus */

#endif /* SVN_TEST_H */