main.c File Reference

#include "serene/runtime.h"
#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"

Include dependency graph for main.c:

Go to the source code of this file.

Data Structures
struct	test_case_t
struct	test_fiber_arg_t

Macros
#define	_POSIX_C_SOURCE   200809L
#define	SEPARATOR   "---"

Typedefs
typedef struct test_case_t	test_case_t
typedef struct test_fiber_arg_t	test_fiber_arg_t

Functions
static bool	split_test_case (const char *path, const char *content, size_t len, test_case_t *out)
	Split content (len bytes) at the line that is exactly "---" into a freshly allocated source and expected string in out.
static srn_fiber_result_t	run_test_fiber (srn_context_t *ctx, void *arg_)
	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.
int	main (int argc, char **argv)

Macro Definition Documentation

_POSIX_C_SOURCE

#define _POSIX_C_SOURCE   200809L

Definition at line 22 of file main.c.

SEPARATOR

#define SEPARATOR   "---"

Definition at line 43 of file main.c.

Typedef Documentation

test_case_t

typedef struct test_case_t test_case_t

test_fiber_arg_t

typedef struct test_fiber_arg_t test_fiber_arg_t

Function Documentation

main()

int main	(	int	argc,
		char **	argv )

Definition at line 231 of file main.c.

                                {
  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;
}

Here is the call graph for this function:

run_test_fiber()

srn_fiber_result_t run_test_fiber ( srn_context_t * ctx, void * arg_ )

static

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.

Definition at line 124 of file main.c.

                                                                         {
  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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

split_test_case()

bool split_test_case ( const char * path, const char * content, size_t len, test_case_t * out )

static

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.

Definition at line 62 of file main.c.

                                                                                                 {
  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;
}

Here is the caller graph for this function: