/*
* Copyright (c) Meta Platforms, Inc. and affiliates.
* All rights reserved.
*
* This source code is licensed under both the BSD-style license (found in the
* LICENSE file in the root directory of this source tree) and the GPLv2 (found
* in the COPYING file in the root directory of this source tree).
* You may select, at your option, one of the above-listed licenses.
*/

#include <assert.h>
#include <getopt.h>
#include <stdio.h>
#include <string.h>

#include "config.h"
#include "data.h"
#include "method.h"

static int g_max_name_len = 0;

/** Check if a name contains a comma or is too long. */
static int is_name_bad(char const* name) {
   if (name == NULL)
       return 1;
   int const len = strlen(name);
   if (len > g_max_name_len)
       g_max_name_len = len;
   for (; *name != '\0'; ++name)
       if (*name == ',')
           return 1;
   return 0;
}

/** Check if any of the names contain a comma. */
static int are_names_bad() {
   for (size_t method = 0; methods[method] != NULL; ++method)
       if (is_name_bad(methods[method]->name)) {
           fprintf(stderr, "method name %s is bad\n", methods[method]->name);
           return 1;
       }
   for (size_t datum = 0; data[datum] != NULL; ++datum)
       if (is_name_bad(data[datum]->name)) {
           fprintf(stderr, "data name %s is bad\n", data[datum]->name);
           return 1;
       }
   for (size_t config = 0; configs[config] != NULL; ++config)
       if (is_name_bad(configs[config]->name)) {
           fprintf(stderr, "config name %s is bad\n", configs[config]->name);
           return 1;
       }
   return 0;
}

/**
* Option parsing using getopt.
* When you add a new option update: long_options, long_extras, and
* short_options.
*/

/** Option variables filled by parse_args. */
static char const* g_output = NULL;
static char const* g_diff = NULL;
static char const* g_cache = NULL;
static char const* g_zstdcli = NULL;
static char const* g_config = NULL;
static char const* g_data = NULL;
static char const* g_method = NULL;

typedef enum {
   required_option,
   optional_option,
   help_option,
} option_type;

/**
* Extra state that we need to keep per-option that we can't store in getopt.
*/
struct option_extra {
   int id; /**< The short option name, used as an id. */
   char const* help; /**< The help message. */
   option_type opt_type; /**< The option type: required, optional, or help. */
   char const** value; /**< The value to set or NULL if no_argument. */
};

/** The options. */
static struct option long_options[] = {
   {"cache", required_argument, NULL, 'c'},
   {"output", required_argument, NULL, 'o'},
   {"zstd", required_argument, NULL, 'z'},
   {"config", required_argument, NULL, 128},
   {"data", required_argument, NULL, 129},
   {"method", required_argument, NULL, 130},
   {"diff", required_argument, NULL, 'd'},
   {"help", no_argument, NULL, 'h'},
};

static size_t const nargs = sizeof(long_options) / sizeof(long_options[0]);

/** The extra info for the options. Must be in the same order as the options. */
static struct option_extra long_extras[] = {
   {'c', "the cache directory", required_option, &g_cache},
   {'o', "write the results here", required_option, &g_output},
   {'z', "zstd cli tool", required_option, &g_zstdcli},
   {128, "use this config", optional_option, &g_config},
   {129, "use this data", optional_option, &g_data},
   {130, "use this method", optional_option, &g_method},
   {'d', "compare the results to this file", optional_option, &g_diff},
   {'h', "display this message", help_option, NULL},
};

/** The short options. Must correspond to the options. */
static char const short_options[] = "c:d:ho:z:";

/** Return the help string for the option type. */
static char const* required_message(option_type opt_type) {
   switch (opt_type) {
       case required_option:
           return "[required]";
       case optional_option:
           return "[optional]";
       case help_option:
           return "";
       default:
           assert(0);
           return NULL;
   }
}

/** Print the help for the program. */
static void print_help(void) {
   fprintf(stderr, "regression test runner\n");
   size_t const nargs = sizeof(long_options) / sizeof(long_options[0]);
   for (size_t i = 0; i < nargs; ++i) {
       if (long_options[i].val < 128) {
           /* Long / short  - help [option type] */
           fprintf(
               stderr,
               "--%s / -%c \t- %s %s\n",
               long_options[i].name,
               long_options[i].val,
               long_extras[i].help,
               required_message(long_extras[i].opt_type));
       } else {
           /* Short / long  - help [option type] */
           fprintf(
               stderr,
               "--%s      \t- %s %s\n",
               long_options[i].name,
               long_extras[i].help,
               required_message(long_extras[i].opt_type));
       }
   }
}

