/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.

 *

 * Permission is hereby granted, free of charge, to any person obtaining a copy

 * of this software and associated documentation files (the "Software"), to

 * deal in the Software without restriction, including without limitation the

 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or

 * sell copies of the Software, and to permit persons to whom the Software is

 * furnished to do so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice shall be included in

 * all copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS

 * IN THE SOFTWARE.

 */

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include "runner.h"

#include "task.h"

#include "uv.h"

char executable_path[sizeof(executable_path)];

static int compare_task(const void* va, const void* vb) {

  const task_entry_t* a = va;

  const task_entry_t* b = vb;

  return strcmp(a->task_name, b->task_name);

}

const char* fmt(double d) {

  static char buf[1024];

  static char* p;

  uint64_t v;

  if (p == NULL)

    p = buf;

  p += 31;

  if (p >= buf + sizeof(buf))

    return "<buffer too small>";

  v = (uint64_t) d;

#if 0 /* works but we don't care about fractional precision */

  if (d - v >= 0.01) {

    *--p = '0' + (uint64_t) (d * 100) % 10;

    *--p = '0' + (uint64_t) (d * 10) % 10;

    *--p = '.';

  }

#endif

  if (v == 0)

    *--p = '0';

  while (v) {

    if (v) *--p = '0' + (v % 10), v /= 10;

    if (v) *--p = '0' + (v % 10), v /= 10;

    if (v) *--p = '0' + (v % 10), v /= 10;

    if (v) *--p = ',';

  }

  return p;

}

int run_tests(int benchmark_output) {

  int actual;

  int total;

  int passed;

  int failed;

  int skipped;

  int current;

  int test_result;

  int skip;

  task_entry_t* task;

  /* Count the number of tests. */

  actual = 0;

  total = 0;

  for (task = TASKS; task->main; task++, actual++) {

    if (!task->is_helper) {

      total++;

    }

  }

  /* Keep platform_output first. */

  skip = (actual > 0 && 0 == strcmp(TASKS[0].task_name, "platform_output"));

  qsort(TASKS + skip, actual - skip, sizeof(TASKS[0]), compare_task);

  fprintf(stderr, "1..%d\n", total);

  fflush(stderr);

  /* Run all tests. */

  passed = 0;

  failed = 0;

  skipped = 0;

  current = 1;

  for (task = TASKS; task->main; task++) {

    if (task->is_helper) {

      continue;

    }

    test_result = run_test(task->task_name, benchmark_output, current);

    switch (test_result) {

    case TEST_OK: passed++; break;

    case TEST_SKIP: skipped++; break;

    default: failed++;

    }

    current++;

  }

  return failed;

}

void log_tap_result(int test_count,

                    const char* test,

                    int status,

                    process_info_t* process) {

  const char* result;

  const char* directive;

  char reason[1024];

  int reason_length;

  switch (status) {

  case TEST_OK:

    result = "ok";

    directive = "";

    break;

  case TEST_SKIP:

    result = "ok";

    directive = " # SKIP ";

    break;

  default:

    result = "not ok";

    directive = "";

  }

  if (status == TEST_SKIP && process_output_size(process) > 0) {

    process_read_last_line(process, reason, sizeof reason);

    reason_length = strlen(reason);

    if (reason_length > 0 && reason[reason_length - 1] == '\n')

      reason[reason_length - 1] = '\0';

  } else {

    reason[0] = '\0';

  }

  fprintf(stderr, "%s %d - %s%s%s\n", result, test_count, test, directive, reason);

  fflush(stderr);

}

