source_manager_tests.h

Go to the documentation of this file.

/* -*- C -*-
 * Serene programming language
 * Copyright (C) 2019-2026 Sameer Rahmani <lxsameer@lxsameer.com>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
#pragma once
 
#include <fcntl.h>
#include <limits.h>
#include <string.h>
#include <unistd.h>
 
#include <serene/rt/context.h>
#include <serene/rt/source_manager.h>
 
#include "base.h"
 
// elisp: (eglot-inlay-hints-mode -1)
 
#define SM_TESTS(X)                                                                        \
  X("source_manager::init", test_sm_init),                                                 \
    X("source_manager::buffer_new_file", test_sm_buffer_new_file),                         \
    X("source_manager::buffer_terminated", test_sm_buffer_terminated),                     \
    X("source_manager::buffer_same_file_no_reread", test_sm_buffer_same_file_no_reread),   \
    X("source_manager::buffer_empty_file", test_sm_buffer_empty_file),                     \
    X("source_manager::buffer_nonexistent_file", test_sm_buffer_nonexistent_file),         \
    X("source_manager::buffer_reread", test_sm_buffer_reread),                             \
    X("source_manager::get_buffer", test_sm_get_buffer),                                   \
    X("source_manager::id_exhaustion_releases_lock", test_sm_id_exhaustion_releases_lock), \
    X("source_manager::reread_failure_keeps_buffer", test_sm_reread_failure_keeps_buffer), \
    X("source_manager::filename_is_owned", test_sm_filename_is_owned),                     \
    X("source_manager::shutdown", test_sm_shutdown)
 
// Create a temp file containing `content` (may be empty). Writes the path into
// `path_out` (must be PATH_MAX bytes). Returns 0 on success, -1 on failure.
static int sm_make_temp_file(char *path_out, const char *content) {
  (void)snprintf(path_out, PATH_MAX, "/tmp/srn_sm_test_XXXXXX");
  int fd = mkstemp(path_out);
 
  if (fd < 0) {
    return -1;
  }
 
  size_t len = strlen(content);
  if (len > 0 && write(fd, content, len) != (ssize_t)len) {
    close(fd);
    unlink(path_out);
    return -1;
  }
 
  close(fd);
  return 0;
}
 
// srn_sm_init creates a source manager with no buffers.
static void test_sm_init() {
  MAKE_ENGINE(mm, engine);
  MAKE_CONTEXT(engine, ctx);
 
  srn_sm_t *sm = srn_sm_init(ctx);
  ASSERT_NOT_NULL(sm);
  TEST_CHECK(sm->buffer_counts == 0);
 
  srn_sm_shutdown(sm);
  TEST_CHECK(sm->buffer_counts == 0);
 
  RELEASE_CONTEXT(ctx);
  SHUTDOWN_ENGINE(mm, engine);
}
 
TEST_IN_FIBER(sm_buffer_new_file, {
  char path[PATH_MAX];
  TEST_ASSERT(sm_make_temp_file(path, "hello") == 0);
 
  srn_sm_t *sm = srn_sm_init(ctx);
  auto result  = srn_sm_buffer_file(sm, path, false);
 
  TEST_NO_ERROR(result);
  ASSERT_NOT_NULL(result.buffer);
 
  TEST_CHECK(sm->buffer_counts == 1);
  TEST_CHECK(srn_sm_buffer_len(result.buffer) == 6); // including the null terminator
  TEST_CHECK(memcmp(srn_sm_buffer_data(result.buffer), "hello", 5) == 0);
 
  srn_sm_shutdown(sm);
  unlink(path);
})
 
// The byte after the file contents is a NUL, which is what the reader stops
// on. The content is longer than the 16 bytes glibc scribbles on a freed
// chunk, so the poisoned chunk primed below shows a missing terminator
// instead of a stray zero from the allocator's own bookkeeping.
// This bug is spotted by an LLM.
TEST_IN_FIBER(sm_buffer_terminated, {
  static const char content[] = "0123456789abcdef0123456789abcdef";
  const size_t len            = sizeof(content) - 1;
 
  char path[PATH_MAX];
  TEST_ASSERT(sm_make_temp_file(path, content) == 0);
 
  srn_sm_t *sm = srn_sm_init(ctx);
 
  // Prime the allocator with poisoned chunks of the size the source manager
  // is about to request, otherwise a fresh page hides a missing terminator.
  unsigned char *poison[8];
  for (size_t i = 0; i < 8; i++) {
    poison[i] = srn_mm_malloc(ctx->engine->mm, len + 1);
    memset(poison[i], 0xFF, len + 1);
  }
  for (size_t i = 0; i < 8; i++) {
    srn_mm_free(ctx->engine->mm, poison[i]);
  }
 
  auto result = srn_sm_buffer_file(sm, path, false);
 
  TEST_NO_ERROR(result);
  ASSERT_NOT_NULL(result.buffer);
  TEST_CHECK(srn_sm_buffer_len(result.buffer) == len + 1);
  TEST_CHECK(memcmp(srn_sm_buffer_data(result.buffer), content, len) == 0);
  TEST_CHECK(srn_sm_buffer_data(result.buffer)[len] == '\0');
 
  srn_sm_shutdown(sm);
  unlink(path);
})
 
// Buffering the same path twice without reread returns the same buffer pointer
// and does not allocate a second buffer slot.
TEST_IN_FIBER(sm_buffer_same_file_no_reread, {
  char path[PATH_MAX];
  TEST_ASSERT(sm_make_temp_file(path, "data") == 0);
 
  srn_sm_t *sm = srn_sm_init(ctx);
 
  auto first  = srn_sm_buffer_file(sm, path, false);
  auto second = srn_sm_buffer_file(sm, path, false);
 
  TEST_NO_ERROR(first);
  TEST_NO_ERROR(second);
 
  TEST_CHECK(first.buffer == second.buffer);
  TEST_CHECK(sm->buffer_counts == 1);
 
  srn_sm_shutdown(sm);
  unlink(path);
})
 
// Buffering an empty file succeeds with `buffer->map == nullptr` and buffer_counts is still
// incremented.
TEST_IN_FIBER(sm_buffer_empty_file, {
  char path[PATH_MAX];
  TEST_ASSERT(sm_make_temp_file(path, "") == 0);
 
  srn_sm_t *sm = srn_sm_init(ctx);
  auto result  = srn_sm_buffer_file(sm, path, false);
 
  TEST_NO_ERROR(result);
  ASSERT_NULL(srn_sm_buffer_data(result.buffer));
  TEST_CHECK(sm->buffer_counts == 1);
 
  srn_sm_shutdown(sm);
  unlink(path);
})
 
// Buffering a path that does not exist returns a NOT_FOUND error and leaves buffer_counts
// unchanged.
TEST_IN_FIBER(sm_buffer_nonexistent_file, {
  srn_sm_t *sm = srn_sm_init(ctx);
  auto result  = srn_sm_buffer_file(sm, "/tmp/srn_does_not_exist_xyz123abc", false);
 
  ASSERT_NOT_NULL(result.maybe_error);
  TEST_CHECK(result.maybe_error->tag == NOT_FOUND);
  TEST_CHECK(sm->buffer_counts == 0);
 
  srn_sm_shutdown(sm);
})
 
// Buffering with reread == true replaces the head of the chain while keeping the old version
// accessible via next.
TEST_IN_FIBER(sm_buffer_reread, {
  char path[PATH_MAX];
  TEST_ASSERT(sm_make_temp_file(path, "version1") == 0);
 
  srn_sm_t *sm = srn_sm_init(ctx);
 
  auto first = srn_sm_buffer_file(sm, path, false);
  TEST_NO_ERROR(first);
  ASSERT_NOT_NULL(srn_sm_buffer_data(first.buffer));
 
  int fd = open(path, O_WRONLY | O_TRUNC);
  TEST_ASSERT(fd >= 0);
  TEST_ASSERT(write(fd, "version2", 8) == 8);
  close(fd);
 
  auto second = srn_sm_buffer_file(sm, path, true);
 
  TEST_NO_ERROR(second);
  ASSERT_NOT_NULL(srn_sm_buffer_data(second.buffer));
  TEST_CHECK(sm->buffer_counts == 1);
 
  // Head reflects the new content.
  TEST_CHECK(srn_sm_buffer_len(second.buffer) == 9);
  TEST_CHECK(memcmp(srn_sm_buffer_data(second.buffer), "version2", 8) == 0);
 
  TEST_CHECK(srn_sm_buffer_data(second.buffer) != srn_sm_buffer_data(second.buffer->next));
 
  // Old version is still reachable via next.
  ASSERT_NOT_NULL(second.buffer->next);
  TEST_CHECK(srn_sm_buffer_len(second.buffer->next) == 9);
  TEST_CHECK(memcmp(srn_sm_buffer_data(second.buffer->next), "version1", 8) == 0);
 
  srn_sm_shutdown(sm);
  unlink(path);
})
 
// srn_sm_get_buffer returns the buffer for a valid id, with correct data and
// filename. Uses srn_sm_read_buffer_file to obtain the id.
TEST_IN_FIBER(sm_get_buffer, {
  char path[PATH_MAX];
  TEST_ASSERT(sm_make_temp_file(path, "test content") == 0);
 
  srn_sm_t *sm = srn_sm_init(ctx);
  auto result  = srn_sm_read_buffer_file(sm, path, false);
  TEST_NO_ERROR(result);
 
  srn_sm_buffer_t *buf = srn_sm_get_buffer(sm, result.id);
  ASSERT_NOT_NULL(buf);
  TEST_CHECK(srn_sm_buffer_len(buf) == 13);
  TEST_CHECK(memcmp(srn_sm_buffer_data(buf), "test content", 12) == 0);
  TEST_CHECK(strcmp(buf->filename, path) == 0);
 
  srn_sm_shutdown(sm);
  unlink(path);
})
 
// A reread that cannot read the file reports the error and leaves the
// buffer as it was, instead of installing an empty head over the good one.
TEST_IN_FIBER(sm_reread_failure_keeps_buffer, {
  char path[PATH_MAX];
  TEST_ASSERT(sm_make_temp_file(path, "version1") == 0);
 
  srn_sm_t *sm = srn_sm_init(ctx);
  auto first   = srn_sm_buffer_file(sm, path, false);
  TEST_NO_ERROR(first);
 
  unlink(path);
  auto failed = srn_sm_buffer_file(sm, path, true);
  ASSERT_NOT_NULL(failed.maybe_error);
  TEST_CHECK(failed.maybe_error->tag == NOT_FOUND);
 
  auto again = srn_sm_buffer_file(sm, path, false);
  TEST_NO_ERROR(again);
  TEST_CHECK(again.buffer == first.buffer);
  TEST_CHECK(srn_sm_buffer_len(again.buffer) == 9);
  TEST_CHECK(memcmp(srn_sm_buffer_data(again.buffer), "version1", 8) == 0);
 
  srn_sm_shutdown(sm);
})
 
// The buffer keeps its own copy of the path, since buffers outlive the
// caller's string.
TEST_IN_FIBER(sm_filename_is_owned, {
  char path[PATH_MAX];
  TEST_ASSERT(sm_make_temp_file(path, "data") == 0);
 
  char scratch[PATH_MAX];
  (void)snprintf(scratch, sizeof(scratch), "%s", path);
 
  srn_sm_t *sm = srn_sm_init(ctx);
  auto result  = srn_sm_buffer_file(sm, scratch, false);
  TEST_NO_ERROR(result);
 
  memset(scratch, 'x', strlen(scratch));
  TEST_CHECK(strcmp(result.buffer->filename, path) == 0);
 
  srn_sm_shutdown(sm);
  unlink(path);
})
 
// A load refused for lack of buffer ids must leave the write lock free,
// otherwise the next new file load parks forever on it. The fiber sets `done`
// as its last step and the check runs after the scheduler returns, so a
// fiber that never comes back is a failure rather than a test with no checks.
static srn_fiber_result_t sm_id_exhaustion_fiber(srn_context_t *ctx, void *arg) {
  bool *done = arg;
  char path1[PATH_MAX];
  char path2[PATH_MAX];
  TEST_ASSERT(sm_make_temp_file(path1, "one") == 0);
  TEST_ASSERT(sm_make_temp_file(path2, "two") == 0);
 
  srn_sm_t *sm = srn_sm_init(ctx);
 
  sm->buffer_counts = UINT16_MAX;
  auto refused      = srn_sm_buffer_file(sm, path1, false);
  ASSERT_NOT_NULL(refused.maybe_error);
  TEST_CHECK(refused.maybe_error->tag == SM_BUFFER_ID_EXHAUSTED);
 
  sm->buffer_counts = 0;
  auto accepted     = srn_sm_buffer_file(sm, path2, false);
  TEST_NO_ERROR(accepted);
  TEST_CHECK(sm->buffer_counts == 1);
 
  srn_sm_shutdown(sm);
  unlink(path1);
  unlink(path2);
  *done = true;
  return nullptr;
}
 
static void test_sm_id_exhaustion_releases_lock() {
  MAKE_ENGINE(mm, engine);
  MAKE_CONTEXT(engine, ctx);
 
  bool done = false;
  srn_fiber_spawn(ctx, sm_id_exhaustion_fiber, &done);
  srn_sched_run(engine->scheduler, 1);
  TEST_CHECK(done);
 
  RELEASE_CONTEXT(ctx);
  SHUTDOWN_ENGINE(mm, engine);
}
 
// srn_sm_shutdown releases all buffer mappings and resets buffer_counts to 0.
TEST_IN_FIBER(sm_shutdown, {
  char path1[PATH_MAX];
  char path2[PATH_MAX];
  TEST_ASSERT(sm_make_temp_file(path1, "file one content") == 0);
  TEST_ASSERT(sm_make_temp_file(path2, "file two content") == 0);
 
  srn_sm_t *sm = srn_sm_init(ctx);
  TEST_NO_ERROR(srn_sm_buffer_file(sm, path1, false));
  TEST_NO_ERROR(srn_sm_buffer_file(sm, path2, false));
  TEST_CHECK(sm->buffer_counts == 2);
 
  srn_sm_shutdown(sm);
  TEST_CHECK(sm->buffer_counts == 0);
 
  unlink(path1);
  unlink(path2);
})