/** Parse the arguments. Return 0 on success. Print help on failure. */
static int parse_args(int argc, char** argv) {
   int option_index = 0;
   int c;

   while (1) {
       c = getopt_long(argc, argv, short_options, long_options, &option_index);
       if (c == -1)
           break;

       int found = 0;
       for (size_t i = 0; i < nargs; ++i) {
           if (c == long_extras[i].id && long_extras[i].value != NULL) {
               *long_extras[i].value = optarg;
               found = 1;
               break;
           }
       }
       if (found)
           continue;

       switch (c) {
           case 'h':
           case '?':
           default:
               print_help();
               return 1;
       }
   }

   int bad = 0;
   for (size_t i = 0; i < nargs; ++i) {
       if (long_extras[i].opt_type != required_option)
           continue;
       if (long_extras[i].value == NULL)
           continue;
       if (*long_extras[i].value != NULL)
           continue;
       fprintf(
           stderr,
           "--%s is a required argument but is not set\n",
           long_options[i].name);
       bad = 1;
   }
   if (bad) {
       fprintf(stderr, "\n");
       print_help();
       return 1;
   }

   return 0;
}

/** Helper macro to print to stderr and a file. */
#define tprintf(file, ...)            \
   do {                              \
       fprintf(file, __VA_ARGS__);   \
       fprintf(stderr, __VA_ARGS__); \
   } while (0)
/** Helper macro to flush stderr and a file. */
#define tflush(file)    \
   do {                \
       fflush(file);   \
       fflush(stderr); \
   } while (0)

void tprint_names(
   FILE* results,
   char const* data_name,
   char const* config_name,
   char const* method_name) {
   int const data_padding = g_max_name_len - strlen(data_name);
   int const config_padding = g_max_name_len - strlen(config_name);
   int const method_padding = g_max_name_len - strlen(method_name);

   tprintf(
       results,
       "%s, %*s%s, %*s%s, %*s",
       data_name,
       data_padding,
       "",
       config_name,
       config_padding,
       "",
       method_name,
       method_padding,
       "");
}

/**
* Run all the regression tests and record the results table to results and
* stderr progressively.
*/
static int run_all(FILE* results) {
   tprint_names(results, "Data", "Config", "Method");
   tprintf(results, "Total compressed size\n");
   for (size_t method = 0; methods[method] != NULL; ++method) {
       if (g_method != NULL && strcmp(methods[method]->name, g_method))
           continue;
       for (size_t datum = 0; data[datum] != NULL; ++datum) {
           if (g_data != NULL && strcmp(data[datum]->name, g_data))
               continue;
           /* Create the state common to all configs */
           method_state_t* state = methods[method]->create(data[datum]);
           for (size_t config = 0; configs[config] != NULL; ++config) {
               if (g_config != NULL && strcmp(configs[config]->name, g_config))
                   continue;
               if (config_skip_data(configs[config], data[datum]))
                   continue;
               /* Print the result for the (method, data, config) tuple. */
               result_t const result =
                   methods[method]->compress(state, configs[config]);
               if (result_is_skip(result))
                   continue;
               tprint_names(
                   results,
                   data[datum]->name,
                   configs[config]->name,
                   methods[method]->name);
               if (result_is_error(result)) {
                   tprintf(results, "%s\n", result_get_error_string(result));
               } else {
                   tprintf(
                       results,
                       "%llu\n",
                       (unsigned long long)result_get_data(result).total_size);
               }
               tflush(results);
           }
           methods[method]->destroy(state);
       }
   }
   return 0;
}

/** memcmp() the old results file and the new results file. */
static int diff_results(char const* actual_file, char const* expected_file) {
   data_buffer_t const actual = data_buffer_read(actual_file);
   data_buffer_t const expected = data_buffer_read(expected_file);
   int ret = 1;

   if (actual.data == NULL) {
       fprintf(stderr, "failed to open results '%s' for diff\n", actual_file);
       goto out;
   }
   if (expected.data == NULL) {
       fprintf(
           stderr,
           "failed to open previous results '%s' for diff\n",
           expected_file);
       goto out;
   }

   ret = data_buffer_compare(actual, expected);
   if (ret != 0) {
       fprintf(
           stderr,
           "actual results '%s' does not match expected results '%s'\n",
           actual_file,
           expected_file);
   } else {
       fprintf(stderr, "actual results match expected results\n");
   }
out:
   data_buffer_free(actual);
   data_buffer_free(expected);
   return ret;
}

int main(int argc, char** argv) {
   /* Parse args and validate modules. */
   int ret = parse_args(argc, argv);
   if (ret != 0)
       return ret;

   if (are_names_bad())
       return 1;

   /* Initialize modules. */
   method_set_zstdcli(g_zstdcli);
   ret = data_init(g_cache);
   if (ret != 0) {
       fprintf(stderr, "data_init() failed with error=%s\n", strerror(ret));
       return 1;
   }

   /* Run the regression tests. */
   ret = 1;
   FILE* results = fopen(g_output, "w");
   if (results == NULL) {
       fprintf(stderr, "Failed to open the output file\n");
       goto out;
   }
   ret = run_all(results);
   fclose(results);

   if (ret != 0)
       goto out;

   if (g_diff)
       /* Diff the new results with the previous results. */
       ret = diff_results(g_output, g_diff);

out:
   data_finish();
   return ret;
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.