diff --git a/src/libexpr-c/nix_api_value.cc b/src/libexpr-c/nix_api_value.cc index 93e7db5c054..80e853b872d 100644 --- a/src/libexpr-c/nix_api_value.cc +++ b/src/libexpr-c/nix_api_value.cc @@ -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) diff --git a/src/libexpr-c/nix_api_value.h b/src/libexpr-c/nix_api_value.h index c42581278a0..42218188c09 100644 --- a/src/libexpr-c/nix_api_value.h +++ b/src/libexpr-c/nix_api_value.h @@ -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 diff --git a/tests/unit/libexpr-support/tests/nix_api_expr.hh b/tests/unit/libexpr-support/tests/nix_api_expr.hh index f63c0331930..d1840d03432 100644 --- a/tests/unit/libexpr-support/tests/nix_api_expr.hh +++ b/tests/unit/libexpr-support/tests/nix_api_expr.hh @@ -7,6 +7,7 @@ #include namespace nixC { + class nix_api_expr_test : public nix_api_store_test { protected: @@ -26,4 +27,5 @@ protected: EvalState * state; Value * value; }; + } diff --git a/tests/unit/libexpr/nix_api_external.cc b/tests/unit/libexpr/nix_api_external.cc index 68766fd4776..7e2caed1bd5 100644 --- a/tests/unit/libexpr/nix_api_external.cc +++ b/tests/unit/libexpr/nix_api_external.cc @@ -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); diff --git a/tests/unit/libexpr/nix_api_value.cc b/tests/unit/libexpr/nix_api_value.cc index 20c874f223f..7269606384a 100644 --- a/tests/unit/libexpr/nix_api_value.cc +++ b/tests/unit/libexpr/nix_api_value.cc @@ -14,132 +14,170 @@ namespace nixC { TEST_F(nix_api_expr_test, nix_value_set_get_int) { + ASSERT_EQ(0, nix_get_int(ctx, nullptr)); + ASSERT_DEATH(nix_get_int(ctx, value), ""); + int myInt = 1; - nix_init_int(nullptr, value, myInt); + nix_init_int(ctx, value, myInt); - 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)); + 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) { + ASSERT_FLOAT_EQ(0.0, nix_get_float(ctx, nullptr)); + ASSERT_DEATH(nix_get_float(ctx, value), ""); + float myDouble = 1.0; - nix_init_float(nullptr, value, myDouble); + nix_init_float(ctx, value, myDouble); - 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)); + 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) { + ASSERT_EQ(false, nix_get_bool(ctx, nullptr)); + ASSERT_DEATH(nix_get_bool(ctx, value), ""); + bool myBool = true; - nix_init_bool(nullptr, value, myBool); + nix_init_bool(ctx, value, myBool); - 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)); + 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) { + ASSERT_EQ(nullptr, nix_get_string(ctx, nullptr)); + ASSERT_DEATH(nix_get_string(ctx, value), ""); + const char * myString = "some string"; - nix_init_string(nullptr, value, myString); + nix_init_string(ctx, value, myString); - 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)); + 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), ""); + + nix_init_null(ctx, value); - ASSERT_STREQ("null", nix_get_typename(nullptr, value)); - ASSERT_EQ(NIX_TYPE_NULL, nix_get_type(nullptr, 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) { + ASSERT_EQ(nullptr, nix_get_path_string(ctx, nullptr)); + ASSERT_DEATH(nix_get_path_string(ctx, value), ""); + const char * p = "/nix/store/40s0qmrfb45vlh6610rk29ym318dswdr-myname"; - nix_init_path_string(nullptr, state, value, p); + nix_init_path_string(ctx, state, value, p); - 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)); + 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) { + ASSERT_EQ(nullptr, nix_get_list_byidx(ctx, nullptr, state, 0)); + ASSERT_EQ(0, nix_get_list_size(ctx, nullptr)); + + 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(nullptr, state, size); + ListBuilder * builder = nix_make_list_builder(ctx, state, size); - 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); + 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(nullptr, out_value); + nix_gc_decref(ctx, out_value); + + ASSERT_STREQ("a", nix_get_attr_name_byidx(ctx, value, state, 0)); - ASSERT_STREQ("a", nix_get_attr_name_byidx(nullptr, 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(nullptr, value, state, "b"); - ASSERT_STREQ("foo", nix_get_string(nullptr, out_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); - 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); }