int run_test(const char* test,

             int benchmark_output,

             int test_count) {

  char errmsg[1024] = "";

  process_info_t processes[1024];

  process_info_t *main_proc;

  task_entry_t* task;

  int timeout_multiplier;

  int process_count;

  int result;

  int status;

  int i;

  status = 255;

  main_proc = NULL;

  process_count = 0;

#ifndef _WIN32

  /* Clean up stale socket from previous run. */

  remove(TEST_PIPENAME);

  remove(TEST_PIPENAME_2);

  remove(TEST_PIPENAME_3);

#endif

  /* If it's a helper the user asks for, start it directly. */

  for (task = TASKS; task->main; task++) {

    if (task->is_helper && strcmp(test, task->process_name) == 0) {

      return task->main();

    }

  }

  /* Start the helpers first. */

  for (task = TASKS; task->main; task++) {

    if (strcmp(test, task->task_name) != 0) {

      continue;

    }

    /* Skip the test itself. */

    if (!task->is_helper) {

      continue;

    }

    if (process_start(task->task_name,

                      task->process_name,

                      &processes[process_count],

                      1 /* is_helper */) == -1) {

      snprintf(errmsg,

               sizeof errmsg,

               "Process `%s` failed to start.",

               task->process_name);

      goto out;

    }

    process_count++;

  }

  /* Now start the test itself. */

  for (task = TASKS; task->main; task++) {

    if (strcmp(test, task->task_name) != 0) {

      continue;

    }

    if (task->is_helper) {

      continue;

    }

    if (process_start(task->task_name,

                      task->process_name,

                      &processes[process_count],

                      0 /* !is_helper */) == -1) {

      snprintf(errmsg,

               sizeof errmsg,

               "Process `%s` failed to start.",

               task->process_name);

      goto out;

    }

    main_proc = &processes[process_count];

    process_count++;

    break;

  }

  if (main_proc == NULL) {

    snprintf(errmsg,

             sizeof errmsg,

             "No test with that name: %s",

             test);

    goto out;

  }

  timeout_multiplier = 1;

#ifndef _WIN32

  do {

    const char* var;

    var = getenv("UV_TEST_TIMEOUT_MULTIPLIER");

    if (var == NULL)

      break;

    timeout_multiplier = atoi(var);

    if (timeout_multiplier <= 0)

      timeout_multiplier = 1;

  } while (0);

#endif

  result = process_wait(main_proc, 1, task->timeout * timeout_multiplier);

  if (result == -1) {

    FATAL("process_wait failed");

  } else if (result == -2) {

    /* Don't have to clean up the process, process_wait() has killed it. */

    snprintf(errmsg,

             sizeof errmsg,

             "timeout");

    goto out;

  }

  status = process_reap(main_proc);

  if (status != TEST_OK) {

    snprintf(errmsg,

             sizeof errmsg,

             "exit code %d",

             status);

    goto out;

  }

  if (benchmark_output) {

    /* Give the helpers time to clean up their act. */

    uv_sleep(1000);

  }

out:

  /* Reap running processes except the main process, it's already dead. */

  for (i = 0; i < process_count - 1; i++) {

    process_terminate(&processes[i]);

  }

  if (process_count > 0 &&

      process_wait(processes, process_count - 1, -1) < 0) {

    FATAL("process_wait failed");

  }

  log_tap_result(test_count, test, status, &processes[i]);

  /* Show error and output from processes if the test failed. */

  if ((status != TEST_OK && status != TEST_SKIP) || task->show_output) {

    if (strlen(errmsg) > 0)

      fprintf(stderr, "# %s\n", errmsg);

    fprintf(stderr, "# ");

    fflush(stderr);

    for (i = 0; i < process_count; i++) {

      switch (process_output_size(&processes[i])) {

       case -1:

        fprintf(stderr, "Output from process `%s`: (unavailable)\n",

                process_get_name(&processes[i]));

        fflush(stderr);

        break;

       case 0:

        fprintf(stderr, "Output from process `%s`: (no output)\n",

                process_get_name(&processes[i]));

        fflush(stderr);

        break;

       default:

        fprintf(stderr, "Output from process `%s`:\n", process_get_name(&processes[i]));

        fflush(stderr);

        process_copy_output(&processes[i], stderr);

        break;

      }

    }

  /* In benchmark mode show concise output from the main process. */

  } else if (benchmark_output) {

    switch (process_output_size(main_proc)) {

     case -1:

      fprintf(stderr, "%s: (unavailable)\n", test);

      fflush(stderr);

      break;

     case 0:

      fprintf(stderr, "%s: (no output)\n", test);

      fflush(stderr);

      break;

     default:

      for (i = 0; i < process_count; i++) {

        process_copy_output(&processes[i], stderr);

      }

      break;

    }

  }

  /* Clean up all process handles. */

  for (i = 0; i < process_count; i++) {

    process_cleanup(&processes[i]);

  }

  return status;

}

/* Returns the status code of the task part

 * or 255 if no matching task was not found.

 */

int run_test_part(const char* test, const char* part) {

  task_entry_t* task;

  int r;

  for (task = TASKS; task->main; task++) {

    if (strcmp(test, task->task_name) == 0 &&

        strcmp(part, task->process_name) == 0) {

      r = task->main();

      return r;

    }

  }

  fprintf(stderr, "No test part with that name: %s:%s\n", test, part);

  fflush(stderr);

  return 255;

}

static int find_helpers(const task_entry_t* task,

                        const task_entry_t** helpers) {

  const task_entry_t* helper;

  int n_helpers;

  for (n_helpers = 0, helper = TASKS; helper->main; helper++) {

    if (helper->is_helper && strcmp(helper->task_name, task->task_name) == 0) {

      *helpers++ = helper;

      n_helpers++;

    }

  }

  return n_helpers;

}

void print_tests(FILE* stream) {

  const task_entry_t* helpers[1024];

  const task_entry_t* task;

  int n_helpers;

  int n_tasks;

  int i;

  for (n_tasks = 0, task = TASKS; task->main; n_tasks++, task++);

  qsort(TASKS, n_tasks, sizeof(TASKS[0]), compare_task);

  for (task = TASKS; task->main; task++) {

    if (task->is_helper) {

      continue;

    }

    n_helpers = find_helpers(task, helpers);

    if (n_helpers) {

      printf("%-25s (helpers:", task->task_name);

      for (i = 0; i < n_helpers; i++) {

        printf(" %s", helpers[i]->process_name);

      }

      printf(")\n");

    } else {

      printf("%s\n", task->task_name);

    }

  }

}

void print_lines(const char* buffer, size_t size, FILE* stream) {

  const char* start;

  const char* end;

  start = buffer;

  while ((end = memchr(start, '\n', &buffer[size] - start))) {

    fputs("# ", stream);

    fwrite(start, 1, (int)(end - start), stream);

    fputs("\n", stream);

    fflush(stream);

    start = end + 1;

  }

  end = &buffer[size];

  if (start < end) {

    fputs("# ", stream);

    fwrite(start, 1, (int)(end - start), stream);

    fputs("\n", stream);

    fflush(stream);

  }

}