main.c

Go to the documentation of this file.

/* -*- C -*-
 * Serene programming language
 * Copyright (C) 2019-2026 Sameer Rahmani <lxsameer@lxsameer.com>
 *
 * This library is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this library.  If not, see <https://www.gnu.org/licenses/>.
 */
 
#include "serene/runtime.h"
#if !defined(_WIN32)
#  ifndef _POSIX_C_SOURCE
#    define _POSIX_C_SOURCE 200809L
#  endif
#endif
 
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>
 
#include "serene/ir/reader.h"
#include "serene/rt/context.h"
#include "serene/rt/engine.h"
#include "serene/rt/errors.h"
#include "serene/rt/fiber.h"
#include "serene/rt/fiber/io.h"
#include "serene/rt/mm/interface.h"
#include "serene/utils.h"
 
#define SEPARATOR "---"
 
typedef struct test_case_t {
  char *source;
  char *expected;
} test_case_t;
 
typedef struct test_fiber_arg_t {
  const char *path;
  bool passed;
} test_fiber_arg_t;
 
/**
 * Split `content` (`len` bytes) at the line that is exactly "---" into a
 * freshly allocated `source` and `expected` string in `out`. A single
 * trailing newline is stripped from each side, if present, everything else is
 * kept byte for byte. Returns false, after printing a message to stderr, when
 * no such line exists.
 */
static bool split_test_case(const char *path, const char *content, size_t len, test_case_t *out) {
  size_t line_start = 0;
  size_t sep_start  = SIZE_MAX;
  size_t sep_end    = SIZE_MAX;
 
  for (size_t i = 0; i <= len; i++) {
    if (i == len || content[i] == '\n') {
      size_t line_len = i - line_start;
      if (line_len == strlen(SEPARATOR) && memcmp(content + line_start, SEPARATOR, line_len) == 0) {
        sep_start = line_start;
        sep_end   = (i < len) ? i + 1 : i;
        break;
      }
      line_start = i + 1;
    }
  }
 
  if (sep_start == SIZE_MAX) {
    (void)fprintf(stderr, "%s: missing '---' separator line\n", path);
    return false;
  }
 
  size_t src_len = sep_start;
  if (src_len > 0 && content[src_len - 1] == '\n') {
    src_len--;
  }
 
  size_t exp_start = sep_end;
  size_t exp_len   = len - sep_end;
  if (exp_len > 0 && content[exp_start + exp_len - 1] == '\n') {
    exp_len--;
  }
 
  out->source   = malloc(src_len + 1);
  out->expected = malloc(exp_len + 1);
 
  if (out->source == nullptr || out->expected == nullptr) {
    (void)fprintf(stderr, "%s: out of memory\n", path);
    free(out->source);
    free(out->expected);
    return false;
  }
 
  memcpy(out->source, content, src_len);
  out->source[src_len] = '\0';
 
  memcpy(out->expected, content + exp_start, exp_len);
  out->expected[exp_len] = '\0';
 
  return true;
}
 
/**
 * Run one test file end to end, on its own fiber, so a large batch of files
 * runs as that many concurrent fibers rather than one after another: read the
 * file (srn_fiber_read suspends this fiber rather than blocking its worker),
 * split it into source/expected, hand the source to the reader on a nested
 * fiber, then compare and report. Errors along the way (I/O, a malformed
 * fixture, a reader failure) are reported to stderr and leave `arg->passed`
 * false; nothing here escapes to the fiber's result, there is no driver left
 * to inspect it.
 */
