update all names in repo to match new bindings
This commit is contained in:
parent
54511d9c23
commit
25af468680
GPG key ID:
F68745A836CA0412
29 changed files with 526 additions and 559 deletions
|
|
@ -1,13 +1,12 @@
|
|||
#![cfg(feature = "nix-expr-c")]
|
||||
#![cfg(test)]
|
||||
|
||||
use std::{
|
||||
ffi::{CStr, CString},
|
||||
ptr,
|
||||
};
|
||||
use std::ffi::{CStr, CString};
|
||||
use std::ptr;
|
||||
|
||||
use serial_test::serial;
|
||||
|
||||
use nixide_sys::*;
|
||||
use serial_test::serial;
|
||||
|
||||
#[test]
|
||||
#[serial]
|
||||
|
|
@ -16,13 +15,13 @@ fn eval_init_and_state_build() {
|
|||
let ctx = nix_c_context_create();
|
||||
assert!(!ctx.is_null());
|
||||
let err = nix_libutil_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK, "nix_libutil_init failed: {err}");
|
||||
assert_eq!(err, NixErr::Ok, "nix_libutil_init failed: {err}");
|
||||
|
||||
let err = nix_libstore_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK, "nix_libstore_init failed: {err}");
|
||||
assert_eq!(err, NixErr::Ok, "nix_libstore_init failed: {err}");
|
||||
|
||||
let err = nix_libexpr_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK, "nix_libexpr_init failed: {err}");
|
||||
assert_eq!(err, NixErr::Ok, "nix_libexpr_init failed: {err}");
|
||||
|
||||
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
|
||||
assert!(!store.is_null());
|
||||
|
|
@ -31,7 +30,7 @@ fn eval_init_and_state_build() {
|
|||
assert!(!builder.is_null());
|
||||
|
||||
let load_err = nix_eval_state_builder_load(ctx, builder);
|
||||
assert_eq!(load_err, nix_err_NIX_OK);
|
||||
assert_eq!(load_err, NixErr::Ok);
|
||||
|
||||
let state = nix_eval_state_build(ctx, builder);
|
||||
assert!(!state.is_null());
|
||||
|
|
@ -51,20 +50,20 @@ fn eval_simple_expression() {
|
|||
assert!(!ctx.is_null());
|
||||
|
||||
let err = nix_libutil_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK, "nix_libutil_init failed: {err}");
|
||||
assert_eq!(err, NixErr::Ok, "nix_libutil_init failed: {err}");
|
||||
|
||||
let err = nix_libstore_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK, "nix_libstore_init failed: {err}");
|
||||
assert_eq!(err, NixErr::Ok, "nix_libstore_init failed: {err}");
|
||||
|
||||
let err = nix_libexpr_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK, "nix_libexpr_init failed: {err}");
|
||||
assert_eq!(err, NixErr::Ok, "nix_libexpr_init failed: {err}");
|
||||
|
||||
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
|
||||
assert!(!store.is_null());
|
||||
|
||||
let builder = nix_eval_state_builder_new(ctx, store);
|
||||
assert!(!builder.is_null());
|
||||
assert_eq!(nix_eval_state_builder_load(ctx, builder), nix_err_NIX_OK);
|
||||
assert_eq!(nix_eval_state_builder_load(ctx, builder), NixErr::Ok);
|
||||
|
||||
let state = nix_eval_state_build(ctx, builder);
|
||||
assert!(!state.is_null());
|
||||
|
|
@ -76,11 +75,11 @@ fn eval_simple_expression() {
|
|||
assert!(!value.is_null());
|
||||
|
||||
let eval_err = nix_expr_eval_from_string(ctx, state, expr.as_ptr(), path.as_ptr(), value);
|
||||
assert_eq!(eval_err, nix_err_NIX_OK);
|
||||
assert_eq!(eval_err, NixErr::Ok);
|
||||
|
||||
// Force the value (should not be a thunk)
|
||||
let force_err = nix_value_force(ctx, state, value);
|
||||
assert_eq!(force_err, nix_err_NIX_OK);
|
||||
assert_eq!(force_err, NixErr::Ok);
|
||||
|
||||
nix_state_free(state);
|
||||
nix_eval_state_builder_free(builder);
|
||||
|
|
@ -96,25 +95,25 @@ fn value_construction_and_inspection() {
|
|||
let ctx = nix_c_context_create();
|
||||
assert!(!ctx.is_null());
|
||||
let err = nix_libutil_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
let err = nix_libstore_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
let err = nix_libexpr_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
|
||||
assert!(!store.is_null());
|
||||
let builder = nix_eval_state_builder_new(ctx, store);
|
||||
assert!(!builder.is_null());
|
||||
assert_eq!(nix_eval_state_builder_load(ctx, builder), nix_err_NIX_OK);
|
||||
assert_eq!(nix_eval_state_builder_load(ctx, builder), NixErr::Ok);
|
||||
let state = nix_eval_state_build(ctx, builder);
|
||||
assert!(!state.is_null());
|
||||
|
||||
// Int
|
||||
let int_val = nix_alloc_value(ctx, state);
|
||||
assert!(!int_val.is_null());
|
||||
assert_eq!(nix_init_int(ctx, int_val, 42), nix_err_NIX_OK);
|
||||
assert_eq!(nix_get_type(ctx, int_val), ValueType_NIX_TYPE_INT);
|
||||
assert_eq!(nix_init_int(ctx, int_val, 42), NixErr::Ok);
|
||||
assert_eq!(nix_get_type(ctx, int_val), ValueType::Int);
|
||||
assert_eq!(nix_get_int(ctx, int_val), 42);
|
||||
|
||||
// Float
|
||||
|
|
@ -122,30 +121,30 @@ fn value_construction_and_inspection() {
|
|||
assert!(!float_val.is_null());
|
||||
assert_eq!(
|
||||
nix_init_float(ctx, float_val, std::f64::consts::PI),
|
||||
nix_err_NIX_OK
|
||||
NixErr::Ok
|
||||
);
|
||||
assert_eq!(nix_get_type(ctx, float_val), ValueType_NIX_TYPE_FLOAT);
|
||||
assert_eq!(nix_get_type(ctx, float_val), ValueType::Float);
|
||||
assert!((nix_get_float(ctx, float_val) - std::f64::consts::PI).abs() < 1e-10);
|
||||
|
||||
// Bool
|
||||
let bool_val = nix_alloc_value(ctx, state);
|
||||
assert!(!bool_val.is_null());
|
||||
assert_eq!(nix_init_bool(ctx, bool_val, true), nix_err_NIX_OK);
|
||||
assert_eq!(nix_get_type(ctx, bool_val), ValueType_NIX_TYPE_BOOL);
|
||||
assert_eq!(nix_init_bool(ctx, bool_val, true), NixErr::Ok);
|
||||
assert_eq!(nix_get_type(ctx, bool_val), ValueType::Bool);
|
||||
assert!(nix_get_bool(ctx, bool_val));
|
||||
|
||||
// Null
|
||||
let null_val = nix_alloc_value(ctx, state);
|
||||
assert!(!null_val.is_null());
|
||||
assert_eq!(nix_init_null(ctx, null_val), nix_err_NIX_OK);
|
||||
assert_eq!(nix_get_type(ctx, null_val), ValueType_NIX_TYPE_NULL);
|
||||
assert_eq!(nix_init_null(ctx, null_val), NixErr::Ok);
|
||||
assert_eq!(nix_get_type(ctx, null_val), ValueType::Null);
|
||||
|
||||
// String
|
||||
let string_val = nix_alloc_value(ctx, state);
|
||||
assert!(!string_val.is_null());
|
||||
let s = CString::new("hello world").unwrap();
|
||||
assert_eq!(nix_init_string(ctx, string_val, s.as_ptr()), nix_err_NIX_OK);
|
||||
assert_eq!(nix_get_type(ctx, string_val), ValueType_NIX_TYPE_STRING);
|
||||
assert_eq!(nix_init_string(ctx, string_val, s.as_ptr()), NixErr::Ok);
|
||||
assert_eq!(nix_get_type(ctx, string_val), ValueType::String);
|
||||
extern "C" fn string_cb(
|
||||
start: *const ::std::os::raw::c_char,
|
||||
n: ::std::os::raw::c_uint,
|
||||
|
|
@ -159,7 +158,7 @@ fn value_construction_and_inspection() {
|
|||
let mut got: Option<String> = None;
|
||||
assert_eq!(
|
||||
nix_get_string(ctx, string_val, Some(string_cb), (&raw mut got).cast()),
|
||||
nix_err_NIX_OK
|
||||
NixErr::Ok
|
||||
);
|
||||
assert_eq!(got.as_deref(), Some("hello world"));
|
||||
|
||||
|
|
@ -169,9 +168,9 @@ fn value_construction_and_inspection() {
|
|||
let p = CString::new("/nix/store/foo").unwrap();
|
||||
assert_eq!(
|
||||
nix_init_path_string(ctx, state, path_val, p.as_ptr()),
|
||||
nix_err_NIX_OK
|
||||
NixErr::Ok
|
||||
);
|
||||
assert_eq!(nix_get_type(ctx, path_val), ValueType_NIX_TYPE_PATH);
|
||||
assert_eq!(nix_get_type(ctx, path_val), ValueType::Path);
|
||||
let path_ptr = nix_get_path_string(ctx, path_val);
|
||||
assert!(!path_ptr.is_null());
|
||||
let path_str = CStr::from_ptr(path_ptr).to_string_lossy();
|
||||
|
|
@ -192,17 +191,17 @@ fn list_and_attrset_manipulation() {
|
|||
let ctx = nix_c_context_create();
|
||||
assert!(!ctx.is_null());
|
||||
let err = nix_libutil_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
let err = nix_libstore_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
let err = nix_libexpr_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
|
||||
assert!(!store.is_null());
|
||||
let builder = nix_eval_state_builder_new(ctx, store);
|
||||
assert!(!builder.is_null());
|
||||
assert_eq!(nix_eval_state_builder_load(ctx, builder), nix_err_NIX_OK);
|
||||
assert_eq!(nix_eval_state_builder_load(ctx, builder), NixErr::Ok);
|
||||
let state = nix_eval_state_build(ctx, builder);
|
||||
assert!(!state.is_null());
|
||||
|
||||
|
|
@ -220,15 +219,15 @@ fn list_and_attrset_manipulation() {
|
|||
nix_list_builder_insert(ctx, list_builder, 2, v3);
|
||||
|
||||
let list_val = nix_alloc_value(ctx, state);
|
||||
assert_eq!(nix_make_list(ctx, list_builder, list_val), nix_err_NIX_OK);
|
||||
assert_eq!(nix_get_type(ctx, list_val), ValueType_NIX_TYPE_LIST);
|
||||
assert_eq!(nix_make_list(ctx, list_builder, list_val), NixErr::Ok);
|
||||
assert_eq!(nix_get_type(ctx, list_val), ValueType::List);
|
||||
assert_eq!(nix_get_list_size(ctx, list_val), 3);
|
||||
|
||||
// Get elements by index
|
||||
for i in 0..3 {
|
||||
let elem = nix_get_list_byidx(ctx, list_val, state, i);
|
||||
assert!(!elem.is_null());
|
||||
assert_eq!(nix_get_type(ctx, elem), ValueType_NIX_TYPE_INT);
|
||||
assert_eq!(nix_get_type(ctx, elem), ValueType::Int);
|
||||
assert_eq!(nix_get_int(ctx, elem), i64::from(i + 1));
|
||||
}
|
||||
|
||||
|
|
@ -248,19 +247,19 @@ fn list_and_attrset_manipulation() {
|
|||
nix_bindings_builder_insert(ctx, attr_builder, bar.as_ptr(), bar_val);
|
||||
|
||||
let attr_val = nix_alloc_value(ctx, state);
|
||||
assert_eq!(nix_make_attrs(ctx, attr_val, attr_builder), nix_err_NIX_OK);
|
||||
assert_eq!(nix_get_type(ctx, attr_val), ValueType_NIX_TYPE_ATTRS);
|
||||
assert_eq!(nix_make_attrs(ctx, attr_val, attr_builder), NixErr::Ok);
|
||||
assert_eq!(nix_get_type(ctx, attr_val), ValueType::Attrs);
|
||||
assert_eq!(nix_get_attrs_size(ctx, attr_val), 2);
|
||||
|
||||
// Get by name
|
||||
let foo_got = nix_get_attr_byname(ctx, attr_val, state, foo.as_ptr());
|
||||
assert!(!foo_got.is_null());
|
||||
assert_eq!(nix_get_type(ctx, foo_got), ValueType_NIX_TYPE_INT);
|
||||
assert_eq!(nix_get_type(ctx, foo_got), ValueType::Int);
|
||||
assert_eq!(nix_get_int(ctx, foo_got), 42);
|
||||
|
||||
let bar_got = nix_get_attr_byname(ctx, attr_val, state, bar.as_ptr());
|
||||
assert!(!bar_got.is_null());
|
||||
assert_eq!(nix_get_type(ctx, bar_got), ValueType_NIX_TYPE_STRING);
|
||||
assert_eq!(nix_get_type(ctx, bar_got), ValueType::String);
|
||||
|
||||
// Has attr
|
||||
assert!(nix_has_attr_byname(ctx, attr_val, state, foo.as_ptr()));
|
||||
|
|
@ -282,17 +281,17 @@ fn function_application_and_force() {
|
|||
let ctx = nix_c_context_create();
|
||||
assert!(!ctx.is_null());
|
||||
let err = nix_libutil_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
let err = nix_libstore_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
let err = nix_libexpr_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
|
||||
assert!(!store.is_null());
|
||||
let builder = nix_eval_state_builder_new(ctx, store);
|
||||
assert!(!builder.is_null());
|
||||
assert_eq!(nix_eval_state_builder_load(ctx, builder), nix_err_NIX_OK);
|
||||
assert_eq!(nix_eval_state_builder_load(ctx, builder), NixErr::Ok);
|
||||
let state = nix_eval_state_build(ctx, builder);
|
||||
assert!(!state.is_null());
|
||||
|
||||
|
|
@ -303,7 +302,7 @@ fn function_application_and_force() {
|
|||
assert!(!fn_val.is_null());
|
||||
assert_eq!(
|
||||
nix_expr_eval_from_string(ctx, state, expr.as_ptr(), path.as_ptr(), fn_val),
|
||||
nix_err_NIX_OK
|
||||
NixErr::Ok
|
||||
);
|
||||
|
||||
// Argument: 41
|
||||
|
|
@ -315,16 +314,16 @@ fn function_application_and_force() {
|
|||
assert!(!result_val.is_null());
|
||||
assert_eq!(
|
||||
nix_value_call(ctx, state, fn_val, arg_val, result_val),
|
||||
nix_err_NIX_OK
|
||||
NixErr::Ok
|
||||
);
|
||||
|
||||
// Force result
|
||||
assert_eq!(nix_value_force(ctx, state, result_val), nix_err_NIX_OK);
|
||||
assert_eq!(nix_get_type(ctx, result_val), ValueType_NIX_TYPE_INT);
|
||||
assert_eq!(nix_value_force(ctx, state, result_val), NixErr::Ok);
|
||||
assert_eq!(nix_get_type(ctx, result_val), ValueType::Int);
|
||||
assert_eq!(nix_get_int(ctx, result_val), 42);
|
||||
|
||||
// Deep force (should be a no-op for int)
|
||||
assert_eq!(nix_value_force_deep(ctx, state, result_val), nix_err_NIX_OK);
|
||||
assert_eq!(nix_value_force_deep(ctx, state, result_val), NixErr::Ok);
|
||||
|
||||
nix_state_free(state);
|
||||
nix_eval_state_builder_free(builder);
|
||||
|
|
@ -340,17 +339,17 @@ fn error_handling_invalid_expression() {
|
|||
let ctx = nix_c_context_create();
|
||||
assert!(!ctx.is_null());
|
||||
let err = nix_libutil_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
let err = nix_libstore_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
let err = nix_libexpr_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
|
||||
assert!(!store.is_null());
|
||||
let builder = nix_eval_state_builder_new(ctx, store);
|
||||
assert!(!builder.is_null());
|
||||
assert_eq!(nix_eval_state_builder_load(ctx, builder), nix_err_NIX_OK);
|
||||
assert_eq!(nix_eval_state_builder_load(ctx, builder), NixErr::Ok);
|
||||
let state = nix_eval_state_build(ctx, builder);
|
||||
assert!(!state.is_null());
|
||||
|
||||
|
|
@ -360,7 +359,7 @@ fn error_handling_invalid_expression() {
|
|||
let value = nix_alloc_value(ctx, state);
|
||||
assert!(!value.is_null());
|
||||
let eval_err = nix_expr_eval_from_string(ctx, state, expr.as_ptr(), path.as_ptr(), value);
|
||||
assert_ne!(eval_err, nix_err_NIX_OK);
|
||||
assert_ne!(eval_err, NixErr::Ok);
|
||||
|
||||
nix_state_free(state);
|
||||
nix_eval_state_builder_free(builder);
|
||||
|
|
@ -376,24 +375,24 @@ fn realised_string_and_gc() {
|
|||
let ctx = nix_c_context_create();
|
||||
assert!(!ctx.is_null());
|
||||
let err = nix_libutil_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
let err = nix_libstore_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
let err = nix_libexpr_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
|
||||
assert!(!store.is_null());
|
||||
let builder = nix_eval_state_builder_new(ctx, store);
|
||||
assert!(!builder.is_null());
|
||||
assert_eq!(nix_eval_state_builder_load(ctx, builder), nix_err_NIX_OK);
|
||||
assert_eq!(nix_eval_state_builder_load(ctx, builder), NixErr::Ok);
|
||||
let state = nix_eval_state_build(ctx, builder);
|
||||
assert!(!state.is_null());
|
||||
|
||||
// String value
|
||||
let string_val = nix_alloc_value(ctx, state);
|
||||
let s = CString::new("hello world").unwrap();
|
||||
assert_eq!(nix_init_string(ctx, string_val, s.as_ptr()), nix_err_NIX_OK);
|
||||
assert_eq!(nix_init_string(ctx, string_val, s.as_ptr()), NixErr::Ok);
|
||||
|
||||
// Realise string
|
||||
let realised = nix_string_realise(ctx, state, string_val, false);
|
||||
|
|
@ -422,18 +421,18 @@ fn big_thunk_evaluation() {
|
|||
assert!(!ctx.is_null());
|
||||
|
||||
let err = nix_libutil_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
let err = nix_libstore_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
let err = nix_libexpr_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
|
||||
assert!(!store.is_null());
|
||||
|
||||
let builder = nix_eval_state_builder_new(ctx, store);
|
||||
assert!(!builder.is_null());
|
||||
assert_eq!(nix_eval_state_builder_load(ctx, builder), nix_err_NIX_OK);
|
||||
assert_eq!(nix_eval_state_builder_load(ctx, builder), NixErr::Ok);
|
||||
|
||||
let state = nix_eval_state_build(ctx, builder);
|
||||
assert!(!state.is_null());
|
||||
|
|
@ -446,10 +445,10 @@ fn big_thunk_evaluation() {
|
|||
assert!(!value.is_null());
|
||||
|
||||
let eval_err = nix_expr_eval_from_string(ctx, state, expr.as_ptr(), path.as_ptr(), value);
|
||||
assert_eq!(eval_err, nix_err_NIX_OK);
|
||||
assert_eq!(eval_err, NixErr::Ok);
|
||||
|
||||
// The top-level should be an attrset
|
||||
assert_eq!(nix_get_type(ctx, value), ValueType_NIX_TYPE_ATTRS);
|
||||
assert_eq!(nix_get_type(ctx, value), ValueType::Attrs);
|
||||
|
||||
// Get "result" attribute (ts should be a thunk initially)
|
||||
let result_name = CString::new("result").unwrap();
|
||||
|
|
@ -458,9 +457,9 @@ fn big_thunk_evaluation() {
|
|||
|
||||
// Force the result
|
||||
let force_err = nix_value_force(ctx, state, result_val);
|
||||
assert_eq!(force_err, nix_err_NIX_OK);
|
||||
assert_eq!(force_err, NixErr::Ok);
|
||||
|
||||
assert_eq!(nix_get_type(ctx, result_val), ValueType_NIX_TYPE_INT);
|
||||
assert_eq!(nix_get_type(ctx, result_val), ValueType::Int);
|
||||
assert_eq!(nix_get_int(ctx, result_val), 13); // ((1+2)*3)+4 = 13
|
||||
|
||||
// Get "other" attribute
|
||||
|
|
@ -469,9 +468,9 @@ fn big_thunk_evaluation() {
|
|||
assert!(!other_val.is_null());
|
||||
|
||||
let force_err2 = nix_value_force(ctx, state, other_val);
|
||||
assert_eq!(force_err2, nix_err_NIX_OK);
|
||||
assert_eq!(force_err2, NixErr::Ok);
|
||||
|
||||
assert_eq!(nix_get_type(ctx, other_val), ValueType_NIX_TYPE_INT);
|
||||
assert_eq!(nix_get_type(ctx, other_val), ValueType::Int);
|
||||
assert_eq!(nix_get_int(ctx, other_val), 3); // 1+2 = 3
|
||||
|
||||
nix_state_free(state);
|
||||
|
|
@ -489,13 +488,13 @@ fn multi_argument_function_calls() {
|
|||
assert!(!ctx.is_null());
|
||||
|
||||
let err = nix_libutil_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
let err = nix_libstore_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
let err = nix_libexpr_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
|
||||
assert!(!store.is_null());
|
||||
|
|
@ -504,7 +503,7 @@ fn multi_argument_function_calls() {
|
|||
assert!(!builder.is_null());
|
||||
|
||||
let load_err = nix_eval_state_builder_load(ctx, builder);
|
||||
assert_eq!(load_err, nix_err_NIX_OK);
|
||||
assert_eq!(load_err, NixErr::Ok);
|
||||
|
||||
let state = nix_eval_state_build(ctx, builder);
|
||||
assert!(!state.is_null());
|
||||
|
|
@ -518,15 +517,15 @@ fn multi_argument_function_calls() {
|
|||
|
||||
let eval_err =
|
||||
nix_expr_eval_from_string(ctx, state, expr.as_ptr(), path.as_ptr(), func_value);
|
||||
assert_eq!(eval_err, nix_err_NIX_OK);
|
||||
assert_eq!(eval_err, NixErr::Ok);
|
||||
|
||||
// Force evaluation of the function
|
||||
let force_err = nix_value_force(ctx, state, func_value);
|
||||
assert_eq!(force_err, nix_err_NIX_OK);
|
||||
assert_eq!(force_err, NixErr::Ok);
|
||||
|
||||
// Verify it's a function
|
||||
let func_type = nix_get_type(ctx, func_value);
|
||||
assert_eq!(func_type, ValueType_NIX_TYPE_FUNCTION);
|
||||
assert_eq!(func_type, ValueType::Function);
|
||||
|
||||
// Create arguments
|
||||
let arg1 = nix_alloc_value(ctx, state);
|
||||
|
|
@ -535,8 +534,8 @@ fn multi_argument_function_calls() {
|
|||
|
||||
let init_arg1_err = nix_init_int(ctx, arg1, 10);
|
||||
let init_arg2_err = nix_init_int(ctx, arg2, 20);
|
||||
assert_eq!(init_arg1_err, nix_err_NIX_OK);
|
||||
assert_eq!(init_arg2_err, nix_err_NIX_OK);
|
||||
assert_eq!(init_arg1_err, NixErr::Ok);
|
||||
assert_eq!(init_arg2_err, NixErr::Ok);
|
||||
|
||||
// Test multi-argument call using nix_value_call_multi
|
||||
let mut args = [arg1, arg2];
|
||||
|
|
@ -544,15 +543,15 @@ fn multi_argument_function_calls() {
|
|||
assert!(!result.is_null());
|
||||
|
||||
let call_err = nix_value_call_multi(ctx, state, func_value, 2, args.as_mut_ptr(), result);
|
||||
assert_eq!(call_err, nix_err_NIX_OK);
|
||||
assert_eq!(call_err, NixErr::Ok);
|
||||
|
||||
// Force the result
|
||||
let force_result_err = nix_value_force(ctx, state, result);
|
||||
assert_eq!(force_result_err, nix_err_NIX_OK);
|
||||
assert_eq!(force_result_err, NixErr::Ok);
|
||||
|
||||
// Check result type and value
|
||||
let result_type = nix_get_type(ctx, result);
|
||||
assert_eq!(result_type, ValueType_NIX_TYPE_INT);
|
||||
assert_eq!(result_type, ValueType::Int);
|
||||
|
||||
let result_value = nix_get_int(ctx, result);
|
||||
assert_eq!(result_value, 30); // 10 + 20
|
||||
|
|
@ -577,13 +576,13 @@ fn curried_function_evaluation() {
|
|||
assert!(!ctx.is_null());
|
||||
|
||||
let err = nix_libutil_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
let err = nix_libstore_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
let err = nix_libexpr_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
|
||||
assert!(!store.is_null());
|
||||
|
|
@ -592,7 +591,7 @@ fn curried_function_evaluation() {
|
|||
assert!(!builder.is_null());
|
||||
|
||||
let load_err = nix_eval_state_builder_load(ctx, builder);
|
||||
assert_eq!(load_err, nix_err_NIX_OK);
|
||||
assert_eq!(load_err, NixErr::Ok);
|
||||
|
||||
let state = nix_eval_state_build(ctx, builder);
|
||||
assert!(!state.is_null());
|
||||
|
|
@ -606,7 +605,7 @@ fn curried_function_evaluation() {
|
|||
|
||||
let eval_err =
|
||||
nix_expr_eval_from_string(ctx, state, expr.as_ptr(), path.as_ptr(), func_value);
|
||||
assert_eq!(eval_err, nix_err_NIX_OK);
|
||||
assert_eq!(eval_err, NixErr::Ok);
|
||||
|
||||
// Create three arguments
|
||||
let arg1 = nix_alloc_value(ctx, state);
|
||||
|
|
@ -624,15 +623,15 @@ fn curried_function_evaluation() {
|
|||
assert!(!result.is_null());
|
||||
|
||||
let call_err = nix_value_call_multi(ctx, state, func_value, 3, args.as_mut_ptr(), result);
|
||||
assert_eq!(call_err, nix_err_NIX_OK);
|
||||
assert_eq!(call_err, NixErr::Ok);
|
||||
|
||||
// Force the result
|
||||
let force_result_err = nix_value_force(ctx, state, result);
|
||||
assert_eq!(force_result_err, nix_err_NIX_OK);
|
||||
assert_eq!(force_result_err, NixErr::Ok);
|
||||
|
||||
// Check result
|
||||
let result_type = nix_get_type(ctx, result);
|
||||
assert_eq!(result_type, ValueType_NIX_TYPE_INT);
|
||||
assert_eq!(result_type, ValueType::Int);
|
||||
|
||||
let result_value = nix_get_int(ctx, result);
|
||||
assert_eq!(result_value, 30); // 5 + 10 + 15
|
||||
|
|
@ -642,42 +641,42 @@ fn curried_function_evaluation() {
|
|||
assert!(!partial1.is_null());
|
||||
|
||||
let partial_call1_err = nix_value_call(ctx, state, func_value, arg1, partial1);
|
||||
assert_eq!(partial_call1_err, nix_err_NIX_OK);
|
||||
assert_eq!(partial_call1_err, NixErr::Ok);
|
||||
|
||||
// partial1 should still be a function
|
||||
let force_partial1_err = nix_value_force(ctx, state, partial1);
|
||||
assert_eq!(force_partial1_err, nix_err_NIX_OK);
|
||||
assert_eq!(force_partial1_err, NixErr::Ok);
|
||||
|
||||
let partial1_type = nix_get_type(ctx, partial1);
|
||||
assert_eq!(partial1_type, ValueType_NIX_TYPE_FUNCTION);
|
||||
assert_eq!(partial1_type, ValueType::Function);
|
||||
|
||||
// Apply second argument
|
||||
let partial2 = nix_alloc_value(ctx, state);
|
||||
assert!(!partial2.is_null());
|
||||
|
||||
let partial_call2_err = nix_value_call(ctx, state, partial1, arg2, partial2);
|
||||
assert_eq!(partial_call2_err, nix_err_NIX_OK);
|
||||
assert_eq!(partial_call2_err, NixErr::Ok);
|
||||
|
||||
// partial2 should still be a function
|
||||
let force_partial2_err = nix_value_force(ctx, state, partial2);
|
||||
assert_eq!(force_partial2_err, nix_err_NIX_OK);
|
||||
assert_eq!(force_partial2_err, NixErr::Ok);
|
||||
|
||||
let partial2_type = nix_get_type(ctx, partial2);
|
||||
assert_eq!(partial2_type, ValueType_NIX_TYPE_FUNCTION);
|
||||
assert_eq!(partial2_type, ValueType::Function);
|
||||
|
||||
// Apply final argument
|
||||
let final_result = nix_alloc_value(ctx, state);
|
||||
assert!(!final_result.is_null());
|
||||
|
||||
let final_call_err = nix_value_call(ctx, state, partial2, arg3, final_result);
|
||||
assert_eq!(final_call_err, nix_err_NIX_OK);
|
||||
assert_eq!(final_call_err, NixErr::Ok);
|
||||
|
||||
// Force and check final result
|
||||
let force_final_err = nix_value_force(ctx, state, final_result);
|
||||
assert_eq!(force_final_err, nix_err_NIX_OK);
|
||||
assert_eq!(force_final_err, NixErr::Ok);
|
||||
|
||||
let final_type = nix_get_type(ctx, final_result);
|
||||
assert_eq!(final_type, ValueType_NIX_TYPE_INT);
|
||||
assert_eq!(final_type, ValueType::Int);
|
||||
|
||||
let final_value = nix_get_int(ctx, final_result);
|
||||
assert_eq!(final_value, 30); // same result as multi-arg call
|
||||
|
|
@ -706,13 +705,13 @@ fn thunk_creation_with_init_apply() {
|
|||
assert!(!ctx.is_null());
|
||||
|
||||
let err = nix_libutil_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
let err = nix_libstore_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
let err = nix_libexpr_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
|
||||
assert!(!store.is_null());
|
||||
|
|
@ -721,7 +720,7 @@ fn thunk_creation_with_init_apply() {
|
|||
assert!(!builder.is_null());
|
||||
|
||||
let load_err = nix_eval_state_builder_load(ctx, builder);
|
||||
assert_eq!(load_err, nix_err_NIX_OK);
|
||||
assert_eq!(load_err, NixErr::Ok);
|
||||
|
||||
let state = nix_eval_state_build(ctx, builder);
|
||||
assert!(!state.is_null());
|
||||
|
|
@ -735,33 +734,33 @@ fn thunk_creation_with_init_apply() {
|
|||
|
||||
let eval_err =
|
||||
nix_expr_eval_from_string(ctx, state, func_expr.as_ptr(), path.as_ptr(), func_value);
|
||||
assert_eq!(eval_err, nix_err_NIX_OK);
|
||||
assert_eq!(eval_err, NixErr::Ok);
|
||||
|
||||
// Create an argument
|
||||
let arg = nix_alloc_value(ctx, state);
|
||||
assert!(!arg.is_null());
|
||||
|
||||
let init_arg_err = nix_init_int(ctx, arg, 21);
|
||||
assert_eq!(init_arg_err, nix_err_NIX_OK);
|
||||
assert_eq!(init_arg_err, NixErr::Ok);
|
||||
|
||||
// Create a thunk using nix_init_apply (lazy evaluation)
|
||||
let thunk = nix_alloc_value(ctx, state);
|
||||
assert!(!thunk.is_null());
|
||||
|
||||
let apply_err = nix_init_apply(ctx, thunk, func_value, arg);
|
||||
assert_eq!(apply_err, nix_err_NIX_OK);
|
||||
assert_eq!(apply_err, NixErr::Ok);
|
||||
|
||||
// Initially, the thunk should be of type THUNK
|
||||
let thunk_type = nix_get_type(ctx, thunk);
|
||||
assert_eq!(thunk_type, ValueType_NIX_TYPE_THUNK);
|
||||
assert_eq!(thunk_type, ValueType::Thunk);
|
||||
|
||||
// Force evaluation of the thunk
|
||||
let force_err = nix_value_force(ctx, state, thunk);
|
||||
assert_eq!(force_err, nix_err_NIX_OK);
|
||||
assert_eq!(force_err, NixErr::Ok);
|
||||
|
||||
// After forcing, it should be an integer
|
||||
let forced_type = nix_get_type(ctx, thunk);
|
||||
assert_eq!(forced_type, ValueType_NIX_TYPE_INT);
|
||||
assert_eq!(forced_type, ValueType::Int);
|
||||
|
||||
let result_value = nix_get_int(ctx, thunk);
|
||||
assert_eq!(result_value, 42); // 21 * 2
|
||||
|
|
@ -785,13 +784,13 @@ fn lookup_path_configuration() {
|
|||
assert!(!ctx.is_null());
|
||||
|
||||
let err = nix_libutil_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
let err = nix_libstore_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
let err = nix_libexpr_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
|
||||
assert!(!store.is_null());
|
||||
|
|
@ -814,10 +813,10 @@ fn lookup_path_configuration() {
|
|||
builder,
|
||||
lookup_path_ptrs_null_terminated.as_mut_ptr(),
|
||||
);
|
||||
assert_eq!(set_lookup_err, nix_err_NIX_OK);
|
||||
assert_eq!(set_lookup_err, NixErr::Ok);
|
||||
|
||||
let load_err = nix_eval_state_builder_load(ctx, builder);
|
||||
assert_eq!(load_err, nix_err_NIX_OK);
|
||||
assert_eq!(load_err, NixErr::Ok);
|
||||
|
||||
let state = nix_eval_state_build(ctx, builder);
|
||||
assert!(!state.is_null());
|
||||
|
|
@ -836,12 +835,12 @@ fn lookup_path_configuration() {
|
|||
// The evaluation might succeed or fail depending on Nix version and
|
||||
// configuration The important thing is that setting the lookup path
|
||||
// didn't crash
|
||||
if eval_err == nix_err_NIX_OK {
|
||||
if eval_err == NixErr::Ok {
|
||||
let force_err = nix_value_force(ctx, state, result);
|
||||
if force_err == nix_err_NIX_OK {
|
||||
if force_err == NixErr::Ok {
|
||||
let result_type = nix_get_type(ctx, result);
|
||||
// nixPath should be a list
|
||||
assert_eq!(result_type, ValueType_NIX_TYPE_LIST);
|
||||
assert_eq!(result_type, ValueType::List);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -862,13 +861,13 @@ fn complex_nested_evaluation() {
|
|||
assert!(!ctx.is_null());
|
||||
|
||||
let err = nix_libutil_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
let err = nix_libstore_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
let err = nix_libexpr_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
|
||||
assert!(!store.is_null());
|
||||
|
|
@ -877,7 +876,7 @@ fn complex_nested_evaluation() {
|
|||
assert!(!builder.is_null());
|
||||
|
||||
let load_err = nix_eval_state_builder_load(ctx, builder);
|
||||
assert_eq!(load_err, nix_err_NIX_OK);
|
||||
assert_eq!(load_err, NixErr::Ok);
|
||||
|
||||
let state = nix_eval_state_build(ctx, builder);
|
||||
assert!(!state.is_null());
|
||||
|
|
@ -907,7 +906,7 @@ fn complex_nested_evaluation() {
|
|||
|
||||
// Complex expressions may fail sometimes, check for both success
|
||||
// and error
|
||||
if eval_err != nix_err_NIX_OK {
|
||||
if eval_err != NixErr::Ok {
|
||||
// If evaluation fails, skip the rest of the test
|
||||
nix_value_decref(ctx, result);
|
||||
nix_state_free(state);
|
||||
|
|
@ -919,7 +918,7 @@ fn complex_nested_evaluation() {
|
|||
|
||||
// Force deep evaluation
|
||||
let force_err = nix_value_force_deep(ctx, state, result);
|
||||
if force_err != nix_err_NIX_OK {
|
||||
if force_err != NixErr::Ok {
|
||||
// If forcing fails, skip the rest of the test
|
||||
nix_value_decref(ctx, result);
|
||||
nix_state_free(state);
|
||||
|
|
@ -931,7 +930,7 @@ fn complex_nested_evaluation() {
|
|||
|
||||
// Verify result structure
|
||||
let result_type = nix_get_type(ctx, result);
|
||||
assert_eq!(result_type, ValueType_NIX_TYPE_ATTRS);
|
||||
assert_eq!(result_type, ValueType::Attrs);
|
||||
|
||||
let attrs_size = nix_get_attrs_size(ctx, result);
|
||||
assert_eq!(attrs_size, 2); // original, sum
|
||||
|
|
@ -942,7 +941,7 @@ fn complex_nested_evaluation() {
|
|||
assert!(!sum_value.is_null());
|
||||
|
||||
let sum_type = nix_get_type(ctx, sum_value);
|
||||
assert_eq!(sum_type, ValueType_NIX_TYPE_INT);
|
||||
assert_eq!(sum_type, ValueType::Int);
|
||||
|
||||
let sum_result = nix_get_int(ctx, sum_value);
|
||||
assert_eq!(sum_result, 15); // 1 + 2 + 3 + 4 + 5
|
||||
|
|
@ -952,7 +951,7 @@ fn complex_nested_evaluation() {
|
|||
let original_value = nix_get_attr_byname(ctx, result, state, original_key.as_ptr());
|
||||
if !original_value.is_null() {
|
||||
let original_type = nix_get_type(ctx, original_value);
|
||||
assert_eq!(original_type, ValueType_NIX_TYPE_LIST);
|
||||
assert_eq!(original_type, ValueType::List);
|
||||
|
||||
let original_size = nix_get_list_size(ctx, original_value);
|
||||
assert_eq!(original_size, 5);
|
||||
|
|
@ -961,7 +960,7 @@ fn complex_nested_evaluation() {
|
|||
let first_elem = nix_get_list_byidx(ctx, original_value, state, 0);
|
||||
if !first_elem.is_null() {
|
||||
let first_elem_type = nix_get_type(ctx, first_elem);
|
||||
assert_eq!(first_elem_type, ValueType_NIX_TYPE_INT);
|
||||
assert_eq!(first_elem_type, ValueType::Int);
|
||||
|
||||
let first_elem_value = nix_get_int(ctx, first_elem);
|
||||
assert_eq!(first_elem_value, 1);
|
||||
|
|
@ -985,13 +984,13 @@ fn evaluation_error_handling() {
|
|||
assert!(!ctx.is_null());
|
||||
|
||||
let err = nix_libutil_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
let err = nix_libstore_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
let err = nix_libexpr_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
|
||||
assert!(!store.is_null());
|
||||
|
|
@ -1000,7 +999,7 @@ fn evaluation_error_handling() {
|
|||
assert!(!builder.is_null());
|
||||
|
||||
let load_err = nix_eval_state_builder_load(ctx, builder);
|
||||
assert_eq!(load_err, nix_err_NIX_OK);
|
||||
assert_eq!(load_err, NixErr::Ok);
|
||||
|
||||
let state = nix_eval_state_build(ctx, builder);
|
||||
assert!(!state.is_null());
|
||||
|
|
@ -1014,7 +1013,7 @@ fn evaluation_error_handling() {
|
|||
|
||||
let eval_err =
|
||||
nix_expr_eval_from_string(ctx, state, invalid_expr.as_ptr(), path.as_ptr(), result);
|
||||
assert_ne!(eval_err, nix_err_NIX_OK); // should fail
|
||||
assert_ne!(eval_err, NixErr::Ok); // should fail
|
||||
|
||||
// Clear error for next test
|
||||
nix_clear_err(ctx);
|
||||
|
|
@ -1034,14 +1033,14 @@ fn evaluation_error_handling() {
|
|||
);
|
||||
|
||||
// May succeed at parse time but fail during evaluation
|
||||
if eval_err2 == nix_err_NIX_OK {
|
||||
if eval_err2 == NixErr::Ok {
|
||||
let force_err = nix_value_force(ctx, state, result2);
|
||||
assert_ne!(force_err, nix_err_NIX_OK); // should fail during forcing
|
||||
assert_ne!(force_err, NixErr::Ok); // should fail during forcing
|
||||
}
|
||||
|
||||
// Test error information retrieval
|
||||
let error_code = nix_err_code(ctx);
|
||||
assert_ne!(error_code, nix_err_NIX_OK);
|
||||
assert_ne!(error_code, NixErr::Ok);
|
||||
|
||||
// Try to get error message
|
||||
let mut error_len: std::os::raw::c_uint = 0;
|
||||
|
|
@ -1065,7 +1064,7 @@ fn evaluation_error_handling() {
|
|||
|
||||
let eval_func_err =
|
||||
nix_expr_eval_from_string(ctx, state, func_expr.as_ptr(), path.as_ptr(), func_value);
|
||||
assert_eq!(eval_func_err, nix_err_NIX_OK);
|
||||
assert_eq!(eval_func_err, NixErr::Ok);
|
||||
|
||||
// Try to call with wrong number of arguments.
|
||||
// The function expects 2, but we give 1
|
||||
|
|
@ -1087,12 +1086,12 @@ fn evaluation_error_handling() {
|
|||
);
|
||||
|
||||
// This should succeed but result should be a partially applied function
|
||||
if call_err == nix_err_NIX_OK {
|
||||
if call_err == NixErr::Ok {
|
||||
let force_err = nix_value_force(ctx, state, result3);
|
||||
assert_eq!(force_err, nix_err_NIX_OK);
|
||||
assert_eq!(force_err, NixErr::Ok);
|
||||
|
||||
let result_type = nix_get_type(ctx, result3);
|
||||
assert_eq!(result_type, ValueType_NIX_TYPE_FUNCTION); // partially applied
|
||||
assert_eq!(result_type, ValueType::Function); // partially applied
|
||||
}
|
||||
|
||||
// Clean up
|
||||
|
|
@ -1116,13 +1115,13 @@ fn builtin_function_calls() {
|
|||
assert!(!ctx.is_null());
|
||||
|
||||
let err = nix_libutil_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
let err = nix_libstore_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
let err = nix_libexpr_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
|
||||
assert!(!store.is_null());
|
||||
|
|
@ -1131,7 +1130,7 @@ fn builtin_function_calls() {
|
|||
assert!(!builder.is_null());
|
||||
|
||||
let load_err = nix_eval_state_builder_load(ctx, builder);
|
||||
assert_eq!(load_err, nix_err_NIX_OK);
|
||||
assert_eq!(load_err, NixErr::Ok);
|
||||
|
||||
let state = nix_eval_state_build(ctx, builder);
|
||||
assert!(!state.is_null());
|
||||
|
|
@ -1145,7 +1144,7 @@ fn builtin_function_calls() {
|
|||
|
||||
let eval_length_err =
|
||||
nix_expr_eval_from_string(ctx, state, length_expr.as_ptr(), path.as_ptr(), length_func);
|
||||
assert_eq!(eval_length_err, nix_err_NIX_OK);
|
||||
assert_eq!(eval_length_err, NixErr::Ok);
|
||||
|
||||
// Create a list to test with
|
||||
let list_expr = CString::new("[1 2 3 4 5]").unwrap();
|
||||
|
|
@ -1154,20 +1153,20 @@ fn builtin_function_calls() {
|
|||
|
||||
let eval_list_err =
|
||||
nix_expr_eval_from_string(ctx, state, list_expr.as_ptr(), path.as_ptr(), test_list);
|
||||
assert_eq!(eval_list_err, nix_err_NIX_OK);
|
||||
assert_eq!(eval_list_err, NixErr::Ok);
|
||||
|
||||
// Call length function with the list
|
||||
let length_result = nix_alloc_value(ctx, state);
|
||||
assert!(!length_result.is_null());
|
||||
|
||||
let call_length_err = nix_value_call(ctx, state, length_func, test_list, length_result);
|
||||
assert_eq!(call_length_err, nix_err_NIX_OK);
|
||||
assert_eq!(call_length_err, NixErr::Ok);
|
||||
|
||||
let force_length_err = nix_value_force(ctx, state, length_result);
|
||||
assert_eq!(force_length_err, nix_err_NIX_OK);
|
||||
assert_eq!(force_length_err, NixErr::Ok);
|
||||
|
||||
let length_type = nix_get_type(ctx, length_result);
|
||||
assert_eq!(length_type, ValueType_NIX_TYPE_INT);
|
||||
assert_eq!(length_type, ValueType::Int);
|
||||
|
||||
let length_value = nix_get_int(ctx, length_result);
|
||||
assert_eq!(length_value, 5);
|
||||
|
|
@ -1179,7 +1178,7 @@ fn builtin_function_calls() {
|
|||
|
||||
let eval_map_err =
|
||||
nix_expr_eval_from_string(ctx, state, map_expr.as_ptr(), path.as_ptr(), map_func);
|
||||
assert_eq!(eval_map_err, nix_err_NIX_OK);
|
||||
assert_eq!(eval_map_err, NixErr::Ok);
|
||||
|
||||
// Create a simple function to map: (x: x * 2)
|
||||
let double_expr = CString::new("(x: x * 2)").unwrap();
|
||||
|
|
@ -1188,7 +1187,7 @@ fn builtin_function_calls() {
|
|||
|
||||
let eval_double_err =
|
||||
nix_expr_eval_from_string(ctx, state, double_expr.as_ptr(), path.as_ptr(), double_func);
|
||||
assert_eq!(eval_double_err, nix_err_NIX_OK);
|
||||
assert_eq!(eval_double_err, NixErr::Ok);
|
||||
|
||||
// Call map with the function and list
|
||||
let mut args = [double_func, test_list];
|
||||
|
|
@ -1197,13 +1196,13 @@ fn builtin_function_calls() {
|
|||
|
||||
let call_map_err =
|
||||
nix_value_call_multi(ctx, state, map_func, 2, args.as_mut_ptr(), map_result);
|
||||
assert_eq!(call_map_err, nix_err_NIX_OK);
|
||||
assert_eq!(call_map_err, NixErr::Ok);
|
||||
|
||||
let force_map_err = nix_value_force(ctx, state, map_result);
|
||||
assert_eq!(force_map_err, nix_err_NIX_OK);
|
||||
assert_eq!(force_map_err, NixErr::Ok);
|
||||
|
||||
let map_result_type = nix_get_type(ctx, map_result);
|
||||
assert_eq!(map_result_type, ValueType_NIX_TYPE_LIST);
|
||||
assert_eq!(map_result_type, ValueType::List);
|
||||
|
||||
let map_result_size = nix_get_list_size(ctx, map_result);
|
||||
assert_eq!(map_result_size, 5);
|
||||
|
|
@ -1213,10 +1212,10 @@ fn builtin_function_calls() {
|
|||
assert!(!first_mapped.is_null());
|
||||
|
||||
let force_first_err = nix_value_force(ctx, state, first_mapped);
|
||||
assert_eq!(force_first_err, nix_err_NIX_OK);
|
||||
assert_eq!(force_first_err, NixErr::Ok);
|
||||
|
||||
let first_mapped_type = nix_get_type(ctx, first_mapped);
|
||||
assert_eq!(first_mapped_type, ValueType_NIX_TYPE_INT);
|
||||
assert_eq!(first_mapped_type, ValueType::Int);
|
||||
|
||||
let first_mapped_value = nix_get_int(ctx, first_mapped);
|
||||
assert_eq!(first_mapped_value, 2); // 1 * 2
|
||||
|
|
|
|||
|
|
@ -3,9 +3,10 @@
|
|||
|
||||
use std::ptr;
|
||||
|
||||
use nixide_sys::*;
|
||||
use serial_test::serial;
|
||||
|
||||
use nixide_sys::*;
|
||||
|
||||
#[test]
|
||||
#[serial]
|
||||
fn flake_settings_new_and_free() {
|
||||
|
|
@ -32,13 +33,13 @@ fn flake_settings_add_to_eval_state_builder() {
|
|||
assert!(!ctx.is_null());
|
||||
|
||||
let err = nix_libutil_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
let err = nix_libstore_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
let err = nix_libexpr_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
|
||||
assert!(!store.is_null());
|
||||
|
|
@ -53,9 +54,8 @@ fn flake_settings_add_to_eval_state_builder() {
|
|||
let err = nix_flake_settings_add_to_eval_state_builder(ctx, settings, builder);
|
||||
// Accept OK or ERR_UNKNOWN (depends on Nix build/config)
|
||||
assert!(
|
||||
err == nix_err_NIX_OK || err == nix_err_NIX_ERR_UNKNOWN,
|
||||
"nix_flake_settings_add_to_eval_state_builder returned unexpected error \
|
||||
code: {err}"
|
||||
err == NixErr::Ok || err == NixErr::Unknown,
|
||||
"nix_flake_settings_add_to_eval_state_builder returned unexpected error code: {err}"
|
||||
);
|
||||
|
||||
nix_flake_settings_free(settings);
|
||||
|
|
|
|||
|
|
@ -3,9 +3,10 @@
|
|||
|
||||
use std::ffi::CString;
|
||||
|
||||
use nixide_sys::*;
|
||||
use serial_test::serial;
|
||||
|
||||
use nixide_sys::*;
|
||||
|
||||
#[test]
|
||||
#[serial]
|
||||
fn value_reference_counting() {
|
||||
|
|
@ -14,13 +15,13 @@ fn value_reference_counting() {
|
|||
assert!(!ctx.is_null());
|
||||
|
||||
let err = nix_libutil_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
let err = nix_libstore_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
let err = nix_libexpr_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
|
||||
assert!(!store.is_null());
|
||||
|
|
@ -29,7 +30,7 @@ fn value_reference_counting() {
|
|||
assert!(!builder.is_null());
|
||||
|
||||
let load_err = nix_eval_state_builder_load(ctx, builder);
|
||||
assert_eq!(load_err, nix_err_NIX_OK);
|
||||
assert_eq!(load_err, NixErr::Ok);
|
||||
|
||||
let state = nix_eval_state_build(ctx, builder);
|
||||
assert!(!state.is_null());
|
||||
|
|
@ -40,11 +41,11 @@ fn value_reference_counting() {
|
|||
|
||||
// Initialize with an integer
|
||||
let init_err = nix_init_int(ctx, value, 42);
|
||||
assert_eq!(init_err, nix_err_NIX_OK);
|
||||
assert_eq!(init_err, NixErr::Ok);
|
||||
|
||||
// Test value-specific reference counting
|
||||
let incref_err = nix_value_incref(ctx, value);
|
||||
assert_eq!(incref_err, nix_err_NIX_OK);
|
||||
assert_eq!(incref_err, NixErr::Ok);
|
||||
|
||||
// Value should still be valid after increment
|
||||
let int_val = nix_get_int(ctx, value);
|
||||
|
|
@ -52,7 +53,7 @@ fn value_reference_counting() {
|
|||
|
||||
// Test decrement
|
||||
let decref_err = nix_value_decref(ctx, value);
|
||||
assert_eq!(decref_err, nix_err_NIX_OK);
|
||||
assert_eq!(decref_err, NixErr::Ok);
|
||||
|
||||
// Value should still be valid (original reference still exists)
|
||||
let int_val2 = nix_get_int(ctx, value);
|
||||
|
|
@ -60,7 +61,7 @@ fn value_reference_counting() {
|
|||
|
||||
// Final decrement (should not crash)
|
||||
let final_decref_err = nix_value_decref(ctx, value);
|
||||
assert_eq!(final_decref_err, nix_err_NIX_OK);
|
||||
assert_eq!(final_decref_err, NixErr::Ok);
|
||||
|
||||
// Clean up
|
||||
nix_state_free(state);
|
||||
|
|
@ -78,13 +79,13 @@ fn general_gc_reference_counting() {
|
|||
assert!(!ctx.is_null());
|
||||
|
||||
let err = nix_libutil_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
let err = nix_libstore_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
let err = nix_libexpr_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
|
||||
assert!(!store.is_null());
|
||||
|
|
@ -93,7 +94,7 @@ fn general_gc_reference_counting() {
|
|||
assert!(!builder.is_null());
|
||||
|
||||
let load_err = nix_eval_state_builder_load(ctx, builder);
|
||||
assert_eq!(load_err, nix_err_NIX_OK);
|
||||
assert_eq!(load_err, NixErr::Ok);
|
||||
|
||||
let state = nix_eval_state_build(ctx, builder);
|
||||
assert!(!state.is_null());
|
||||
|
|
@ -107,19 +108,19 @@ fn general_gc_reference_counting() {
|
|||
value,
|
||||
CString::new("test string for GC").unwrap().as_ptr(),
|
||||
);
|
||||
assert_eq!(init_err, nix_err_NIX_OK);
|
||||
assert_eq!(init_err, NixErr::Ok);
|
||||
|
||||
// Test general GC reference counting
|
||||
let gc_incref_err = nix_gc_incref(ctx, value as *const ::std::os::raw::c_void);
|
||||
assert_eq!(gc_incref_err, nix_err_NIX_OK);
|
||||
assert_eq!(gc_incref_err, NixErr::Ok);
|
||||
|
||||
// Value should still be accessible
|
||||
let value_type = nix_get_type(ctx, value);
|
||||
assert_eq!(value_type, ValueType_NIX_TYPE_STRING);
|
||||
assert_eq!(value_type, ValueType::String);
|
||||
|
||||
// Test GC decrement
|
||||
let gc_decref_err = nix_gc_decref(ctx, value as *const ::std::os::raw::c_void);
|
||||
assert_eq!(gc_decref_err, nix_err_NIX_OK);
|
||||
assert_eq!(gc_decref_err, NixErr::Ok);
|
||||
|
||||
// Final cleanup
|
||||
nix_value_decref(ctx, value);
|
||||
|
|
@ -138,13 +139,13 @@ fn manual_garbage_collection() {
|
|||
assert!(!ctx.is_null());
|
||||
|
||||
let err = nix_libutil_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
let err = nix_libstore_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
let err = nix_libexpr_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
|
||||
assert!(!store.is_null());
|
||||
|
|
@ -153,7 +154,7 @@ fn manual_garbage_collection() {
|
|||
assert!(!builder.is_null());
|
||||
|
||||
let load_err = nix_eval_state_builder_load(ctx, builder);
|
||||
assert_eq!(load_err, nix_err_NIX_OK);
|
||||
assert_eq!(load_err, NixErr::Ok);
|
||||
|
||||
let state = nix_eval_state_build(ctx, builder);
|
||||
assert!(!state.is_null());
|
||||
|
|
@ -164,7 +165,7 @@ fn manual_garbage_collection() {
|
|||
let value = nix_alloc_value(ctx, state);
|
||||
if !value.is_null() {
|
||||
let init_err = nix_init_int(ctx, value, i);
|
||||
if init_err == nix_err_NIX_OK {
|
||||
if init_err == NixErr::Ok {
|
||||
values.push(value);
|
||||
}
|
||||
}
|
||||
|
|
@ -196,13 +197,13 @@ fn value_copying_and_memory_management() {
|
|||
assert!(!ctx.is_null());
|
||||
|
||||
let err = nix_libutil_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
let err = nix_libstore_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
let err = nix_libexpr_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
|
||||
assert!(!store.is_null());
|
||||
|
|
@ -211,7 +212,7 @@ fn value_copying_and_memory_management() {
|
|||
assert!(!builder.is_null());
|
||||
|
||||
let load_err = nix_eval_state_builder_load(ctx, builder);
|
||||
assert_eq!(load_err, nix_err_NIX_OK);
|
||||
assert_eq!(load_err, NixErr::Ok);
|
||||
|
||||
let state = nix_eval_state_build(ctx, builder);
|
||||
assert!(!state.is_null());
|
||||
|
|
@ -222,20 +223,20 @@ fn value_copying_and_memory_management() {
|
|||
|
||||
let test_string = CString::new("test string for copying").unwrap();
|
||||
let init_err = nix_init_string(ctx, original, test_string.as_ptr());
|
||||
assert_eq!(init_err, nix_err_NIX_OK);
|
||||
assert_eq!(init_err, NixErr::Ok);
|
||||
|
||||
// Create copy
|
||||
let copy = nix_alloc_value(ctx, state);
|
||||
assert!(!copy.is_null());
|
||||
|
||||
let copy_err = nix_copy_value(ctx, copy, original);
|
||||
assert_eq!(copy_err, nix_err_NIX_OK);
|
||||
assert_eq!(copy_err, NixErr::Ok);
|
||||
|
||||
// Verify copy has same type and can be accessed
|
||||
let original_type = nix_get_type(ctx, original);
|
||||
let copy_type = nix_get_type(ctx, copy);
|
||||
assert_eq!(original_type, copy_type);
|
||||
assert_eq!(copy_type, ValueType_NIX_TYPE_STRING);
|
||||
assert_eq!(copy_type, ValueType::String);
|
||||
|
||||
// Test string contents using callback
|
||||
unsafe extern "C" fn string_callback(
|
||||
|
|
@ -268,20 +269,22 @@ fn value_copying_and_memory_management() {
|
|||
|
||||
// Both should have the same string content
|
||||
assert_eq!(original_string, copy_string);
|
||||
assert!(original_string
|
||||
.as_deref()
|
||||
.unwrap_or("")
|
||||
.contains("test string"));
|
||||
assert!(
|
||||
original_string
|
||||
.as_deref()
|
||||
.unwrap_or("")
|
||||
.contains("test string")
|
||||
);
|
||||
|
||||
// Test reference counting on both values
|
||||
let incref_orig = nix_value_incref(ctx, original);
|
||||
let incref_copy = nix_value_incref(ctx, copy);
|
||||
assert_eq!(incref_orig, nix_err_NIX_OK);
|
||||
assert_eq!(incref_copy, nix_err_NIX_OK);
|
||||
assert_eq!(incref_orig, NixErr::Ok);
|
||||
assert_eq!(incref_copy, NixErr::Ok);
|
||||
|
||||
// Values should still be accessible after increment
|
||||
assert_eq!(nix_get_type(ctx, original), ValueType_NIX_TYPE_STRING);
|
||||
assert_eq!(nix_get_type(ctx, copy), ValueType_NIX_TYPE_STRING);
|
||||
assert_eq!(nix_get_type(ctx, original), ValueType::String);
|
||||
assert_eq!(nix_get_type(ctx, copy), ValueType::String);
|
||||
|
||||
// Clean up with decrements
|
||||
nix_value_decref(ctx, original);
|
||||
|
|
@ -304,13 +307,13 @@ fn complex_value_memory_management() {
|
|||
assert!(!ctx.is_null());
|
||||
|
||||
let err = nix_libutil_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
let err = nix_libstore_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
let err = nix_libexpr_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
|
||||
assert!(!store.is_null());
|
||||
|
|
@ -319,7 +322,7 @@ fn complex_value_memory_management() {
|
|||
assert!(!builder.is_null());
|
||||
|
||||
let load_err = nix_eval_state_builder_load(ctx, builder);
|
||||
assert_eq!(load_err, nix_err_NIX_OK);
|
||||
assert_eq!(load_err, NixErr::Ok);
|
||||
|
||||
let state = nix_eval_state_build(ctx, builder);
|
||||
assert!(!state.is_null());
|
||||
|
|
@ -343,7 +346,7 @@ fn complex_value_memory_management() {
|
|||
let _ = nix_init_string(ctx, val1, name_str.as_ptr());
|
||||
|
||||
let insert_err1 = nix_bindings_builder_insert(ctx, bindings_builder1, key1.as_ptr(), val1);
|
||||
assert_eq!(insert_err1, nix_err_NIX_OK);
|
||||
assert_eq!(insert_err1, NixErr::Ok);
|
||||
|
||||
let key2 = CString::new("value").unwrap();
|
||||
let val2 = nix_alloc_value(ctx, state);
|
||||
|
|
@ -351,14 +354,14 @@ fn complex_value_memory_management() {
|
|||
let _ = nix_init_int(ctx, val2, 42);
|
||||
|
||||
let insert_err2 = nix_bindings_builder_insert(ctx, bindings_builder1, key2.as_ptr(), val2);
|
||||
assert_eq!(insert_err2, nix_err_NIX_OK);
|
||||
assert_eq!(insert_err2, NixErr::Ok);
|
||||
|
||||
let make_attrs_err1 = nix_make_attrs(ctx, attrs1, bindings_builder1);
|
||||
assert_eq!(make_attrs_err1, nix_err_NIX_OK);
|
||||
assert_eq!(make_attrs_err1, NixErr::Ok);
|
||||
|
||||
// Insert first attrs into list
|
||||
let list_insert_err1 = nix_list_builder_insert(ctx, list_builder, 0, attrs1);
|
||||
assert_eq!(list_insert_err1, nix_err_NIX_OK);
|
||||
assert_eq!(list_insert_err1, NixErr::Ok);
|
||||
|
||||
// Create second element
|
||||
let attrs2 = nix_alloc_value(ctx, state);
|
||||
|
|
@ -374,23 +377,23 @@ fn complex_value_memory_management() {
|
|||
let _ = nix_init_string(ctx, val3, data_str.as_ptr());
|
||||
|
||||
let insert_err3 = nix_bindings_builder_insert(ctx, bindings_builder2, key3.as_ptr(), val3);
|
||||
assert_eq!(insert_err3, nix_err_NIX_OK);
|
||||
assert_eq!(insert_err3, NixErr::Ok);
|
||||
|
||||
let make_attrs_err2 = nix_make_attrs(ctx, attrs2, bindings_builder2);
|
||||
assert_eq!(make_attrs_err2, nix_err_NIX_OK);
|
||||
assert_eq!(make_attrs_err2, NixErr::Ok);
|
||||
|
||||
let list_insert_err2 = nix_list_builder_insert(ctx, list_builder, 1, attrs2);
|
||||
assert_eq!(list_insert_err2, nix_err_NIX_OK);
|
||||
assert_eq!(list_insert_err2, NixErr::Ok);
|
||||
|
||||
// Create final list
|
||||
let final_list = nix_alloc_value(ctx, state);
|
||||
assert!(!final_list.is_null());
|
||||
|
||||
let make_list_err = nix_make_list(ctx, list_builder, final_list);
|
||||
assert_eq!(make_list_err, nix_err_NIX_OK);
|
||||
assert_eq!(make_list_err, NixErr::Ok);
|
||||
|
||||
// Test the complex structure
|
||||
assert_eq!(nix_get_type(ctx, final_list), ValueType_NIX_TYPE_LIST);
|
||||
assert_eq!(nix_get_type(ctx, final_list), ValueType::List);
|
||||
assert_eq!(nix_get_list_size(ctx, final_list), 2);
|
||||
|
||||
// Access nested elements
|
||||
|
|
@ -398,19 +401,19 @@ fn complex_value_memory_management() {
|
|||
let elem1 = nix_get_list_byidx(ctx, final_list, state, 1);
|
||||
assert!(!elem0.is_null() && !elem1.is_null());
|
||||
|
||||
assert_eq!(nix_get_type(ctx, elem0), ValueType_NIX_TYPE_ATTRS);
|
||||
assert_eq!(nix_get_type(ctx, elem1), ValueType_NIX_TYPE_ATTRS);
|
||||
assert_eq!(nix_get_type(ctx, elem0), ValueType::Attrs);
|
||||
assert_eq!(nix_get_type(ctx, elem1), ValueType::Attrs);
|
||||
|
||||
// Test memory management with deep copying
|
||||
let copied_list = nix_alloc_value(ctx, state);
|
||||
assert!(!copied_list.is_null());
|
||||
|
||||
let copy_err = nix_copy_value(ctx, copied_list, final_list);
|
||||
assert_eq!(copy_err, nix_err_NIX_OK);
|
||||
assert_eq!(copy_err, NixErr::Ok);
|
||||
|
||||
// Force deep evaluation on copy
|
||||
let deep_force_err = nix_value_force_deep(ctx, state, copied_list);
|
||||
assert_eq!(deep_force_err, nix_err_NIX_OK);
|
||||
assert_eq!(deep_force_err, NixErr::Ok);
|
||||
|
||||
// Both should still be accessible
|
||||
assert_eq!(nix_get_list_size(ctx, final_list), 2);
|
||||
|
|
@ -443,34 +446,28 @@ fn memory_management_error_conditions() {
|
|||
|
||||
// XXX: May succeed or fail depending on implementation. We can't really
|
||||
// know, so assert both.
|
||||
assert!(null_incref_err == nix_err_NIX_OK || null_incref_err == nix_err_NIX_ERR_UNKNOWN);
|
||||
assert!(null_incref_err == NixErr::Ok || null_incref_err == NixErr::Unknown);
|
||||
|
||||
let null_decref_err = nix_gc_decref(ctx, std::ptr::null() as *const ::std::os::raw::c_void);
|
||||
assert!(null_decref_err == nix_err_NIX_OK || null_decref_err == nix_err_NIX_ERR_UNKNOWN);
|
||||
assert!(null_decref_err == NixErr::Ok || null_decref_err == NixErr::Unknown);
|
||||
|
||||
let null_value_incref_err = nix_value_incref(ctx, std::ptr::null_mut());
|
||||
// Some Nix APIs gracefully handle null pointers and return OK
|
||||
assert!(
|
||||
null_value_incref_err == nix_err_NIX_OK
|
||||
|| null_value_incref_err == nix_err_NIX_ERR_UNKNOWN
|
||||
);
|
||||
assert!(null_value_incref_err == NixErr::Ok || null_value_incref_err == NixErr::Unknown);
|
||||
|
||||
let null_value_decref_err = nix_value_decref(ctx, std::ptr::null_mut());
|
||||
// Some Nix APIs gracefully handle null pointers and return OK
|
||||
assert!(
|
||||
null_value_decref_err == nix_err_NIX_OK
|
||||
|| null_value_decref_err == nix_err_NIX_ERR_UNKNOWN
|
||||
);
|
||||
assert!(null_value_decref_err == NixErr::Ok || null_value_decref_err == NixErr::Unknown);
|
||||
|
||||
// Test copy with NULL values
|
||||
let err = nix_libutil_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
let err = nix_libstore_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
let err = nix_libexpr_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
|
||||
assert!(!store.is_null());
|
||||
|
|
@ -479,7 +476,7 @@ fn memory_management_error_conditions() {
|
|||
assert!(!builder.is_null());
|
||||
|
||||
let load_err = nix_eval_state_builder_load(ctx, builder);
|
||||
assert_eq!(load_err, nix_err_NIX_OK);
|
||||
assert_eq!(load_err, NixErr::Ok);
|
||||
|
||||
let state = nix_eval_state_build(ctx, builder);
|
||||
assert!(!state.is_null());
|
||||
|
|
@ -489,10 +486,10 @@ fn memory_management_error_conditions() {
|
|||
|
||||
// Test copying to/from NULL
|
||||
let copy_from_null_err = nix_copy_value(ctx, valid_value, std::ptr::null_mut());
|
||||
assert_ne!(copy_from_null_err, nix_err_NIX_OK);
|
||||
assert_ne!(copy_from_null_err, NixErr::Ok);
|
||||
|
||||
let copy_to_null_err = nix_copy_value(ctx, std::ptr::null_mut(), valid_value);
|
||||
assert_ne!(copy_to_null_err, nix_err_NIX_OK);
|
||||
assert_ne!(copy_to_null_err, NixErr::Ok);
|
||||
|
||||
// Clean up
|
||||
nix_value_decref(ctx, valid_value);
|
||||
|
|
|
|||
|
|
@ -1,13 +1,12 @@
|
|||
#![cfg(feature = "nix-expr-c")]
|
||||
#![cfg(test)]
|
||||
|
||||
use std::{
|
||||
ffi::CString,
|
||||
sync::atomic::{AtomicU32, Ordering},
|
||||
};
|
||||
use std::ffi::CString;
|
||||
use std::sync::atomic::{AtomicU32, Ordering};
|
||||
|
||||
use serial_test::serial;
|
||||
|
||||
use nixide_sys::*;
|
||||
use serial_test::serial;
|
||||
|
||||
#[derive(Debug)]
|
||||
struct TestPrimOpData {
|
||||
|
|
@ -18,10 +17,10 @@ struct TestPrimOpData {
|
|||
// Simple PrimOp that adds 1 to an integer argument
|
||||
unsafe extern "C" fn add_one_primop(
|
||||
user_data: *mut ::std::os::raw::c_void,
|
||||
context: *mut nix_c_context,
|
||||
context: *mut NixCContext,
|
||||
state: *mut EvalState,
|
||||
args: *mut *mut nix_value,
|
||||
ret: *mut nix_value,
|
||||
args: *mut *mut NixValue,
|
||||
ret: *mut NixValue,
|
||||
) {
|
||||
if user_data.is_null()
|
||||
|| context.is_null()
|
||||
|
|
@ -32,7 +31,7 @@ unsafe extern "C" fn add_one_primop(
|
|||
let _ = unsafe {
|
||||
nix_set_err_msg(
|
||||
context,
|
||||
nix_err_NIX_ERR_UNKNOWN,
|
||||
NixErr::Unknown,
|
||||
b"Null pointer in add_one_primop\0".as_ptr() as *const _,
|
||||
)
|
||||
};
|
||||
|
|
@ -48,7 +47,7 @@ unsafe extern "C" fn add_one_primop(
|
|||
let _ = unsafe {
|
||||
nix_set_err_msg(
|
||||
context,
|
||||
nix_err_NIX_ERR_UNKNOWN,
|
||||
NixErr::Unknown,
|
||||
b"Missing argument in add_one_primop\0".as_ptr() as *const _,
|
||||
)
|
||||
};
|
||||
|
|
@ -56,16 +55,16 @@ unsafe extern "C" fn add_one_primop(
|
|||
}
|
||||
|
||||
// Force evaluation of argument
|
||||
if unsafe { nix_value_force(context, state, arg) } != nix_err_NIX_OK {
|
||||
if unsafe { nix_value_force(context, state, arg) } != NixErr::Ok {
|
||||
return;
|
||||
}
|
||||
|
||||
// Check if argument is integer
|
||||
if unsafe { nix_get_type(context, arg) } != ValueType_NIX_TYPE_INT {
|
||||
if unsafe { nix_get_type(context, arg) } != ValueType::Int {
|
||||
let _ = unsafe {
|
||||
nix_set_err_msg(
|
||||
context,
|
||||
nix_err_NIX_ERR_UNKNOWN,
|
||||
NixErr::Unknown,
|
||||
b"Expected integer argument in add_one_primop\0".as_ptr() as *const _,
|
||||
)
|
||||
};
|
||||
|
|
@ -83,10 +82,10 @@ unsafe extern "C" fn add_one_primop(
|
|||
// PrimOp that returns a constant string
|
||||
unsafe extern "C" fn hello_world_primop(
|
||||
_user_data: *mut ::std::os::raw::c_void,
|
||||
context: *mut nix_c_context,
|
||||
context: *mut NixCContext,
|
||||
_state: *mut EvalState,
|
||||
_args: *mut *mut nix_value,
|
||||
ret: *mut nix_value,
|
||||
_args: *mut *mut NixValue,
|
||||
ret: *mut NixValue,
|
||||
) {
|
||||
let hello = CString::new("Hello from Rust PrimOp!").unwrap();
|
||||
let _ = unsafe { nix_init_string(context, ret, hello.as_ptr()) };
|
||||
|
|
@ -95,10 +94,10 @@ unsafe extern "C" fn hello_world_primop(
|
|||
// PrimOp that takes multiple arguments and concatenates them
|
||||
unsafe extern "C" fn concat_strings_primop(
|
||||
_user_data: *mut ::std::os::raw::c_void,
|
||||
context: *mut nix_c_context,
|
||||
context: *mut NixCContext,
|
||||
state: *mut EvalState,
|
||||
args: *mut *mut nix_value,
|
||||
ret: *mut nix_value,
|
||||
args: *mut *mut NixValue,
|
||||
ret: *mut NixValue,
|
||||
) {
|
||||
if context.is_null() || state.is_null() || args.is_null() || ret.is_null() {
|
||||
return;
|
||||
|
|
@ -113,7 +112,7 @@ unsafe extern "C" fn concat_strings_primop(
|
|||
let _ = unsafe {
|
||||
nix_set_err_msg(
|
||||
context,
|
||||
nix_err_NIX_ERR_UNKNOWN,
|
||||
NixErr::Unknown,
|
||||
b"Missing argument in concat_strings_primop\0".as_ptr() as *const _,
|
||||
)
|
||||
};
|
||||
|
|
@ -121,15 +120,15 @@ unsafe extern "C" fn concat_strings_primop(
|
|||
}
|
||||
|
||||
// Force evaluation
|
||||
if unsafe { nix_value_force(context, state, arg) } != nix_err_NIX_OK {
|
||||
if unsafe { nix_value_force(context, state, arg) } != NixErr::Ok {
|
||||
return;
|
||||
}
|
||||
|
||||
// Check if it's a string
|
||||
if unsafe { nix_get_type(context, arg) } != ValueType_NIX_TYPE_STRING {
|
||||
if unsafe { nix_get_type(context, arg) } != ValueType::String {
|
||||
let _ = unsafe {
|
||||
static ITEMS: &[u8] = b"Expected string argument in concat_strings_primop\0";
|
||||
nix_set_err_msg(context, nix_err_NIX_ERR_UNKNOWN, ITEMS.as_ptr() as *const _)
|
||||
nix_set_err_msg(context, NixErr::Unknown, ITEMS.as_ptr() as *const _)
|
||||
};
|
||||
return;
|
||||
}
|
||||
|
|
@ -168,13 +167,13 @@ fn primop_allocation_and_registration() {
|
|||
assert!(!ctx.is_null());
|
||||
|
||||
let err = nix_libutil_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
let err = nix_libstore_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
let err = nix_libexpr_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
|
||||
assert!(!store.is_null());
|
||||
|
|
@ -183,7 +182,7 @@ fn primop_allocation_and_registration() {
|
|||
assert!(!builder.is_null());
|
||||
|
||||
let load_err = nix_eval_state_builder_load(ctx, builder);
|
||||
assert_eq!(load_err, nix_err_NIX_OK);
|
||||
assert_eq!(load_err, NixErr::Ok);
|
||||
|
||||
let state = nix_eval_state_build(ctx, builder);
|
||||
assert!(!state.is_null());
|
||||
|
|
@ -220,7 +219,7 @@ fn primop_allocation_and_registration() {
|
|||
let register_err = nix_register_primop(ctx, primop);
|
||||
// Registration may fail in some environments, but allocation should work
|
||||
assert!(
|
||||
register_err == nix_err_NIX_OK || register_err == nix_err_NIX_ERR_UNKNOWN,
|
||||
register_err == NixErr::Ok || register_err == NixErr::Unknown,
|
||||
"Unexpected error code: {register_err}"
|
||||
);
|
||||
|
||||
|
|
@ -229,7 +228,7 @@ fn primop_allocation_and_registration() {
|
|||
assert!(!primop_value.is_null());
|
||||
|
||||
let init_err = nix_init_primop(ctx, primop_value, primop);
|
||||
assert_eq!(init_err, nix_err_NIX_OK);
|
||||
assert_eq!(init_err, NixErr::Ok);
|
||||
|
||||
// Clean up value
|
||||
nix_value_decref(ctx, primop_value);
|
||||
|
|
@ -252,13 +251,13 @@ fn primop_function_call() {
|
|||
assert!(!ctx.is_null());
|
||||
|
||||
let err = nix_libutil_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
let err = nix_libstore_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
let err = nix_libexpr_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
|
||||
assert!(!store.is_null());
|
||||
|
|
@ -267,7 +266,7 @@ fn primop_function_call() {
|
|||
assert!(!builder.is_null());
|
||||
|
||||
let load_err = nix_eval_state_builder_load(ctx, builder);
|
||||
assert_eq!(load_err, nix_err_NIX_OK);
|
||||
assert_eq!(load_err, NixErr::Ok);
|
||||
|
||||
let state = nix_eval_state_build(ctx, builder);
|
||||
assert!(!state.is_null());
|
||||
|
|
@ -300,21 +299,21 @@ fn primop_function_call() {
|
|||
assert!(!primop_value.is_null());
|
||||
|
||||
let init_err = nix_init_primop(ctx, primop_value, hello_primop);
|
||||
assert_eq!(init_err, nix_err_NIX_OK);
|
||||
assert_eq!(init_err, NixErr::Ok);
|
||||
|
||||
// Call the PrimOp (no arguments)
|
||||
let result = nix_alloc_value(ctx, state);
|
||||
assert!(!result.is_null());
|
||||
|
||||
let call_err = nix_value_call(ctx, state, primop_value, std::ptr::null_mut(), result);
|
||||
if call_err == nix_err_NIX_OK {
|
||||
if call_err == NixErr::Ok {
|
||||
// Force the result
|
||||
let force_err = nix_value_force(ctx, state, result);
|
||||
assert_eq!(force_err, nix_err_NIX_OK);
|
||||
assert_eq!(force_err, NixErr::Ok);
|
||||
|
||||
// Check if result is a string
|
||||
let result_type = nix_get_type(ctx, result);
|
||||
if result_type == ValueType_NIX_TYPE_STRING {
|
||||
if result_type == ValueType::String {
|
||||
// Get string value
|
||||
unsafe extern "C" fn string_callback(
|
||||
start: *const ::std::os::raw::c_char,
|
||||
|
|
@ -337,10 +336,12 @@ fn primop_function_call() {
|
|||
);
|
||||
|
||||
// Verify we got the expected string
|
||||
assert!(string_result
|
||||
.as_deref()
|
||||
.unwrap_or("")
|
||||
.contains("Hello from Rust"));
|
||||
assert!(
|
||||
string_result
|
||||
.as_deref()
|
||||
.unwrap_or("")
|
||||
.contains("Hello from Rust")
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -365,13 +366,13 @@ fn primop_with_arguments() {
|
|||
assert!(!ctx.is_null());
|
||||
|
||||
let err = nix_libutil_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
let err = nix_libstore_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
let err = nix_libexpr_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
|
||||
assert!(!store.is_null());
|
||||
|
|
@ -380,7 +381,7 @@ fn primop_with_arguments() {
|
|||
assert!(!builder.is_null());
|
||||
|
||||
let load_err = nix_eval_state_builder_load(ctx, builder);
|
||||
assert_eq!(load_err, nix_err_NIX_OK);
|
||||
assert_eq!(load_err, NixErr::Ok);
|
||||
|
||||
let state = nix_eval_state_build(ctx, builder);
|
||||
assert!(!state.is_null());
|
||||
|
|
@ -417,28 +418,28 @@ fn primop_with_arguments() {
|
|||
assert!(!primop_value.is_null());
|
||||
|
||||
let init_err = nix_init_primop(ctx, primop_value, add_primop);
|
||||
assert_eq!(init_err, nix_err_NIX_OK);
|
||||
assert_eq!(init_err, NixErr::Ok);
|
||||
|
||||
// Create an integer argument
|
||||
let arg_value = nix_alloc_value(ctx, state);
|
||||
assert!(!arg_value.is_null());
|
||||
|
||||
let init_arg_err = nix_init_int(ctx, arg_value, 42);
|
||||
assert_eq!(init_arg_err, nix_err_NIX_OK);
|
||||
assert_eq!(init_arg_err, NixErr::Ok);
|
||||
|
||||
// Call the PrimOp with the argument
|
||||
let result = nix_alloc_value(ctx, state);
|
||||
assert!(!result.is_null());
|
||||
|
||||
let call_err = nix_value_call(ctx, state, primop_value, arg_value, result);
|
||||
if call_err == nix_err_NIX_OK {
|
||||
if call_err == NixErr::Ok {
|
||||
// Force the result
|
||||
let force_err = nix_value_force(ctx, state, result);
|
||||
assert_eq!(force_err, nix_err_NIX_OK);
|
||||
assert_eq!(force_err, NixErr::Ok);
|
||||
|
||||
// Check if result is an integer
|
||||
let result_type = nix_get_type(ctx, result);
|
||||
if result_type == ValueType_NIX_TYPE_INT {
|
||||
if result_type == ValueType::Int {
|
||||
let result_value = nix_get_int(ctx, result);
|
||||
assert_eq!(result_value, 43); // 42 + 1
|
||||
|
||||
|
|
@ -471,13 +472,13 @@ fn primop_multi_argument() {
|
|||
assert!(!ctx.is_null());
|
||||
|
||||
let err = nix_libutil_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
let err = nix_libstore_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
let err = nix_libexpr_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
|
||||
assert!(!store.is_null());
|
||||
|
|
@ -486,7 +487,7 @@ fn primop_multi_argument() {
|
|||
assert!(!builder.is_null());
|
||||
|
||||
let load_err = nix_eval_state_builder_load(ctx, builder);
|
||||
assert_eq!(load_err, nix_err_NIX_OK);
|
||||
assert_eq!(load_err, NixErr::Ok);
|
||||
|
||||
let state = nix_eval_state_build(ctx, builder);
|
||||
assert!(!state.is_null());
|
||||
|
|
@ -516,7 +517,7 @@ fn primop_multi_argument() {
|
|||
assert!(!primop_value.is_null());
|
||||
|
||||
let init_err = nix_init_primop(ctx, primop_value, concat_primop);
|
||||
assert_eq!(init_err, nix_err_NIX_OK);
|
||||
assert_eq!(init_err, NixErr::Ok);
|
||||
|
||||
// Create string arguments
|
||||
let arg1 = nix_alloc_value(ctx, state);
|
||||
|
|
@ -528,8 +529,8 @@ fn primop_multi_argument() {
|
|||
|
||||
let init_arg1_err = nix_init_string(ctx, arg1, hello_cstr.as_ptr());
|
||||
let init_arg2_err = nix_init_string(ctx, arg2, world_cstr.as_ptr());
|
||||
assert_eq!(init_arg1_err, nix_err_NIX_OK);
|
||||
assert_eq!(init_arg2_err, nix_err_NIX_OK);
|
||||
assert_eq!(init_arg1_err, NixErr::Ok);
|
||||
assert_eq!(init_arg2_err, NixErr::Ok);
|
||||
|
||||
// Test multi-argument call using nix_value_call_multi
|
||||
let mut args = [arg1, arg2];
|
||||
|
|
@ -538,14 +539,14 @@ fn primop_multi_argument() {
|
|||
|
||||
let call_err =
|
||||
nix_value_call_multi(ctx, state, primop_value, 2, args.as_mut_ptr(), result);
|
||||
if call_err == nix_err_NIX_OK {
|
||||
if call_err == NixErr::Ok {
|
||||
// Force the result
|
||||
let force_err = nix_value_force(ctx, state, result);
|
||||
assert_eq!(force_err, nix_err_NIX_OK);
|
||||
assert_eq!(force_err, NixErr::Ok);
|
||||
|
||||
// Check if result is a string
|
||||
let result_type = nix_get_type(ctx, result);
|
||||
if result_type == ValueType_NIX_TYPE_STRING {
|
||||
if result_type == ValueType::String {
|
||||
unsafe extern "C" fn string_callback(
|
||||
start: *const ::std::os::raw::c_char,
|
||||
n: ::std::os::raw::c_uint,
|
||||
|
|
@ -592,13 +593,13 @@ fn primop_error_handling() {
|
|||
assert!(!ctx.is_null());
|
||||
|
||||
let err = nix_libutil_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
let err = nix_libstore_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
let err = nix_libexpr_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
|
||||
assert!(!store.is_null());
|
||||
|
|
@ -607,7 +608,7 @@ fn primop_error_handling() {
|
|||
assert!(!builder.is_null());
|
||||
|
||||
let load_err = nix_eval_state_builder_load(ctx, builder);
|
||||
assert_eq!(load_err, nix_err_NIX_OK);
|
||||
assert_eq!(load_err, NixErr::Ok);
|
||||
|
||||
let state = nix_eval_state_build(ctx, builder);
|
||||
assert!(!state.is_null());
|
||||
|
|
|
|||
|
|
@ -1,10 +1,12 @@
|
|||
#![cfg(feature = "nix-store-c")]
|
||||
#![cfg(test)]
|
||||
|
||||
use std::{ffi::CString, ptr};
|
||||
use std::ffi::CString;
|
||||
use std::ptr;
|
||||
|
||||
use serial_test::serial;
|
||||
|
||||
use nixide_sys::*;
|
||||
use serial_test::serial;
|
||||
|
||||
#[test]
|
||||
#[serial]
|
||||
|
|
@ -13,7 +15,7 @@ fn libstore_init_and_open_free() {
|
|||
let ctx = nix_c_context_create();
|
||||
assert!(!ctx.is_null());
|
||||
let err = nix_libstore_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
// Open the default store (NULL URI, NULL params)
|
||||
let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
|
||||
|
|
@ -32,7 +34,7 @@ fn parse_and_clone_free_store_path() {
|
|||
let ctx = nix_c_context_create();
|
||||
assert!(!ctx.is_null());
|
||||
let err = nix_libstore_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
|
||||
assert!(!store.is_null());
|
||||
|
|
@ -74,14 +76,14 @@ fn store_get_uri_and_storedir() {
|
|||
let ctx = nix_c_context_create();
|
||||
assert!(!ctx.is_null());
|
||||
let err = nix_libstore_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
let store = nix_store_open(ctx, ptr::null(), ptr::null_mut());
|
||||
assert!(!store.is_null());
|
||||
|
||||
let mut uri: Option<String> = None;
|
||||
let res = nix_store_get_uri(ctx, store, Some(string_callback), (&raw mut uri).cast());
|
||||
assert_eq!(res, nix_err_NIX_OK);
|
||||
assert_eq!(res, NixErr::Ok);
|
||||
assert!(uri.is_some());
|
||||
|
||||
let mut storedir: Option<String> = None;
|
||||
|
|
@ -91,7 +93,7 @@ fn store_get_uri_and_storedir() {
|
|||
Some(string_callback),
|
||||
(&raw mut storedir).cast(),
|
||||
);
|
||||
assert_eq!(res, nix_err_NIX_OK);
|
||||
assert_eq!(res, NixErr::Ok);
|
||||
assert!(storedir.is_some());
|
||||
|
||||
nix_store_free(store);
|
||||
|
|
@ -106,7 +108,7 @@ fn libstore_init_no_load_config() {
|
|||
let ctx = nix_c_context_create();
|
||||
assert!(!ctx.is_null());
|
||||
let err = nix_libstore_init_no_load_config(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
nix_c_context_free(ctx);
|
||||
}
|
||||
}
|
||||
|
|
@ -129,7 +131,7 @@ fn store_is_valid_path_and_real_path() {
|
|||
let ctx = nix_c_context_create();
|
||||
assert!(!ctx.is_null());
|
||||
let err = nix_libstore_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
|
||||
assert!(!store.is_null());
|
||||
|
|
@ -150,7 +152,7 @@ fn store_is_valid_path_and_real_path() {
|
|||
(&raw mut real_path).cast(),
|
||||
);
|
||||
// May fail, but should not crash
|
||||
assert!(res == nix_err_NIX_OK || res == nix_err_NIX_ERR_UNKNOWN);
|
||||
assert!(res == NixErr::Ok || res == NixErr::Unknown);
|
||||
nix_store_path_free(store_path);
|
||||
}
|
||||
|
||||
|
|
@ -177,7 +179,7 @@ fn store_path_name() {
|
|||
let ctx = nix_c_context_create();
|
||||
assert!(!ctx.is_null());
|
||||
let err = nix_libstore_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
|
||||
assert!(!store.is_null());
|
||||
|
|
@ -215,7 +217,7 @@ fn store_get_version() {
|
|||
let ctx = nix_c_context_create();
|
||||
assert!(!ctx.is_null());
|
||||
let err = nix_libstore_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
|
||||
assert!(!store.is_null());
|
||||
|
|
@ -223,7 +225,7 @@ fn store_get_version() {
|
|||
let mut version: Option<String> = None;
|
||||
let res =
|
||||
nix_store_get_version(ctx, store, Some(string_callback), (&raw mut version).cast());
|
||||
assert_eq!(res, nix_err_NIX_OK);
|
||||
assert_eq!(res, NixErr::Ok);
|
||||
// Version may be empty for dummy stores, but should not crash
|
||||
assert!(version.is_some());
|
||||
|
||||
|
|
@ -249,7 +251,7 @@ fn store_realise_and_copy_closure() {
|
|||
let ctx = nix_c_context_create();
|
||||
assert!(!ctx.is_null());
|
||||
let err = nix_libstore_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
let store = nix_store_open(ctx, std::ptr::null(), std::ptr::null_mut());
|
||||
assert!(!store.is_null());
|
||||
|
|
|
|||
|
|
@ -1,10 +1,12 @@
|
|||
#![cfg(feature = "nix-util-c")]
|
||||
#![cfg(test)]
|
||||
|
||||
use std::ffi::{CStr, CString};
|
||||
|
||||
use nixide_sys::*;
|
||||
use serial_test::serial;
|
||||
|
||||
use nixide_sys::*;
|
||||
|
||||
#[test]
|
||||
#[serial]
|
||||
fn context_create_and_free() {
|
||||
|
|
@ -22,7 +24,7 @@ fn libutil_init() {
|
|||
let ctx = nix_c_context_create();
|
||||
assert!(!ctx.is_null());
|
||||
let err = nix_libutil_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
nix_c_context_free(ctx);
|
||||
}
|
||||
}
|
||||
|
|
@ -60,7 +62,7 @@ fn setting_set_and_get() {
|
|||
let ctx = nix_c_context_create();
|
||||
assert!(!ctx.is_null());
|
||||
let err = nix_libutil_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
// Set a setting (use a dummy/extra setting to avoid breaking global config)
|
||||
let key = CString::new("extra-test-setting").unwrap();
|
||||
|
|
@ -68,7 +70,7 @@ fn setting_set_and_get() {
|
|||
let set_err = nix_setting_set(ctx, key.as_ptr(), value.as_ptr());
|
||||
// Setting may not exist, but should not crash
|
||||
assert!(
|
||||
set_err == nix_err_NIX_OK || set_err == nix_err_NIX_ERR_KEY,
|
||||
set_err == NixErr::Ok || set_err == NixErr::Key,
|
||||
"Unexpected error code: {set_err}"
|
||||
);
|
||||
|
||||
|
|
@ -81,11 +83,11 @@ fn setting_set_and_get() {
|
|||
(&raw mut got).cast(),
|
||||
);
|
||||
assert!(
|
||||
get_err == nix_err_NIX_OK || get_err == nix_err_NIX_ERR_KEY,
|
||||
get_err == NixErr::Ok || get_err == NixErr::Key,
|
||||
"Unexpected error code: {get_err}"
|
||||
);
|
||||
// If OK, we should have gotten a value
|
||||
if get_err == nix_err_NIX_OK {
|
||||
if get_err == NixErr::Ok {
|
||||
assert_eq!(got.as_deref(), Some("test-value"));
|
||||
}
|
||||
|
||||
|
|
@ -111,16 +113,16 @@ fn error_handling_apis() {
|
|||
let ctx = nix_c_context_create();
|
||||
assert!(!ctx.is_null());
|
||||
let err = nix_libutil_init(ctx);
|
||||
assert_eq!(err, nix_err_NIX_OK);
|
||||
assert_eq!(err, NixErr::Ok);
|
||||
|
||||
// Set an error message
|
||||
let msg = CString::new("custom error message").unwrap();
|
||||
let set_err = nix_set_err_msg(ctx, nix_err_NIX_ERR_UNKNOWN, msg.as_ptr());
|
||||
assert_eq!(set_err, nix_err_NIX_ERR_UNKNOWN);
|
||||
let set_err = nix_set_err_msg(ctx, NixErr::Unknown, msg.as_ptr());
|
||||
assert_eq!(set_err, NixErr::Unknown);
|
||||
|
||||
// Get error code
|
||||
let code = nix_err_code(ctx);
|
||||
assert_eq!(code, nix_err_NIX_ERR_UNKNOWN);
|
||||
assert_eq!(code, NixErr::Unknown);
|
||||
|
||||
// Get error message
|
||||
let mut len: std::os::raw::c_uint = 0;
|
||||
|
|
@ -145,7 +147,7 @@ fn error_handling_apis() {
|
|||
// Clear error
|
||||
nix_clear_err(ctx);
|
||||
let code_after_clear = nix_err_code(ctx);
|
||||
assert_eq!(code_after_clear, nix_err_NIX_OK);
|
||||
assert_eq!(code_after_clear, NixErr::Ok);
|
||||
|
||||
nix_c_context_free(ctx);
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue