ns_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 "base.h"
#include "serene/rt/core.h"
#include "serene/rt/fiber.h"
#include "serene/rt/namespaces.h"
#include "serene/rt/protocols.h"
#include "serene/rt/strings.h"
#include "serene/rt/symbols.h"
#include "serene/runtime.h"
 
#define NS_TESTS(X)                                         \
  X("namespace::get_or_create", test_ns_get_or_create),     \
    X("namespace::get_or_create_twice", test_ns_get_twice), \
    X("config::wiring", test_config_wiring), X("config::runtime_macros", test_runtime_macros)
 
static void test_ns_get_or_create() {
  MAKE_ENGINE(mm, engine);
  MAKE_CONTEXT(engine, ctx);
 
  srn_value_t *name   = srn_string_make(ctx, &absurd_metadata, "serene.tests");
  srn_error_t *err    = nullptr;
  srn_namespace_t *ns = srn_namespace_get_or_create(engine, AS_STRING(name), &err);
 
  TEST_ASSERT(ns != nullptr);
  TEST_CHECK(err == nullptr);
  // ns should has it's own context
  TEST_CHECK(ns->root_context != ctx);
  TEST_CHECK(atomic_load(&ns->sym_table)->len == 0);
  TEST_CHECK(ns->node == nullptr);
  TEST_CHECK(srn_string_eq(ns->name, AS_STRING(name)));
 
  // Creation registers the namespace with the engine.
  TEST_CHECK(atomic_load(&engine->namespaces)->len == 1);
  TEST_CHECK(srn_context_find_namespace(ctx, "serene.tests") == ns);
 
  RELEASE_CONTEXT(ctx);
  SHUTDOWN_ENGINE(mm, engine);
}
 
// A second call with the same name returns the registered namespace rather
// than a new one.
static void test_ns_get_twice() {
  MAKE_ENGINE(mm, engine);
  MAKE_CONTEXT(engine, ctx);
 
  srn_value_t *name    = srn_string_make(ctx, &absurd_metadata, "serene.tests");
  srn_error_t *err     = nullptr;
  srn_namespace_t *ns1 = srn_namespace_get_or_create(engine, AS_STRING(name), &err);
  srn_namespace_t *ns2 = srn_namespace_get_or_create(engine, AS_STRING(name), &err);
 
  TEST_ASSERT(ns1 != nullptr);
  TEST_CHECK(ns1 == ns2);
  TEST_CHECK(atomic_load(&engine->namespaces)->len == 1);
 
  // A different name is a different namespace.
  srn_value_t *other   = srn_string_make(ctx, &absurd_metadata, "serene.other");
  srn_namespace_t *ns3 = srn_namespace_get_or_create(engine, AS_STRING(other), &err);
  TEST_CHECK(ns3 != ns1);
  TEST_CHECK(atomic_load(&engine->namespaces)->len == 2);
  TEST_CHECK(srn_context_find_namespace(ctx, "serene.other") == ns3);
  TEST_CHECK(srn_context_find_namespace(ctx, "serene.missing") == nullptr);
 
  RELEASE_CONTEXT(ctx);
  SHUTDOWN_ENGINE(mm, engine);
}
 
static srn_fiber_result_t config_wiring_fiber_entry(srn_context_t *ctx, void *arg) {
  UNUSED(ctx);
  UNUSED(arg);
  return nullptr;
}
 
// Every configuration knob is read from the configuration, the MM block size
// at srn_mm_init, the per fiber stack default, and the string and namespace
// length limits.
static void test_config_wiring() {
  srn_configuration_t cfg     = SRN_CONFIG_DEFAULTS;
  cfg.mm.block_size_magnitude = 18; // 256 KiB
  cfg.fiber.stack_size        = 256U * 1024U;
  cfg.limits.string_max_len   = 8;
  cfg.limits.ns_name_max_len  = 4;
 
  srn_mm_t *mm = srn_mm_init(&cfg);
  TEST_ASSERT(mm != nullptr);
  TEST_CHECK(mm->block_size == ((size_t)1 << 18));
 
  srn_engine_t *engine = srn_engine_make(mm, &cfg);
  TEST_ASSERT(engine != nullptr);
  MAKE_CONTEXT(engine, ctx);
 
  // A keyword name reaching the configured string limit fails as an error
  // value; a short one interns.
  /* srn_value_t *too_long = srn_engine_intern_keyword(ctx, &absurd_metadata, "waytoolongforthis");
   */
  /* TEST_CHECK(TYPE(too_long) == VError); */
  /* srn_value_t *ok = srn_engine_intern_keyword(ctx, &absurd_metadata, "ok"); */
  /* TEST_CHECK(TYPE(ok) == VKeyword); */
 
  // A namespace name within the configured limit is accepted. Names over the
  // limit panic in `srn_namespace_get_or_create`, which this harness cannot
  // observe.
  srn_value_t *ns_name = srn_string_make(ctx, &absurd_metadata, "four");
  TEST_ASSERT(TYPE(ns_name) == VString);
  srn_error_t *err    = nullptr;
  srn_namespace_t *ns = srn_namespace_get_or_create(engine, AS_STRING(ns_name), &err);
  TEST_CHECK(ns != nullptr);
 
  // A zero per fiber stack size falls back to the configured default.
  srn_fiber_t *f = srn_fiber_spawn(ctx, config_wiring_fiber_entry, nullptr);
  TEST_ASSERT(f != nullptr);
  TEST_CHECK(srn_fiber_stack_size(f->stack) >= 256U * 1024U);
 
  // Reap the never-run fiber while its struct (in the context block) is
  // still alive, before the context that owns it is released.
  srn_sched_shutdown(engine->scheduler);
 
  RELEASE_CONTEXT(ctx);
  SHUTDOWN_ENGINE(mm, engine);
}
 
// The bootstrap macros bring the whole runtime up and down, mm plus engine
// from one config, the scheduler bound, and a teardown that reclaims every
// context chain through the manager.
static void test_runtime_macros() {
  SERENE_RUNTIME_INIT_WITH_SCHED(engine, sched, nullptr);
  MAKE_CONTEXT(engine, ctx);
 
  (void)srn_fiber_spawn(ctx, config_wiring_fiber_entry, nullptr);
  srn_sched_run(sched, 1);
 
  RELEASE_CONTEXT(ctx);
  SERENE_RUNTIME_SHUTDOWN(engine);
}