value_tests.h

Go to the documentation of this file.

/* -*- C -*-
 * Serene programming language
 * Copyright (C) 2019-2026 Sameer Rahmani <[email protected]>
 *
 * 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 <serene/rt/core.h>
#include <serene/rt/core/numbers.h>
#include <serene/rt/lists.h>
#include <serene/rt/maps.h>
#include <serene/rt/protocols.h>
 
#include "base.h"
 
#define VALUE_TESTS(X)                                                  \
  X("values::basics", test_value_basics),                               \
    X("values::f64_zero_eq_hash", test_value_f64_zero_eq_hash),         \
    X("values::list_cons_type_check", test_value_list_cons_type_check), \
    X("values::map_unhashable_key", test_value_map_unhashable_key),
 
#if defined(V_DEBUG)
#  define V_TEST_LOG(...) DBG("VALUE_TEST", __VA_ARGS__)
#else
#  define V_TEST_LOG(...)
#endif
 
static void test_value_basics() {
  MAKE_ENGINE(mm, engine);
  MAKE_CONTEXT(engine, ctx);
 
  srn_value_t *x1 = srn_make_i64(ctx, &absurd_metadata, 5);
  srn_value_t *x2 = srn_make_i64(ctx, &absurd_metadata, -15);
 
  TEST_CHECK(x1->type == VI64);
  TEST_CHECK(x1->as.i64 == 5);
  TEST_CHECK(x2->as.i64 == -15);
 
  RELEASE_CONTEXT(ctx);
  SHUTDOWN_ENGINE(mm, engine);
}
 
/// IEEE equality makes +0.0 and -0.0 equal, so the documented eq => hash
/// invariant requires them to hash the same despite different bit patterns.
static void test_value_f64_zero_eq_hash() {
  MAKE_ENGINE(mm, engine);
  MAKE_CONTEXT(engine, ctx);
 
  srn_value_t pos = {.type = VF64, .metadata = &absurd_metadata, .as = {.f64 = 0.0}};
  srn_value_t neg = {.type = VF64, .metadata = &absurd_metadata, .as = {.f64 = -0.0}};
 
  TEST_CHECK(TYPE(srn_value_eq(ctx, &pos, &neg)) == VTrue);
  TEST_CHECK(srn_value_hash(ctx, &pos) == srn_value_hash(ctx, &neg));
 
  RELEASE_CONTEXT(ctx);
  SHUTDOWN_ENGINE(mm, engine);
}
 
/// Consing onto a value that is neither nil nor a list must produce an error
/// value, not reinterpret the payload as a list pointer.
static void test_value_list_cons_type_check() {
  MAKE_ENGINE(mm, engine);
  MAKE_CONTEXT(engine, ctx);
 
  srn_value_t *not_a_list = srn_make_i64(ctx, &absurd_metadata, 42);
  srn_value_t *x          = srn_make_i64(ctx, &absurd_metadata, 1);
 
  srn_value_t *res = srn_list_cons(ctx, &absurd_metadata, x, not_a_list);
  TEST_CHECK(TYPE(res) == VError);
 
  RELEASE_CONTEXT(ctx);
  SHUTDOWN_ENGINE(mm, engine);
}
 
/// A key the hash protocol cannot hash must come back as an error value from
/// assoc, not abort the process from inside srn_value_hash.
static void test_value_map_unhashable_key() {
  MAKE_ENGINE(mm, engine);
  MAKE_CONTEXT(engine, ctx);
 
  srn_value_t *m = srn_map_empty(ctx, &absurd_metadata);
  TEST_ASSERT(TYPE(m) == VMap);
 
  srn_value_t *item = srn_make_i64(ctx, &absurd_metadata, 7);
  srn_value_t *lst  = srn_list_make(ctx, &absurd_metadata, &item, 1);
  srn_value_t *val  = srn_make_i64(ctx, &absurd_metadata, 9);
 
  srn_value_t *res = srn_map_assoc(ctx, &absurd_metadata, m, lst, val);
  TEST_CHECK(TYPE(res) == VError);
 
  RELEASE_CONTEXT(ctx);
  SHUTDOWN_ENGINE(mm, engine);
}