static srn_fiber_result_t run_test_fiber(srn_context_t *ctx, void *arg_) {
  test_fiber_arg_t *arg = arg_;
  arg->passed           = false;
 
  int fd = open(arg->path, O_RDONLY);
  if (fd < 0) {
    srn_error_tag_t tag = srn_errno_to_tag(errno, UNKNOWN_IO_ERROR);
    srn_error_t *err    = ERR(ctx, tag, "Failed to open the test file.");
    (void)fprintf(stderr, "%s: %s\n", arg->path, srn_error_to_string(ctx, err));
    return nullptr;
  }
 
  struct stat st;
  if (fstat(fd, &st) < 0) {
    srn_error_tag_t tag = srn_errno_to_tag(errno, UNKNOWN_IO_ERROR);
    close(fd);
    srn_error_t *err = ERR(ctx, tag, "Failed to stat the test file.");
    (void)fprintf(stderr, "%s: %s\n", arg->path, srn_error_to_string(ctx, err));
    return nullptr;
  }
 
  size_t len    = (size_t)st.st_size;
  char *content = malloc(len + 1);
  if (content == nullptr) {
    close(fd);
    (void)fprintf(stderr, "%s: out of memory reading the test file\n", arg->path);
    return nullptr;
  }
 
  size_t total_read = 0;
  while (total_read < len) {
    srn_io_size_result_t r;
    SRN_WITH_RETRY(r.maybe_error, {
      r = srn_fiber_read(fd, content + total_read, len - total_read, -1);
    });
 
    if (HAS_ERROR(r)) {
      close(fd);
      free(content);
      (void)fprintf(stderr, "%s: %s\n", arg->path, srn_error_to_string(ctx, r.maybe_error));
      return nullptr;
    }
 
    if (r.count == 0) {
      // Short read against fstat's size, treat what we got as the whole file.
      break;
    }
 
    total_read += r.count;
  }
 
  close(fd);
  content[total_read] = '\0';
 
  test_case_t test;
  if (!split_test_case(arg->path, content, total_read, &test)) {
    free(content);
    return nullptr;
  }
  free(content);
 
  srn_sexp_parser_t parser = {
    .ctx             = ctx,
    .reading_context = nullptr,
    .buffer_id       = 0,
    .buffer          = (const unsigned char *)test.source,
    .len             = strlen(test.source),
    .pos             = 0,
  };
 
  reader_fiber_arg_t reader_arg = {
    .parser = &parser,
    .tree   = nullptr,
  };
 
  srn_fiber_t *reader_fiber        = srn_fiber_spawn(ctx, read_from_buffer, &reader_arg);
  srn_fiber_result_t reader_result = srn_fiber_wait_for(reader_fiber);
 
  if (reader_result != nullptr) {
    srn_error_t *err = (srn_error_t *)reader_result;
    (void)fprintf(stderr, "%s: %s\n", arg->path, srn_error_to_string(ctx, err));
    free(test.source);
    free(test.expected);
    return nullptr;
  }
 
  const char *actual = srn_sexp_to_debug_string(ctx, reader_arg.tree);
  arg->passed        = ((actual != nullptr && strcmp(actual, test.expected) == 0) != 0);
 
  if (arg->passed) {
    printf("PASS %s\n", arg->path);
  } else {
    printf("FAIL %s\n", arg->path);
    printf("==> expected:\n%s\n\n", test.expected);
    printf("==> actual:\n%s\n\n", actual != nullptr ? actual : "(reader error, see above)");
  }
 
  if (actual != nullptr) {
    FREE(ctx, (void *)actual);
  }
 
  free(test.source);
  free(test.expected);
 
  return nullptr;
}
 
int main(int argc, char **argv) {
  if (argc < 2) {
    (void)fprintf(stderr, "usage: %s <test-file>...\n", argv[0]);
    return 1;
  }
 
  SERENE_RUNTIME_INIT_WITH_SCHED(engine, sched, nullptr);
  srn_context_t *ctx = srn_context_make(engine);
  size_t ntests      = (size_t)(argc - 1);
 
  test_fiber_arg_t *args = ALLOCN_OR_PANIC(ctx, test_fiber_arg_t, ntests);
 
  for (size_t i = 0; i < ntests; i++) {
    args[i].path = argv[i + 1];
    srn_fiber_spawn(ctx, run_test_fiber, &args[i]);
  }
 
  srn_sched_run(sched, 0);
 
  int failures = 0;
  for (size_t i = 0; i < ntests; i++) {
    if (!args[i].passed) {
      failures++;
    }
  }
 
  srn_context_release(ctx);
  SERENE_RUNTIME_SHUTDOWN(engine);
 
  printf("\n%d/%d passed\n", (int)ntests - failures, (int)ntests);
 
  return failures == 0 ? 0 : 1;
}