symbol_tests.h File Reference

#include "base.h"
#include "serene/rt/core.h"
#include "serene/rt/namespaces.h"
#include "serene/rt/protocols.h"
#include "serene/rt/strings.h"
#include "serene/rt/symbols.h"

Include dependency graph for symbol_tests.h:

Go to the source code of this file.

Macros
#define	SYMBOL_TESTS(X)

Functions
static srn_namespace_t *	make_test_ns (srn_context_t *ctx)
static size_t	sym_table_len (srn_namespace_t *ns)
static void	test_symbol_make ()
static void	test_symbol_intern ()
static void	test_gensym ()
static void	test_gensym_freshness ()

Macro Definition Documentation

SYMBOL_TESTS

#define SYMBOL_TESTS

(

X

)

Value:

X("symbol::make", test_symbol_make), X("symbol::intern_symbol", test_symbol_intern), \
  X("symbol::gensym", test_gensym), X("symbol::gensym_freshness", test_gensym_freshness)

Definition at line 28 of file symbol_tests.h.

#define SYMBOL_TESTS(X)                                                                \
  X("symbol::make", test_symbol_make), X("symbol::intern_symbol", test_symbol_intern), \
    X("symbol::gensym", test_gensym), X("symbol::gensym_freshness", test_gensym_freshness)

Function Documentation

make_test_ns()

srn_namespace_t * make_test_ns ( srn_context_t * ctx )

static

Definition at line 33 of file symbol_tests.h.

                                                         {
  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(ctx->engine, AS_STRING(name), &err);
  TEST_ASSERT(ns != nullptr);
  return ns;
}

Here is the call graph for this function:

Here is the caller graph for this function:

sym_table_len()

size_t sym_table_len ( srn_namespace_t * ns )

static

Definition at line 41 of file symbol_tests.h.

{ return atomic_load(&ns->sym_table)->len; }

Here is the caller graph for this function:

test_gensym()

void test_gensym ( )

static

Definition at line 84 of file symbol_tests.h.

                          {
  MAKE_ENGINE(mm, engine);
  MAKE_CONTEXT(engine, ctx);
 
  srn_namespace_t *ns = make_test_ns(ctx);
 
  srn_value_t *sym1 = srn_symbol_gen(ctx, &absurd_metadata, ns, nullptr);
  srn_value_t *sym2 = srn_symbol_gen(ctx, &absurd_metadata, ns, nullptr);
 
  srn_value_t *sym1_name = srn_string_make(ctx, &absurd_metadata, "gensym_101");
  srn_value_t *sym2_name = srn_string_make(ctx, &absurd_metadata, "gensym_102");
 
  // gensym should intern the symbol
  TEST_CHECK(sym_table_len(ns) == 2);
 
  TEST_CHECK(IS_A(sym1, VSymbol));
  TEST_CHECK(IS_A(sym2, VSymbol));
 
  TEST_CHECK(srn_string_eq(AS_SYMBOL(sym1)->name, AS_STRING(sym1_name)));
  TEST_CHECK(srn_string_eq(AS_SYMBOL(sym2)->name, AS_STRING(sym2_name)));
 
  RELEASE_CONTEXT(ctx);
  SHUTDOWN_ENGINE(mm, engine);
}

Here is the call graph for this function:

test_gensym_freshness()

void test_gensym_freshness ( )

static

Definition at line 112 of file symbol_tests.h.

                                    {
  MAKE_ENGINE(mm, engine);
  MAKE_CONTEXT(engine, ctx);
 
  srn_namespace_t *ns = make_test_ns(ctx);
 
  // Occupy the exact spelling the next generated symbol would take. The
  // namespace consumed id 100, so the next object id is 101 (the counter
  // behavior symbol::gensym pins).
  srn_value_t *taken    = srn_string_make(ctx, &absurd_metadata, "gensym_101");
  srn_value_t *user_sym = srn_symbol_intern(ctx, &absurd_metadata, ns, AS_STRING(taken));
  TEST_CHECK(IS_A(user_sym, VSymbol));
 
  srn_value_t *g = srn_symbol_gen(ctx, &absurd_metadata, ns, nullptr);
  TEST_CHECK(IS_A(g, VSymbol));
 
  // Not the occupant, not its spelling, and interned alongside it.
  TEST_CHECK(g != user_sym);
  TEST_CHECK(!srn_string_eq(AS_SYMBOL(g)->name, AS_STRING(taken)));
  TEST_CHECK(sym_table_len(ns) == 2);
 
  RELEASE_CONTEXT(ctx);
  SHUTDOWN_ENGINE(mm, engine);
}

Here is the call graph for this function:

test_symbol_intern()

void test_symbol_intern ( )

static

Definition at line 60 of file symbol_tests.h.

                                 {
  MAKE_ENGINE(mm, engine);
  MAKE_CONTEXT(engine, ctx);
 
  srn_value_t *symname = srn_string_make(ctx, &absurd_metadata, "foo");
  srn_namespace_t *ns  = make_test_ns(ctx);
 
  srn_value_t *symbol = srn_symbol_intern(ctx, &absurd_metadata, ns, AS_STRING(symname));
 
  TEST_CHECK(sym_table_len(ns) == 1);
  TEST_CHECK(IS_A(symbol, VSymbol));
  TEST_CHECK(srn_string_eq(AS_SYMBOL(symbol)->name, AS_STRING(symname)));
 
  srn_value_t *symbol1 = srn_symbol_intern(ctx, &absurd_metadata, ns, AS_STRING(symname));
  TEST_CHECK(sym_table_len(ns) == 1);
  TEST_CHECK(IS_A(symbol1, VSymbol));
  TEST_CHECK(srn_string_eq(AS_SYMBOL(symbol1)->name, AS_STRING(symname)));
  srn_value_t *check = srn_value_eq(ctx, symbol, symbol1);
  TEST_CHECK(IS_TRUE(check));
 
  RELEASE_CONTEXT(ctx);
  SHUTDOWN_ENGINE(mm, engine);
}

Here is the call graph for this function:

test_symbol_make()

void test_symbol_make ( )

static

Definition at line 43 of file symbol_tests.h.

                               {
  MAKE_ENGINE(mm, engine);
  MAKE_CONTEXT(engine, ctx);
 
  srn_namespace_t *ns      = make_test_ns(ctx);
  srn_value_t *symbol_name = srn_string_make(ctx, &absurd_metadata, "foo");
  srn_value_t *sym         = srn_symbol_make(ctx, &absurd_metadata, ns, AS_STRING(symbol_name));
 
  TEST_CHECK(IS_A(sym, VSymbol));
  TEST_CHECK(AS_SYMBOL(sym)->ns == ns);
 
  TEST_CHECK(srn_string_eq(AS_SYMBOL(sym)->name, AS_STRING(symbol_name)));
 
  RELEASE_CONTEXT(ctx);
  SHUTDOWN_ENGINE(mm, engine);
}

Here is the call graph for this function: