From c59aeef2e0c86ec3f0f34ce77c205f3ef0b034cc Mon Sep 17 00:00:00 2001 From: "Claudius \"keldu\" Holeksa" Date: Sun, 8 Nov 2026 22:04:06 +0100 Subject: Abstract move. Forstio independence --- modules/core/tests/abstract_foundation.cpp | 189 +++++++++++++++++++++++++++++ 1 file changed, 189 insertions(+) create mode 100644 modules/core/tests/abstract_foundation.cpp (limited to 'modules/core/tests/abstract_foundation.cpp') diff --git a/modules/core/tests/abstract_foundation.cpp b/modules/core/tests/abstract_foundation.cpp new file mode 100644 index 0000000..aea967d --- /dev/null +++ b/modules/core/tests/abstract_foundation.cpp @@ -0,0 +1,189 @@ +#include + +#include "../c++/abstract/common.hpp" +#include "../c++/abstract/error.hpp" +#include "../c++/abstract/schema.hpp" +#include "../c++/abstract/stringify_schema.hpp" +#include "../c++/abstract/templates.hpp" + +namespace { +namespace ts { +using namespace kel::lbm::sch; +} + +SAW_TEST("Abstract/Templates/CtMultiply"){ + using namespace kel::lbm; + + static_assert(ct_multiply::value == 1u, "empty pack is the identity"); + static_assert(ct_multiply::value == 3u, ""); + static_assert(ct_multiply::value == 24u, ""); +} + +SAW_TEST("Abstract/Templates/ParameterPack"){ + using namespace kel::lbm; + + static_assert(std::is_same_v::type, int>, ""); + static_assert(std::is_same_v::type, bool>, ""); + + static_assert(parameter_pack_index::value == 1u, ""); + + static_assert(parameter_pack_value<1u, uint64_t, 7u, 9u, 11u>::value == 9u, ""); +} + +SAW_TEST("Abstract/Templates/KeyPack"){ + using namespace kel::lbm; + + static_assert(parameter_key_pack_index<"b", "a", "b", "c">::value == 1u, ""); + static_assert(parameter_key_pack_type<2u, "a", "b", "c">::literal == string_literal{"c"}, ""); +} + +SAW_TEST("Abstract/Templates/DigitConversion"){ + using namespace kel::lbm; + + static_assert(ct_convert_to_digits<0u,10u>::literal == string_literal{"0"}, ""); + static_assert(ct_convert_to_digits<7u,10u>::literal == string_literal{"7"}, ""); + static_assert(ct_convert_to_digits<1024u,10u>::literal == string_literal{"1024"}, ""); +} + +SAW_TEST("Abstract/StringLiteral/Concat"){ + using namespace kel::lbm; + + static_assert((string_literal{"foo"} + string_literal{"bar"}) == string_literal{"foobar"}, ""); + static_assert(string_literal{"foo"}.view() == std::string_view{"foo"}, ""); +} + +SAW_TEST("Abstract/Schema/Meta"){ + using namespace kel::lbm; + + // Compile time shapes carry nothing at runtime. + static_assert(std::is_same_v, ""); + static_assert(std::is_same_v::Meta, ts::Void>, ""); + + // A dynamically sized Array is described by its extents. + static_assert(std::is_same_v< + ts::Array::Meta, + ts::FixedArray>, ""); + + // A String is described by its length. + static_assert(std::is_same_v, ""); + + // A Tensor is addressed through a rank sized index. + static_assert(std::is_same_v< + ts::Vector::Meta, + ts::FixedArray>, ""); + static_assert(std::is_same_v< + ts::Scalar::Meta, + ts::FixedArray>, ""); + + // Structural schemas recurse into their members. + using TStruct = ts::Struct< + ts::Member, + ts::Member,"values"> + >; + static_assert(std::is_same_v< + TStruct::Meta, + ts::Struct< + ts::Member, + ts::Member,"values"> + >>, ""); + + static_assert(std::is_same_v< + ts::Tuple::Meta, + ts::Tuple>, ""); +} + +SAW_TEST("Abstract/Schema/PrimitiveShape"){ + using namespace kel::lbm; + + static_assert(ts::UInt64::Bytes == 8u, ""); + static_assert(std::is_same_v, ""); + static_assert(std::is_same_v, ""); + static_assert(std::is_same_v, ""); + + using TMixed = ts::MixedPrecision; + static_assert(std::is_same_v, ""); + static_assert(std::is_same_v, ""); + + static_assert(ts::FixedArray::FlatSize == 6u, ""); + static_assert(ts::FixedArray::Rank == 2u, ""); + static_assert(ts::Scalar::FlatSize == 1u, "rank zero holds one element"); +} + +SAW_TEST("Abstract/SchemaStringify/Primitive"){ + using namespace kel::lbm; + + static_assert(schema_to_string::literal + == string_literal{"Primitive"}, ""); + static_assert(schema_to_string::literal + == string_literal{"Primitive"}, ""); +} + +SAW_TEST("Abstract/SchemaStringify/Composite"){ + using namespace kel::lbm; + + static_assert(schema_to_string>::literal + == string_literal{"FixedArray,2,3>"}, ""); + + static_assert(schema_to_string>::literal + == string_literal{"Tuple"}, ""); +} + +SAW_TEST("Abstract/Error/MakeError"){ + using namespace kel::lbm; + + auto err = make_error("missing thing"); + SAW_EXPECT(err.failed(), "a not_found is an error"); + SAW_EXPECT(err.is_recoverable(), "not_found is recoverable"); + SAW_EXPECT(err.is_type(), "error keeps its type"); + SAW_EXPECT(!err.is_type(), "and is distinguishable"); + SAW_EXPECT(err.get_message() == std::string_view{"missing thing"}, "message survives"); +} + +SAW_TEST("Abstract/Error/Critical"){ + using namespace kel::lbm; + + auto err = make_error(); + SAW_EXPECT(err.is_critical(), "out_of_memory is critical"); + SAW_EXPECT(!err.is_recoverable(), "and therefore not recoverable"); +} + +SAW_TEST("Abstract/Error/ErrorOr"){ + using namespace kel::lbm; + + error_or good{uint64_t{42u}}; + SAW_EXPECT(good.is_value(), "holds a value"); + SAW_EXPECT(!good.is_error(), "and not an error"); + SAW_EXPECT(good.get_value() == 42u, "value round trips"); + + error_or bad{make_error()}; + SAW_EXPECT(bad.is_error(), "holds an error"); + SAW_EXPECT(!bad.is_value(), "and not a value"); + SAW_EXPECT(bad.get_error().is_type(), "error type survives"); +} + +SAW_TEST("Abstract/Error/VoidPath"){ + using namespace kel::lbm; + + error_or ok{make_void()}; + SAW_EXPECT(ok.is_value(), "make_void is a value, not an error"); +} + +SAW_TEST("Abstract/Common/Pointers"){ + using namespace kel::lbm; + + auto owned = heap(7u); + SAW_EXPECT(*owned == 7u, "heap constructs in place"); + + ptr empty; + SAW_EXPECT(!empty.is_valid(), "a default ptr is empty"); + + uint64_t backing = 3u; + ptr filled{backing}; + SAW_EXPECT(filled.is_valid(), "a bound ptr is valid"); + SAW_EXPECT(filled() == 3u, "and reads through"); + + ref r{backing}; + r() = 9u; + SAW_EXPECT(backing == 9u, "ref writes through to its referent"); +} +} -- cgit v1.3.1