max/nix-super
1
0
Fork 0
mirror of https://github.com/privatevoid-net/nix-super.git synced 2024-11-22 05:56:15 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

C API: add more tests

Browse source
This commit is contained in:
José Luis Lafuente 2024-03-29 14:00:19 +01:00
parent 2d84433a3b
commit 926fbadcc3
No known key found for this signature in database
GPG key ID: 8A3455EBE455489A
5 changed files with 112 additions and 72 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/libexpr-c/nix_api_value.cc
View file

@ -227,7 +227,7 @@ double nix_get_float(nix_c_context * context, const Value * value)
assert(v.type() == nix::nFloat);
return v.fpoint;
}
NIXC_CATCH_ERRS_RES(NAN);
NIXC_CATCH_ERRS_RES(0.0);
}
int64_t nix_get_int(nix_c_context * context, const Value * value)

6
src/libexpr-c/nix_api_value.h
View file

@ -136,8 +136,8 @@ nix_err nix_register_primop(nix_c_context * context, PrimOp * primOp);
* @return value, or null in case of errors
*
*/
Value * nix_alloc_value(nix_c_context * context, EvalState * state);
/** @addtogroup value_manip Manipulating values
* @brief Functions to inspect and change Nix language values, represented by Value.
* @{
@ -150,15 +150,14 @@ Value * nix_alloc_value(nix_c_context * context, EvalState * state);
* @param[in] value Nix value to inspect
* @return type of nix value
*/
ValueType nix_get_type(nix_c_context * context, const Value * value);
/** @brief Get type name of value as defined in the evaluator
* @param[out] context Optional, stores error information
* @param[in] value Nix value to inspect
* @return type name, owned string
* @todo way to free the result
*/
const char * nix_get_typename(nix_c_context * context, const Value * value);
/** @brief Get boolean value
@ -167,6 +166,7 @@ const char * nix_get_typename(nix_c_context * context, const Value * value);
* @return true or false, error info via context
*/
bool nix_get_bool(nix_c_context * context, const Value * value);
/** @brief Get string
* @param[out] context Optional, stores error information
* @param[in] value Nix value to inspect

2
tests/unit/libexpr-support/tests/nix_api_expr.hh
View file

@ -7,6 +7,7 @@
#include <gtest/gtest.h>
namespace nixC {
class nix_api_expr_test : public nix_api_store_test
{
protected:
@ -26,4 +27,5 @@ protected:
EvalState * state;
Value * value;
};
}

2
tests/unit/libexpr/nix_api_external.cc
View file

@ -44,7 +44,7 @@ TEST_F(nix_api_expr_test, nix_expr_eval_external)
{
MyExternalValueDesc * external = new MyExternalValueDesc(42);
ExternalValue * val = nix_create_external_value(ctx, external, external);
nix_init_external(nullptr, value, val);
nix_init_external(ctx, value, val);
EvalState * stateResult = nix_state_create(nullptr, nullptr, store);
Value * valueResult = nix_alloc_value(nullptr, stateResult);

172
tests/unit/libexpr/nix_api_value.cc
View file

@ -14,132 +14,170 @@ namespace nixC {
TEST_F(nix_api_expr_test, nix_value_set_get_int)
{
int myInt = 1;
nix_init_int(nullptr, value, myInt);
ASSERT_EQ(0, nix_get_int(ctx, nullptr));
ASSERT_DEATH(nix_get_int(ctx, value), "");
ASSERT_EQ(myInt, nix_get_int(nullptr, value));
ASSERT_STREQ("an integer", nix_get_typename(nullptr, value));
ASSERT_EQ(NIX_TYPE_INT, nix_get_type(nullptr, value));
int myInt = 1;
nix_init_int(ctx, value, myInt);
ASSERT_EQ(myInt, nix_get_int(ctx, value));
ASSERT_STREQ("an integer", nix_get_typename(ctx, value));
ASSERT_EQ(NIX_TYPE_INT, nix_get_type(ctx, value));
}
TEST_F(nix_api_expr_test, nix_value_set_get_float)
{
float myDouble = 1.0;
nix_init_float(nullptr, value, myDouble);
ASSERT_FLOAT_EQ(0.0, nix_get_float(ctx, nullptr));
ASSERT_DEATH(nix_get_float(ctx, value), "");
ASSERT_EQ(myDouble, nix_get_float(nullptr, value));
ASSERT_STREQ("a float", nix_get_typename(nullptr, value));
ASSERT_EQ(NIX_TYPE_FLOAT, nix_get_type(nullptr, value));
float myDouble = 1.0;
nix_init_float(ctx, value, myDouble);
ASSERT_FLOAT_EQ(myDouble, nix_get_float(ctx, value));
ASSERT_STREQ("a float", nix_get_typename(ctx, value));
ASSERT_EQ(NIX_TYPE_FLOAT, nix_get_type(ctx, value));
}
TEST_F(nix_api_expr_test, nix_value_set_get_bool)
{
bool myBool = true;
nix_init_bool(nullptr, value, myBool);
ASSERT_EQ(false, nix_get_bool(ctx, nullptr));
ASSERT_DEATH(nix_get_bool(ctx, value), "");
ASSERT_EQ(myBool, nix_get_bool(nullptr, value));
ASSERT_STREQ("a Boolean", nix_get_typename(nullptr, value));
ASSERT_EQ(NIX_TYPE_BOOL, nix_get_type(nullptr, value));
bool myBool = true;
nix_init_bool(ctx, value, myBool);
ASSERT_EQ(myBool, nix_get_bool(ctx, value));
ASSERT_STREQ("a Boolean", nix_get_typename(ctx, value));
ASSERT_EQ(NIX_TYPE_BOOL, nix_get_type(ctx, value));
}
TEST_F(nix_api_expr_test, nix_value_set_get_string)
{
const char * myString = "some string";
nix_init_string(nullptr, value, myString);
ASSERT_EQ(nullptr, nix_get_string(ctx, nullptr));
ASSERT_DEATH(nix_get_string(ctx, value), "");
ASSERT_STREQ(myString, nix_get_string(nullptr, value));
ASSERT_STREQ("a string", nix_get_typename(nullptr, value));
ASSERT_EQ(NIX_TYPE_STRING, nix_get_type(nullptr, value));
const char * myString = "some string";
nix_init_string(ctx, value, myString);
ASSERT_STREQ(myString, nix_get_string(ctx, value));
ASSERT_STREQ("a string", nix_get_typename(ctx, value));
ASSERT_EQ(NIX_TYPE_STRING, nix_get_type(ctx, value));
}
TEST_F(nix_api_expr_test, nix_value_set_get_null)
{
nix_init_null(nullptr, value);
ASSERT_DEATH(nix_get_typename(ctx, value), "");
ASSERT_STREQ("null", nix_get_typename(nullptr, value));
ASSERT_EQ(NIX_TYPE_NULL, nix_get_type(nullptr, value));
nix_init_null(ctx, value);
ASSERT_STREQ("null", nix_get_typename(ctx, value));
ASSERT_EQ(NIX_TYPE_NULL, nix_get_type(ctx, value));
}
TEST_F(nix_api_expr_test, nix_value_set_get_path)
{
const char * p = "/nix/store/40s0qmrfb45vlh6610rk29ym318dswdr-myname";
nix_init_path_string(nullptr, state, value, p);
ASSERT_EQ(nullptr, nix_get_path_string(ctx, nullptr));
ASSERT_DEATH(nix_get_path_string(ctx, value), "");
ASSERT_STREQ(p, nix_get_path_string(nullptr, value));
ASSERT_STREQ("a path", nix_get_typename(nullptr, value));
ASSERT_EQ(NIX_TYPE_PATH, nix_get_type(nullptr, value));
const char * p = "/nix/store/40s0qmrfb45vlh6610rk29ym318dswdr-myname";
nix_init_path_string(ctx, state, value, p);
ASSERT_STREQ(p, nix_get_path_string(ctx, value));
ASSERT_STREQ("a path", nix_get_typename(ctx, value));
ASSERT_EQ(NIX_TYPE_PATH, nix_get_type(ctx, value));
}
TEST_F(nix_api_expr_test, nix_build_and_init_list)
{
int size = 10;
ListBuilder * builder = nix_make_list_builder(nullptr, state, size);
ASSERT_EQ(nullptr, nix_get_list_byidx(ctx, nullptr, state, 0));
ASSERT_EQ(0, nix_get_list_size(ctx, nullptr));
Value * intValue = nix_alloc_value(nullptr, state);
nix_init_int(nullptr, intValue, 42);
nix_list_builder_insert(nullptr, builder, 0, intValue);
nix_make_list(nullptr, builder, value);
ASSERT_DEATH(nix_get_list_byidx(ctx, value, state, 0), "");
ASSERT_DEATH(nix_get_list_size(ctx, value), "");
int size = 10;
ListBuilder * builder = nix_make_list_builder(ctx, state, size);
Value * intValue = nix_alloc_value(ctx, state);
nix_init_int(ctx, intValue, 42);
nix_list_builder_insert(ctx, builder, 0, intValue);
nix_make_list(ctx, builder, value);
nix_list_builder_free(builder);
ASSERT_EQ(42, nix_get_int(nullptr, nix_get_list_byidx(nullptr, value, state, 0)));
ASSERT_EQ(nullptr, nix_get_list_byidx(nullptr, value, state, 1));
ASSERT_EQ(10, nix_get_list_size(nullptr, value));
ASSERT_EQ(42, nix_get_int(ctx, nix_get_list_byidx(ctx, value, state, 0)));
ASSERT_EQ(nullptr, nix_get_list_byidx(ctx, value, state, 1));
ASSERT_EQ(10, nix_get_list_size(ctx, value));
ASSERT_STREQ("a list", nix_get_typename(nullptr, value));
ASSERT_EQ(NIX_TYPE_LIST, nix_get_type(nullptr, value));
ASSERT_STREQ("a list", nix_get_typename(ctx, value));
ASSERT_EQ(NIX_TYPE_LIST, nix_get_type(ctx, value));
// Clean up
nix_gc_decref(nullptr, intValue);
nix_gc_decref(ctx, intValue);
}
TEST_F(nix_api_expr_test, nix_build_and_init_attr)
{
ASSERT_EQ(nullptr, nix_get_attr_byname(ctx, nullptr, state, 0));
ASSERT_EQ(nullptr, nix_get_attr_byidx(ctx, nullptr, state, 0, nullptr));
ASSERT_EQ(nullptr, nix_get_attr_name_byidx(ctx, nullptr, state, 0));
ASSERT_EQ(0, nix_get_attrs_size(ctx, nullptr));
ASSERT_EQ(false, nix_has_attr_byname(ctx, nullptr, state, "no-value"));
ASSERT_DEATH(nix_get_attr_byname(ctx, value, state, 0), "");
ASSERT_DEATH(nix_get_attr_byidx(ctx, value, state, 0, nullptr), "");
ASSERT_DEATH(nix_get_attr_name_byidx(ctx, value, state, 0), "");
ASSERT_DEATH(nix_get_attrs_size(ctx, value), "");
ASSERT_DEATH(nix_has_attr_byname(ctx, value, state, "no-value"), "");
int size = 10;
const char ** out_name = (const char **) malloc(sizeof(char *));
BindingsBuilder * builder = nix_make_bindings_builder(nullptr, state, size);
BindingsBuilder * builder = nix_make_bindings_builder(ctx, state, size);
Value * intValue = nix_alloc_value(nullptr, state);
nix_init_int(nullptr, intValue, 42);
Value * intValue = nix_alloc_value(ctx, state);
nix_init_int(ctx, intValue, 42);
Value * stringValue = nix_alloc_value(nullptr, state);
nix_init_string(nullptr, stringValue, "foo");
Value * stringValue = nix_alloc_value(ctx, state);
nix_init_string(ctx, stringValue, "foo");
nix_bindings_builder_insert(nullptr, builder, "a", intValue);
nix_bindings_builder_insert(nullptr, builder, "b", stringValue);
nix_make_attrs(nullptr, value, builder);
nix_bindings_builder_insert(ctx, builder, "a", intValue);
nix_bindings_builder_insert(ctx, builder, "b", stringValue);
nix_make_attrs(ctx, value, builder);
nix_bindings_builder_free(builder);
ASSERT_EQ(2, nix_get_attrs_size(nullptr, value));
ASSERT_EQ(2, nix_get_attrs_size(ctx, value));
Value * out_value = nix_get_attr_byname(nullptr, value, state, "a");
ASSERT_EQ(42, nix_get_int(nullptr, out_value));
nix_gc_decref(nullptr, out_value);
Value * out_value = nix_get_attr_byname(ctx, value, state, "a");
ASSERT_EQ(42, nix_get_int(ctx, out_value));
nix_gc_decref(ctx, out_value);
out_value = nix_get_attr_byidx(nullptr, value, state, 0, out_name);
ASSERT_EQ(42, nix_get_int(nullptr, out_value));
out_value = nix_get_attr_byidx(ctx, value, state, 0, out_name);
ASSERT_EQ(42, nix_get_int(ctx, out_value));
ASSERT_STREQ("a", *out_name);
nix_gc_decref(ctx, out_value);
ASSERT_STREQ("a", nix_get_attr_name_byidx(ctx, value, state, 0));
ASSERT_EQ(true, nix_has_attr_byname(ctx, value, state, "b"));
ASSERT_EQ(false, nix_has_attr_byname(ctx, value, state, "no-value"));
out_value = nix_get_attr_byname(ctx, value, state, "b");
ASSERT_STREQ("foo", nix_get_string(ctx, out_value));
nix_gc_decref(nullptr, out_value);
ASSERT_STREQ("a", nix_get_attr_name_byidx(nullptr, value, state, 0));
out_value = nix_get_attr_byname(nullptr, value, state, "b");
ASSERT_STREQ("foo", nix_get_string(nullptr, out_value));
nix_gc_decref(nullptr, out_value);
out_value = nix_get_attr_byidx(nullptr, value, state, 1, out_name);
ASSERT_STREQ("foo", nix_get_string(nullptr, out_value));
out_value = nix_get_attr_byidx(ctx, value, state, 1, out_name);
ASSERT_STREQ("foo", nix_get_string(ctx, out_value));
ASSERT_STREQ("b", *out_name);
nix_gc_decref(nullptr, out_value);
ASSERT_STREQ("b", nix_get_attr_name_byidx(nullptr, value, state, 1));
ASSERT_STREQ("b", nix_get_attr_name_byidx(ctx, value, state, 1));
ASSERT_STREQ("a set", nix_get_typename(nullptr, value));
ASSERT_EQ(NIX_TYPE_ATTRS, nix_get_type(nullptr, value));
ASSERT_STREQ("a set", nix_get_typename(ctx, value));
ASSERT_EQ(NIX_TYPE_ATTRS, nix_get_type(ctx, value));
// Clean up
nix_gc_decref(nullptr, intValue);
nix_gc_decref(nullptr, stringValue);
nix_gc_decref(ctx, intValue);
nix_gc_decref(ctx, stringValue);
free(out_name);
}