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);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -57,42 +57,29 @@ use crate::util::wrappers::AsInnerPtr;
|
|||
/// };
|
||||
/// ```
|
||||
///
|
||||
/// The [sys::nix_c_context] struct is laid out so that it can also be
|
||||
/// cast to a [sys::nix_err] to inspect directly:
|
||||
/// The [NixCContext] struct is laid out so that it can also be
|
||||
/// cast to a [sys::NixErr] to inspect directly:
|
||||
/// ```c
|
||||
/// assert(*(nix_err*)ctx == NIX_OK);
|
||||
/// ```
|
||||
///
|
||||
pub(crate) struct ErrorContext {
|
||||
inner: NonNull<sys::nix_c_context>,
|
||||
inner: NonNull<sys::NixCContext>,
|
||||
}
|
||||
|
||||
// impl Clone for ErrorContext {
|
||||
// fn clone(&self) -> Self {
|
||||
// let inner = self.inner.clone();
|
||||
//
|
||||
// wrap::nix_fn!(|ctx: &ErrorContext| unsafe {
|
||||
// sys::nix_gc_incref(ctx.as_ptr(), self.as_ptr() as *mut c_void);
|
||||
// })
|
||||
// .unwrap();
|
||||
//
|
||||
// Self { inner }
|
||||
// }
|
||||
// }
|
||||
|
||||
impl AsInnerPtr<sys::nix_c_context> for ErrorContext {
|
||||
impl AsInnerPtr<sys::NixCContext> for ErrorContext {
|
||||
#[inline]
|
||||
unsafe fn as_ptr(&self) -> *mut sys::nix_c_context {
|
||||
unsafe fn as_ptr(&self) -> *mut sys::NixCContext {
|
||||
self.inner.as_ptr()
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn as_ref(&self) -> &sys::nix_c_context {
|
||||
unsafe fn as_ref(&self) -> &sys::NixCContext {
|
||||
unsafe { self.inner.as_ref() }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn as_mut(&mut self) -> &mut sys::nix_c_context {
|
||||
unsafe fn as_mut(&mut self) -> &mut sys::NixCContext {
|
||||
unsafe { self.inner.as_mut() }
|
||||
}
|
||||
}
|
||||
|
|
@ -100,11 +87,11 @@ impl AsInnerPtr<sys::nix_c_context> for ErrorContext {
|
|||
impl Into<NixideResult<()>> for &ErrorContext {
|
||||
/// # Panics
|
||||
///
|
||||
/// This function will panic in the event that `context.get_err() == Some(err) && err == sys::nix_err_NIX_OK`
|
||||
/// since `nixide::ErrorContext::get_err` is expected to return `None` to indicate `sys::nix_err_NIX_OK`.
|
||||
/// This function will panic in the event that `context.get_err() == Some(err) && err == sys::NixErr::NIX_OK`
|
||||
/// since `nixide::ErrorContext::get_err` is expected to return `None` to indicate `sys::NixErr::NIX_OK`.
|
||||
///
|
||||
/// This function will panic in the event that `value != sys::nix_err_NIX_OK`
|
||||
/// but that `context.get_code() == sys::nix_err_NIX_OK`
|
||||
/// This function will panic in the event that `value != sys::NixErr::NIX_OK`
|
||||
/// but that `context.get_code() == sys::NixErr::NIX_OK`
|
||||
///
|
||||
fn into(self) -> NixideResult<()> {
|
||||
let inner = match self.get_err() {
|
||||
|
|
@ -117,11 +104,11 @@ impl Into<NixideResult<()>> for &ErrorContext {
|
|||
};
|
||||
|
||||
let err = match inner {
|
||||
sys::nix_err_NIX_OK => unreachable!(),
|
||||
sys::NixErr::Ok => unreachable!(),
|
||||
|
||||
sys::nix_err_NIX_ERR_OVERFLOW => NixError::Overflow,
|
||||
sys::nix_err_NIX_ERR_KEY => NixError::KeyNotFound(None),
|
||||
sys::nix_err_NIX_ERR_NIX_ERROR => NixError::ExprEval {
|
||||
sys::NixErr::Overflow => NixError::Overflow,
|
||||
sys::NixErr::Key => NixError::KeyNotFound(None),
|
||||
sys::NixErr::NixError => NixError::ExprEval {
|
||||
name: self
|
||||
.get_nix_err_name()
|
||||
.unwrap_or_else(|| panic_issue_call_failed!()),
|
||||
|
|
@ -131,7 +118,7 @@ impl Into<NixideResult<()>> for &ErrorContext {
|
|||
.unwrap_or_else(|| panic_issue_call_failed!()),
|
||||
},
|
||||
|
||||
sys::nix_err_NIX_ERR_UNKNOWN => NixError::Unknown,
|
||||
sys::NixErr::Unknown => NixError::Unknown,
|
||||
err => NixError::Undocumented(err),
|
||||
};
|
||||
|
||||
|
|
@ -145,13 +132,13 @@ impl ErrorContext {
|
|||
/// # Errors
|
||||
///
|
||||
/// Returns an error if no memory can be allocated for
|
||||
/// the underlying [sys::nix_c_context] struct.
|
||||
/// the underlying [NixCContext] struct.
|
||||
///
|
||||
pub fn new() -> Self {
|
||||
match NonNull::new(unsafe { sys::nix_c_context_create() }) {
|
||||
Some(inner) => ErrorContext { inner },
|
||||
None => panic!(
|
||||
"[nixide] CRITICAL FAILURE: Out-Of-Memory condition reached - `sys::nix_c_context_create` allocation failed!"
|
||||
"[nixide] CRITICAL FAILURE: Out-Of-Memory condition reached - `NixCContext_create` allocation failed!"
|
||||
),
|
||||
}
|
||||
}
|
||||
|
|
@ -216,12 +203,12 @@ impl ErrorContext {
|
|||
Ok(())
|
||||
}
|
||||
|
||||
/// Returns [None] if [self.code] is [sys::nix_err_NIX_OK], and [Some] otherwise.
|
||||
/// Returns [None] if [self.code] is [sys::NixErr::NIX_OK], and [Some] otherwise.
|
||||
///
|
||||
/// # Nix C++ API Internals
|
||||
///
|
||||
/// ```cpp
|
||||
/// nix_err nix_err_code(const nix_c_context * read_context)
|
||||
/// nix_err nix_err::code(const nix_c_context * read_context)
|
||||
/// {
|
||||
/// return read_context->last_err_code;
|
||||
/// }
|
||||
|
|
@ -229,19 +216,19 @@ impl ErrorContext {
|
|||
///
|
||||
/// This function **never fails**.
|
||||
///
|
||||
fn get_err(&self) -> Option<sys::nix_err> {
|
||||
fn get_err(&self) -> Option<sys::NixErr> {
|
||||
match unsafe { sys::nix_err_code(self.as_ptr()) } {
|
||||
sys::nix_err_NIX_OK => None,
|
||||
sys::NixErr::Ok => None,
|
||||
err => Some(err),
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns [None] if [self.code] is [sys::nix_err_NIX_OK], and [Some] otherwise.
|
||||
/// Returns [None] if [self.code] is [sys::NixErr::NIX_OK], and [Some] otherwise.
|
||||
///
|
||||
/// # Nix C++ API Internals
|
||||
///
|
||||
/// ```cpp
|
||||
/// const char * nix_err_msg(nix_c_context * context, const nix_c_context * read_context, unsigned int * n)
|
||||
/// const char * nix_err::msg(nix_c_context * context, const nix_c_context * read_context, unsigned int * n)
|
||||
/// {
|
||||
/// if (context)
|
||||
/// context->last_err_code = NIX_OK;
|
||||
|
|
@ -250,21 +237,21 @@ impl ErrorContext {
|
|||
/// *n = read_context->last_err->size();
|
||||
/// return read_context->last_err->c_str();
|
||||
/// }
|
||||
/// nix_set_err_msg(context, NIX_ERR_UNKNOWN, "No error message");
|
||||
/// nix_set_err_msg(context, NIX_ERR::UNKNOWN, "No error message");
|
||||
/// return nullptr;
|
||||
/// }
|
||||
/// ```
|
||||
///
|
||||
/// # Note
|
||||
///
|
||||
/// On failure [sys::nix_err_name] does the following if the error
|
||||
/// has the error code [sys::nix_err_NIX_OK]:
|
||||
/// On failure [sys::NixErr::name] does the following if the error
|
||||
/// has the error code [sys::NixErr::NIX_OK]:
|
||||
/// ```cpp
|
||||
/// nix_set_err_msg(context, NIX_ERR_UNKNOWN, "No error message");
|
||||
/// nix_set_err_msg(context, NIX_ERR::UNKNOWN, "No error message");
|
||||
/// return nullptr;
|
||||
/// ```
|
||||
/// Hence we can just test whether the returned pointer is a `NULL` pointer,
|
||||
/// and avoid passing in a [sys::nix_c_context] struct.
|
||||
/// and avoid passing in a [NixCContext] struct.
|
||||
///
|
||||
fn get_msg(&self) -> Option<String> {
|
||||
// NOTE: an Err here only occurs when `self.get_code() == Ok(())`
|
||||
|
|
@ -281,13 +268,13 @@ impl ErrorContext {
|
|||
}
|
||||
}
|
||||
|
||||
/// Returns [None] if [self.code] is [sys::nix_err_NIX_OK], and [Some] otherwise.
|
||||
/// Returns [None] if [self.code] is [sys::NixErr::NIX_OK], and [Some] otherwise.
|
||||
///
|
||||
/// # Nix C++ API Internals
|
||||
///
|
||||
/// ```cpp
|
||||
/// // NOTE(nixide): the implementation of `nix_err_info_msg` is identical to `nix_err_name`
|
||||
/// nix_err nix_err_info_msg(
|
||||
/// // NOTE(nixide): the implementation of `nix_err::info_msg` is identical to `nix_err::name`
|
||||
/// nix_err nix_err::info_msg(
|
||||
/// nix_c_context * context,
|
||||
/// const nix_c_context * read_context,
|
||||
/// nix_get_string_callback callback,
|
||||
|
|
@ -295,16 +282,16 @@ impl ErrorContext {
|
|||
/// {
|
||||
/// if (context)
|
||||
/// context->last_err_code = NIX_OK;
|
||||
/// if (read_context->last_err_code != NIX_ERR_NIX_ERROR) {
|
||||
/// if (read_context->last_err_code != NIX_ERR::NIX_ERROR) {
|
||||
/// // NOTE(nixide): `nix_set_err_msg` throws a `nix::Error` exception if `context == nullptr`
|
||||
/// return nix_set_err_msg(context, NIX_ERR_UNKNOWN, "Last error was not a nix error");
|
||||
/// return nix_set_err_msg(context, NIX_ERR::UNKNOWN, "Last error was not a nix error");
|
||||
/// }
|
||||
/// // NOTE(nixide): `call_nix_get_string_callback` always returns `NIX_OK`
|
||||
/// return call_nix_get_string_callback(read_context->info->msg.str(), callback, user_data);
|
||||
/// }
|
||||
/// ```
|
||||
///
|
||||
/// `nix_err_info_msg` accepts two `nix_c_context*`:
|
||||
/// `nix_err::info_msg` accepts two `nix_c_context*`:
|
||||
/// * `nix_c_context* context` - errors from the function call are logged here
|
||||
/// * `const nix_c_context* read_context` - the context to read `info_msg` from
|
||||
///
|
||||
|
|
@ -333,13 +320,13 @@ impl ErrorContext {
|
|||
.ok()
|
||||
}
|
||||
|
||||
/// Returns [None] if [self.code] is [sys::nix_err_NIX_OK], and [Some] otherwise.
|
||||
/// Returns [None] if [self.code] is [sys::NixErr::NIX_OK], and [Some] otherwise.
|
||||
///
|
||||
/// # Nix C++ API Internals
|
||||
///
|
||||
/// ```cpp
|
||||
/// // NOTE(nixide): the implementation of `nix_err_info_msg` is identical to `nix_err_name`
|
||||
/// nix_err nix_err_info_msg(
|
||||
/// // NOTE(nixide): the implementation of `nix_err::info_msg` is identical to `nix_err::name`
|
||||
/// nix_err nix_err::info_msg(
|
||||
/// nix_c_context * context,
|
||||
/// const nix_c_context * read_context,
|
||||
/// nix_get_string_callback callback,
|
||||
|
|
@ -347,16 +334,16 @@ impl ErrorContext {
|
|||
/// {
|
||||
/// if (context)
|
||||
/// context->last_err_code = NIX_OK;
|
||||
/// if (read_context->last_err_code != NIX_ERR_NIX_ERROR) {
|
||||
/// if (read_context->last_err_code != NIX_ERR::NIX_ERROR) {
|
||||
/// // NOTE(nixide): `nix_set_err_msg` throws a `nix::Error` exception if `context == nullptr`
|
||||
/// return nix_set_err_msg(context, NIX_ERR_UNKNOWN, "Last error was not a nix error");
|
||||
/// return nix_set_err_msg(context, NIX_ERR::UNKNOWN, "Last error was not a nix error");
|
||||
/// }
|
||||
/// // NOTE(nixide): `call_nix_get_string_callback` always returns `NIX_OK`
|
||||
/// return call_nix_get_string_callback(read_context->info->msg.str(), callback, user_data);
|
||||
/// }
|
||||
/// ```
|
||||
///
|
||||
/// `nix_err_info_msg` accepts two `nix_c_context*`:
|
||||
/// `nix_err::info_msg` accepts two `nix_c_context*`:
|
||||
/// * `nix_c_context* context` - errors from the function call are logged here
|
||||
/// * `const nix_c_context* read_context` - the context to read `info_msg` from
|
||||
///
|
||||
|
|
|
|||
|
|
@ -12,7 +12,7 @@ pub enum NixideError {
|
|||
/// that is instead mapped to [NixError::ExprEval]
|
||||
NixError {
|
||||
trace: String,
|
||||
inner: sys::nix_err,
|
||||
inner: sys::NixErr,
|
||||
err: NixError,
|
||||
msg: String,
|
||||
},
|
||||
|
|
@ -84,9 +84,7 @@ pub(crate) use new_nixide_error;
|
|||
|
||||
#[allow(unused_macros)]
|
||||
macro_rules! retrace_nixide_error {
|
||||
($x:expr) => {{
|
||||
crate::errors::new_nixide_error!($x.err)
|
||||
}};
|
||||
($x:expr) => {{ crate::errors::new_nixide_error!($x.err) }};
|
||||
}
|
||||
pub(crate) use retrace_nixide_error;
|
||||
|
||||
|
|
@ -102,15 +100,15 @@ impl Display for NixideError {
|
|||
msg,
|
||||
} => {
|
||||
write!(f, "[nixide ~ {trace}]{err} (nix_err={inner}): {msg}")
|
||||
}
|
||||
},
|
||||
|
||||
NixideError::StringNulByte { trace } => {
|
||||
write!(f, "[nixide ~ {trace}] Got premature `\\0` (NUL) byte")
|
||||
}
|
||||
},
|
||||
|
||||
NixideError::StringNotUtf8 { trace } => {
|
||||
write!(f, "[nixide ~ {trace}] Expected UTF-8 encoded string")
|
||||
}
|
||||
},
|
||||
|
||||
NixideError::NullPtr { trace } => write!(f, "[nixide ~ {trace}] Got null pointer"),
|
||||
|
||||
|
|
@ -123,7 +121,7 @@ impl Display for NixideError {
|
|||
f,
|
||||
"[nixide ~ {trace}] Invalid argument `{name}`: reason \"{reason}\""
|
||||
)
|
||||
}
|
||||
},
|
||||
|
||||
NixideError::InvalidType {
|
||||
trace,
|
||||
|
|
|
|||
|
|
@ -93,15 +93,18 @@ pub enum NixError {
|
|||
///
|
||||
/// [NixError::Undocumented] has no equivalent in the `libnix` api.
|
||||
/// This is solely a language difference between C++ and Rust, since
|
||||
/// [sys::nix_err] is defined over the *"continuous" (not realy)*
|
||||
/// [sys::NixErr] is defined over the *"continuous" (not realy)*
|
||||
/// type [std::os::raw::c_int].
|
||||
Undocumented(sys::nix_err),
|
||||
Undocumented(sys::NixErr),
|
||||
}
|
||||
|
||||
impl Display for NixError {
|
||||
fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
|
||||
match self {
|
||||
NixError::ExprEval { name, info_msg } => write!(f, "[libnix] NixExpr evaluation failed [name=\"{name}\", info_msg=\"{info_msg}\"]"),
|
||||
NixError::ExprEval { name, info_msg } => write!(
|
||||
f,
|
||||
"[libnix] NixExpr evaluation failed [name=\"{name}\", info_msg=\"{info_msg}\"]"
|
||||
),
|
||||
NixError::KeyNotFound(Some(key)) => write!(f, "[libnix] Key not found \"{key}\""),
|
||||
NixError::KeyNotFound(None) => write!(f, "[libnix] Key not found"),
|
||||
NixError::Overflow => write!(f, "[libnix] Overflow error"),
|
||||
|
|
@ -115,15 +118,15 @@ impl Display for NixError {
|
|||
}
|
||||
|
||||
impl NixError {
|
||||
pub fn err_code(&self) -> sys::nix_err {
|
||||
pub fn err_code(&self) -> sys::NixErr {
|
||||
match self {
|
||||
NixError::Overflow => sys::nix_err_NIX_ERR_OVERFLOW,
|
||||
NixError::KeyNotFound(_) => sys::nix_err_NIX_ERR_NIX_ERROR,
|
||||
NixError::Overflow => sys::NixErr::Overflow,
|
||||
NixError::KeyNotFound(_) => sys::NixErr::Key,
|
||||
NixError::ExprEval {
|
||||
name: _,
|
||||
info_msg: _,
|
||||
} => sys::nix_err_NIX_ERR_NIX_ERROR,
|
||||
NixError::Unknown => sys::nix_err_NIX_ERR_UNKNOWN,
|
||||
} => sys::NixErr::NixError,
|
||||
NixError::Unknown => sys::NixErr::NixError,
|
||||
NixError::Undocumented(err) => err.clone(),
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -18,23 +18,23 @@ use crate::util::{panic_issue_call_failed, wrap};
|
|||
/// the evaluation state.
|
||||
///
|
||||
pub struct EvalStateBuilder {
|
||||
inner: Rc<RefCell<NonNull<sys::nix_eval_state_builder>>>,
|
||||
inner: Rc<RefCell<NonNull<sys::NixEvalStateBuilder>>>,
|
||||
store: Rc<RefCell<Store>>,
|
||||
}
|
||||
|
||||
impl AsInnerPtr<sys::nix_eval_state_builder> for EvalStateBuilder {
|
||||
impl AsInnerPtr<sys::NixEvalStateBuilder> for EvalStateBuilder {
|
||||
#[inline]
|
||||
unsafe fn as_ptr(&self) -> *mut sys::nix_eval_state_builder {
|
||||
unsafe fn as_ptr(&self) -> *mut sys::NixEvalStateBuilder {
|
||||
self.inner.borrow().as_ptr()
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn as_ref(&self) -> &sys::nix_eval_state_builder {
|
||||
unsafe fn as_ref(&self) -> &sys::NixEvalStateBuilder {
|
||||
unsafe { self.inner.borrow().as_ref() }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn as_mut(&mut self) -> &mut sys::nix_eval_state_builder {
|
||||
unsafe fn as_mut(&mut self) -> &mut sys::NixEvalStateBuilder {
|
||||
unsafe { self.inner.borrow_mut().as_mut() }
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -12,24 +12,24 @@ use crate::{EvalState, NixideResult, StorePath};
|
|||
use crate::{Store, sys};
|
||||
|
||||
pub struct RealisedString<'a> {
|
||||
inner: RefCell<NonNull<sys::nix_realised_string>>,
|
||||
inner: RefCell<NonNull<sys::NixRealisedString>>,
|
||||
pub path: StorePath,
|
||||
pub children: LazyArray<StorePath, Box<dyn Fn(usize) -> StorePath + 'a>>,
|
||||
}
|
||||
|
||||
impl<'a> AsInnerPtr<sys::nix_realised_string> for RealisedString<'a> {
|
||||
impl<'a> AsInnerPtr<sys::NixRealisedString> for RealisedString<'a> {
|
||||
#[inline]
|
||||
unsafe fn as_ptr(&self) -> *mut sys::nix_realised_string {
|
||||
unsafe fn as_ptr(&self) -> *mut sys::NixRealisedString {
|
||||
self.inner.borrow().as_ptr()
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn as_ref(&self) -> &sys::nix_realised_string {
|
||||
unsafe fn as_ref(&self) -> &sys::NixRealisedString {
|
||||
unsafe { self.inner.borrow().as_ref() }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn as_mut(&mut self) -> &mut sys::nix_realised_string {
|
||||
unsafe fn as_mut(&mut self) -> &mut sys::NixRealisedString {
|
||||
unsafe { self.inner.borrow_mut().as_mut() }
|
||||
}
|
||||
}
|
||||
|
|
@ -82,7 +82,7 @@ impl<'a> RealisedString<'a> {
|
|||
})
|
||||
}
|
||||
|
||||
fn parse_path(realised_string: *mut sys::nix_realised_string, store: &Store) -> StorePath {
|
||||
fn parse_path(realised_string: *mut sys::NixRealisedString, store: &Store) -> StorePath {
|
||||
let buffer_ptr = unsafe { sys::nix_realised_string_get_buffer_start(realised_string) };
|
||||
let buffer_size = unsafe { sys::nix_realised_string_get_buffer_size(realised_string) };
|
||||
|
||||
|
|
|
|||
|
|
@ -12,7 +12,7 @@ use crate::util::wrappers::AsInnerPtr;
|
|||
use crate::util::{panic_issue_call_failed, wrap};
|
||||
|
||||
pub struct NixAttrs {
|
||||
inner: NonNull<sys::nix_value>,
|
||||
inner: NonNull<sys::NixValue>,
|
||||
state: Rc<RefCell<NonNull<sys::EvalState>>>,
|
||||
len: u32,
|
||||
}
|
||||
|
|
@ -55,19 +55,19 @@ impl Debug for NixAttrs {
|
|||
}
|
||||
}
|
||||
|
||||
impl AsInnerPtr<sys::nix_value> for NixAttrs {
|
||||
impl AsInnerPtr<sys::NixValue> for NixAttrs {
|
||||
#[inline]
|
||||
unsafe fn as_ptr(&self) -> *mut sys::nix_value {
|
||||
unsafe fn as_ptr(&self) -> *mut sys::NixValue {
|
||||
self.inner.as_ptr()
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn as_ref(&self) -> &sys::nix_value {
|
||||
unsafe fn as_ref(&self) -> &sys::NixValue {
|
||||
unsafe { self.inner.as_ref() }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn as_mut(&mut self) -> &mut sys::nix_value {
|
||||
unsafe fn as_mut(&mut self) -> &mut sys::NixValue {
|
||||
unsafe { self.inner.as_mut() }
|
||||
}
|
||||
}
|
||||
|
|
@ -75,10 +75,10 @@ impl AsInnerPtr<sys::nix_value> for NixAttrs {
|
|||
impl NixValue for NixAttrs {
|
||||
#[inline]
|
||||
fn type_id(&self) -> sys::ValueType {
|
||||
sys::ValueType_NIX_TYPE_ATTRS
|
||||
sys::ValueType::Attrs
|
||||
}
|
||||
|
||||
fn from(inner: NonNull<sys::nix_value>, state: Rc<RefCell<NonNull<sys::EvalState>>>) -> Self {
|
||||
fn from(inner: NonNull<sys::NixValue>, state: Rc<RefCell<NonNull<sys::EvalState>>>) -> Self {
|
||||
let len = wrap::nix_fn!(|ctx: &ErrorContext| unsafe {
|
||||
sys::nix_get_attrs_size(ctx.as_ptr(), inner.as_ptr())
|
||||
})
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@ use crate::util::wrap;
|
|||
use crate::util::wrappers::AsInnerPtr;
|
||||
|
||||
pub struct NixBool {
|
||||
inner: NonNull<sys::nix_value>,
|
||||
inner: NonNull<sys::NixValue>,
|
||||
state: Rc<RefCell<NonNull<sys::EvalState>>>,
|
||||
value: bool,
|
||||
}
|
||||
|
|
@ -54,19 +54,19 @@ impl Debug for NixBool {
|
|||
}
|
||||
}
|
||||
|
||||
impl AsInnerPtr<sys::nix_value> for NixBool {
|
||||
impl AsInnerPtr<sys::NixValue> for NixBool {
|
||||
#[inline]
|
||||
unsafe fn as_ptr(&self) -> *mut sys::nix_value {
|
||||
unsafe fn as_ptr(&self) -> *mut sys::NixValue {
|
||||
self.inner.as_ptr()
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn as_ref(&self) -> &sys::nix_value {
|
||||
unsafe fn as_ref(&self) -> &sys::NixValue {
|
||||
unsafe { self.inner.as_ref() }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn as_mut(&mut self) -> &mut sys::nix_value {
|
||||
unsafe fn as_mut(&mut self) -> &mut sys::NixValue {
|
||||
unsafe { self.inner.as_mut() }
|
||||
}
|
||||
}
|
||||
|
|
@ -74,10 +74,10 @@ impl AsInnerPtr<sys::nix_value> for NixBool {
|
|||
impl NixValue for NixBool {
|
||||
#[inline]
|
||||
fn type_id(&self) -> sys::ValueType {
|
||||
sys::ValueType_NIX_TYPE_BOOL
|
||||
sys::ValueType::Bool
|
||||
}
|
||||
|
||||
fn from(inner: NonNull<sys::nix_value>, state: Rc<RefCell<NonNull<sys::EvalState>>>) -> Self {
|
||||
fn from(inner: NonNull<sys::NixValue>, state: Rc<RefCell<NonNull<sys::EvalState>>>) -> Self {
|
||||
let value = wrap::nix_fn!(|ctx: &ErrorContext| unsafe {
|
||||
sys::nix_get_bool(ctx.as_ptr(), inner.as_ptr())
|
||||
})
|
||||
|
|
|
|||
|
|
@ -10,7 +10,7 @@ use crate::util::wrappers::AsInnerPtr;
|
|||
use crate::util::{panic_issue_call_failed, wrap};
|
||||
|
||||
pub struct NixFloat {
|
||||
inner: NonNull<sys::nix_value>,
|
||||
inner: NonNull<sys::NixValue>,
|
||||
state: Rc<RefCell<NonNull<sys::EvalState>>>,
|
||||
value: f64,
|
||||
}
|
||||
|
|
@ -53,19 +53,19 @@ impl Debug for NixFloat {
|
|||
}
|
||||
}
|
||||
|
||||
impl AsInnerPtr<sys::nix_value> for NixFloat {
|
||||
impl AsInnerPtr<sys::NixValue> for NixFloat {
|
||||
#[inline]
|
||||
unsafe fn as_ptr(&self) -> *mut sys::nix_value {
|
||||
unsafe fn as_ptr(&self) -> *mut sys::NixValue {
|
||||
self.inner.as_ptr()
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn as_ref(&self) -> &sys::nix_value {
|
||||
unsafe fn as_ref(&self) -> &sys::NixValue {
|
||||
unsafe { self.inner.as_ref() }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn as_mut(&mut self) -> &mut sys::nix_value {
|
||||
unsafe fn as_mut(&mut self) -> &mut sys::NixValue {
|
||||
unsafe { self.inner.as_mut() }
|
||||
}
|
||||
}
|
||||
|
|
@ -73,10 +73,10 @@ impl AsInnerPtr<sys::nix_value> for NixFloat {
|
|||
impl NixValue for NixFloat {
|
||||
#[inline]
|
||||
fn type_id(&self) -> sys::ValueType {
|
||||
sys::ValueType_NIX_TYPE_FLOAT
|
||||
sys::ValueType::Float
|
||||
}
|
||||
|
||||
fn from(inner: NonNull<sys::nix_value>, state: Rc<RefCell<NonNull<sys::EvalState>>>) -> Self {
|
||||
fn from(inner: NonNull<sys::NixValue>, state: Rc<RefCell<NonNull<sys::EvalState>>>) -> Self {
|
||||
let value = wrap::nix_fn!(|ctx: &ErrorContext| unsafe {
|
||||
sys::nix_get_float(ctx.as_ptr(), inner.as_ptr())
|
||||
})
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@ use crate::util::wrappers::AsInnerPtr;
|
|||
use crate::util::{panic_issue_call_failed, wrap};
|
||||
|
||||
pub struct NixFunction {
|
||||
inner: NonNull<sys::nix_value>,
|
||||
inner: NonNull<sys::NixValue>,
|
||||
state: Rc<RefCell<NonNull<sys::EvalState>>>,
|
||||
}
|
||||
|
||||
|
|
@ -52,19 +52,19 @@ impl Debug for NixFunction {
|
|||
}
|
||||
}
|
||||
|
||||
impl AsInnerPtr<sys::nix_value> for NixFunction {
|
||||
impl AsInnerPtr<sys::NixValue> for NixFunction {
|
||||
#[inline]
|
||||
unsafe fn as_ptr(&self) -> *mut sys::nix_value {
|
||||
unsafe fn as_ptr(&self) -> *mut sys::NixValue {
|
||||
self.inner.as_ptr()
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn as_ref(&self) -> &sys::nix_value {
|
||||
unsafe fn as_ref(&self) -> &sys::NixValue {
|
||||
unsafe { self.inner.as_ref() }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn as_mut(&mut self) -> &mut sys::nix_value {
|
||||
unsafe fn as_mut(&mut self) -> &mut sys::NixValue {
|
||||
unsafe { self.inner.as_mut() }
|
||||
}
|
||||
}
|
||||
|
|
@ -72,10 +72,10 @@ impl AsInnerPtr<sys::nix_value> for NixFunction {
|
|||
impl NixValue for NixFunction {
|
||||
#[inline]
|
||||
fn type_id(&self) -> sys::ValueType {
|
||||
sys::ValueType_NIX_TYPE_FUNCTION
|
||||
sys::ValueType::Function
|
||||
}
|
||||
|
||||
fn from(inner: NonNull<sys::nix_value>, state: Rc<RefCell<NonNull<sys::EvalState>>>) -> Self {
|
||||
fn from(inner: NonNull<sys::NixValue>, state: Rc<RefCell<NonNull<sys::EvalState>>>) -> Self {
|
||||
Self { inner, state }
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -10,7 +10,7 @@ use crate::util::wrappers::AsInnerPtr;
|
|||
use crate::util::{panic_issue_call_failed, wrap};
|
||||
|
||||
pub struct NixInt {
|
||||
inner: NonNull<sys::nix_value>,
|
||||
inner: NonNull<sys::NixValue>,
|
||||
state: Rc<RefCell<NonNull<sys::EvalState>>>,
|
||||
value: i64,
|
||||
}
|
||||
|
|
@ -53,19 +53,19 @@ impl Debug for NixInt {
|
|||
}
|
||||
}
|
||||
|
||||
impl AsInnerPtr<sys::nix_value> for NixInt {
|
||||
impl AsInnerPtr<sys::NixValue> for NixInt {
|
||||
#[inline]
|
||||
unsafe fn as_ptr(&self) -> *mut sys::nix_value {
|
||||
unsafe fn as_ptr(&self) -> *mut sys::NixValue {
|
||||
self.inner.as_ptr()
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn as_ref(&self) -> &sys::nix_value {
|
||||
unsafe fn as_ref(&self) -> &sys::NixValue {
|
||||
unsafe { self.inner.as_ref() }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn as_mut(&mut self) -> &mut sys::nix_value {
|
||||
unsafe fn as_mut(&mut self) -> &mut sys::NixValue {
|
||||
unsafe { self.inner.as_mut() }
|
||||
}
|
||||
}
|
||||
|
|
@ -73,10 +73,10 @@ impl AsInnerPtr<sys::nix_value> for NixInt {
|
|||
impl NixValue for NixInt {
|
||||
#[inline]
|
||||
fn type_id(&self) -> sys::ValueType {
|
||||
sys::ValueType_NIX_TYPE_INT
|
||||
sys::ValueType::Int
|
||||
}
|
||||
|
||||
fn from(inner: NonNull<sys::nix_value>, state: Rc<RefCell<NonNull<sys::EvalState>>>) -> Self {
|
||||
fn from(inner: NonNull<sys::NixValue>, state: Rc<RefCell<NonNull<sys::EvalState>>>) -> Self {
|
||||
let value = wrap::nix_fn!(|ctx: &ErrorContext| unsafe {
|
||||
sys::nix_get_int(ctx.as_ptr(), inner.as_ptr())
|
||||
})
|
||||
|
|
|
|||
|
|
@ -10,7 +10,7 @@ use crate::util::wrappers::AsInnerPtr;
|
|||
use crate::util::{panic_issue_call_failed, wrap};
|
||||
|
||||
pub struct NixList {
|
||||
inner: NonNull<sys::nix_value>,
|
||||
inner: NonNull<sys::NixValue>,
|
||||
state: Rc<RefCell<NonNull<sys::EvalState>>>,
|
||||
}
|
||||
|
||||
|
|
@ -51,19 +51,19 @@ impl Debug for NixList {
|
|||
}
|
||||
}
|
||||
|
||||
impl AsInnerPtr<sys::nix_value> for NixList {
|
||||
impl AsInnerPtr<sys::NixValue> for NixList {
|
||||
#[inline]
|
||||
unsafe fn as_ptr(&self) -> *mut sys::nix_value {
|
||||
unsafe fn as_ptr(&self) -> *mut sys::NixValue {
|
||||
self.inner.as_ptr()
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn as_ref(&self) -> &sys::nix_value {
|
||||
unsafe fn as_ref(&self) -> &sys::NixValue {
|
||||
unsafe { self.inner.as_ref() }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn as_mut(&mut self) -> &mut sys::nix_value {
|
||||
unsafe fn as_mut(&mut self) -> &mut sys::NixValue {
|
||||
unsafe { self.inner.as_mut() }
|
||||
}
|
||||
}
|
||||
|
|
@ -71,10 +71,10 @@ impl AsInnerPtr<sys::nix_value> for NixList {
|
|||
impl NixValue for NixList {
|
||||
#[inline]
|
||||
fn type_id(&self) -> sys::ValueType {
|
||||
sys::ValueType_NIX_TYPE_LIST
|
||||
sys::ValueType::List
|
||||
}
|
||||
|
||||
fn from(inner: NonNull<sys::nix_value>, state: Rc<RefCell<NonNull<sys::EvalState>>>) -> Self {
|
||||
fn from(inner: NonNull<sys::NixValue>, state: Rc<RefCell<NonNull<sys::EvalState>>>) -> Self {
|
||||
Self { inner, state }
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -30,21 +30,16 @@ use std::rc::Rc;
|
|||
|
||||
use crate::errors::ErrorContext;
|
||||
use crate::sys;
|
||||
use crate::sys::{
|
||||
ValueType_NIX_TYPE_ATTRS, ValueType_NIX_TYPE_BOOL, ValueType_NIX_TYPE_EXTERNAL,
|
||||
ValueType_NIX_TYPE_FLOAT, ValueType_NIX_TYPE_FUNCTION, ValueType_NIX_TYPE_INT,
|
||||
ValueType_NIX_TYPE_LIST, ValueType_NIX_TYPE_NULL, ValueType_NIX_TYPE_PATH,
|
||||
ValueType_NIX_TYPE_STRING, ValueType_NIX_TYPE_THUNK,
|
||||
};
|
||||
use crate::sys::ValueType;
|
||||
use crate::util::wrappers::AsInnerPtr;
|
||||
use crate::util::{panic_issue_call_failed, wrap};
|
||||
|
||||
pub trait NixValue: Clone + Drop + Display + Debug + AsInnerPtr<sys::nix_value> {
|
||||
pub trait NixValue: Clone + Drop + Display + Debug + AsInnerPtr<sys::NixValue> {
|
||||
/// TODO
|
||||
fn type_id(&self) -> sys::ValueType;
|
||||
|
||||
/// TODO
|
||||
fn from(inner: NonNull<sys::nix_value>, state: Rc<RefCell<NonNull<sys::EvalState>>>) -> Self;
|
||||
fn from(inner: NonNull<sys::NixValue>, state: Rc<RefCell<NonNull<sys::EvalState>>>) -> Self;
|
||||
}
|
||||
|
||||
/// A Nix value
|
||||
|
|
@ -110,18 +105,8 @@ pub enum Value {
|
|||
// Failed(NixFailed),
|
||||
}
|
||||
|
||||
impl
|
||||
From<(
|
||||
NonNull<sys::nix_value>,
|
||||
Rc<RefCell<NonNull<sys::EvalState>>>,
|
||||
)> for Value
|
||||
{
|
||||
fn from(
|
||||
value: (
|
||||
NonNull<sys::nix_value>,
|
||||
Rc<RefCell<NonNull<sys::EvalState>>>,
|
||||
),
|
||||
) -> Self {
|
||||
impl From<(NonNull<sys::NixValue>, Rc<RefCell<NonNull<sys::EvalState>>>)> for Value {
|
||||
fn from(value: (NonNull<sys::NixValue>, Rc<RefCell<NonNull<sys::EvalState>>>)) -> Self {
|
||||
let (inner, state) = value;
|
||||
|
||||
wrap::nix_fn!(|ctx: &ErrorContext| unsafe {
|
||||
|
|
@ -136,22 +121,20 @@ impl
|
|||
|
||||
#[allow(non_upper_case_globals)]
|
||||
match type_id {
|
||||
ValueType_NIX_TYPE_THUNK => Value::Thunk(<NixThunk as NixValue>::from(inner, state)),
|
||||
ValueType_NIX_TYPE_INT => Value::Int(<NixInt as NixValue>::from(inner, state)),
|
||||
ValueType_NIX_TYPE_FLOAT => Value::Float(<NixFloat as NixValue>::from(inner, state)),
|
||||
ValueType_NIX_TYPE_BOOL => Value::Bool(<NixBool as NixValue>::from(inner, state)),
|
||||
ValueType_NIX_TYPE_STRING => Value::String(<NixString as NixValue>::from(inner, state)),
|
||||
ValueType_NIX_TYPE_PATH => Value::Path(<NixPath as NixValue>::from(inner, state)),
|
||||
ValueType_NIX_TYPE_NULL => Value::Null(<NixNull as NixValue>::from(inner, state)),
|
||||
ValueType_NIX_TYPE_ATTRS => Value::Attrs(<NixAttrs as NixValue>::from(inner, state)),
|
||||
ValueType_NIX_TYPE_LIST => Value::List(<NixList as NixValue>::from(inner, state)),
|
||||
ValueType_NIX_TYPE_FUNCTION => {
|
||||
Value::Function(<NixFunction as NixValue>::from(inner, state))
|
||||
},
|
||||
// ValueType_NIX_TYPE_EXTERNAL => {
|
||||
ValueType::Thunk => Value::Thunk(<NixThunk as NixValue>::from(inner, state)),
|
||||
ValueType::Int => Value::Int(<NixInt as NixValue>::from(inner, state)),
|
||||
ValueType::Float => Value::Float(<NixFloat as NixValue>::from(inner, state)),
|
||||
ValueType::Bool => Value::Bool(<NixBool as NixValue>::from(inner, state)),
|
||||
ValueType::String => Value::String(<NixString as NixValue>::from(inner, state)),
|
||||
ValueType::Path => Value::Path(<NixPath as NixValue>::from(inner, state)),
|
||||
ValueType::Null => Value::Null(<NixNull as NixValue>::from(inner, state)),
|
||||
ValueType::Attrs => Value::Attrs(<NixAttrs as NixValue>::from(inner, state)),
|
||||
ValueType::List => Value::List(<NixList as NixValue>::from(inner, state)),
|
||||
ValueType::Function => Value::Function(<NixFunction as NixValue>::from(inner, state)),
|
||||
// ValueType::External => {
|
||||
// Value::External(<NixExternal as NixValue>::from(inner, state))
|
||||
// },
|
||||
// ValueType_NIX_TYPE_FAILED => {
|
||||
// ValueType::Failed => {
|
||||
// Value::Failed(<NixFailed as NixValue>::from(inner, state))
|
||||
// },
|
||||
_ => unreachable!(),
|
||||
|
|
|
|||
|
|
@ -10,7 +10,7 @@ use crate::util::wrap;
|
|||
use crate::util::wrappers::AsInnerPtr;
|
||||
|
||||
pub struct NixNull {
|
||||
inner: NonNull<sys::nix_value>,
|
||||
inner: NonNull<sys::NixValue>,
|
||||
state: Rc<RefCell<NonNull<sys::EvalState>>>,
|
||||
}
|
||||
|
||||
|
|
@ -51,19 +51,19 @@ impl Debug for NixNull {
|
|||
}
|
||||
}
|
||||
|
||||
impl AsInnerPtr<sys::nix_value> for NixNull {
|
||||
impl AsInnerPtr<sys::NixValue> for NixNull {
|
||||
#[inline]
|
||||
unsafe fn as_ptr(&self) -> *mut sys::nix_value {
|
||||
unsafe fn as_ptr(&self) -> *mut sys::NixValue {
|
||||
self.inner.as_ptr()
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn as_ref(&self) -> &sys::nix_value {
|
||||
unsafe fn as_ref(&self) -> &sys::NixValue {
|
||||
unsafe { self.inner.as_ref() }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn as_mut(&mut self) -> &mut sys::nix_value {
|
||||
unsafe fn as_mut(&mut self) -> &mut sys::NixValue {
|
||||
unsafe { self.inner.as_mut() }
|
||||
}
|
||||
}
|
||||
|
|
@ -71,10 +71,10 @@ impl AsInnerPtr<sys::nix_value> for NixNull {
|
|||
impl NixValue for NixNull {
|
||||
#[inline]
|
||||
fn type_id(&self) -> sys::ValueType {
|
||||
sys::ValueType_NIX_TYPE_NULL
|
||||
sys::ValueType::Null
|
||||
}
|
||||
|
||||
fn from(inner: NonNull<sys::nix_value>, state: Rc<RefCell<NonNull<sys::EvalState>>>) -> Self {
|
||||
fn from(inner: NonNull<sys::NixValue>, state: Rc<RefCell<NonNull<sys::EvalState>>>) -> Self {
|
||||
Self { inner, state }
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -13,7 +13,7 @@ use crate::util::wrap;
|
|||
use crate::util::wrappers::AsInnerPtr;
|
||||
|
||||
pub struct NixPath {
|
||||
inner: NonNull<sys::nix_value>,
|
||||
inner: NonNull<sys::NixValue>,
|
||||
state: Rc<RefCell<NonNull<sys::EvalState>>>,
|
||||
value: PathBuf,
|
||||
}
|
||||
|
|
@ -56,19 +56,19 @@ impl Debug for NixPath {
|
|||
}
|
||||
}
|
||||
|
||||
impl AsInnerPtr<sys::nix_value> for NixPath {
|
||||
impl AsInnerPtr<sys::NixValue> for NixPath {
|
||||
#[inline]
|
||||
unsafe fn as_ptr(&self) -> *mut sys::nix_value {
|
||||
unsafe fn as_ptr(&self) -> *mut sys::NixValue {
|
||||
self.inner.as_ptr()
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn as_ref(&self) -> &sys::nix_value {
|
||||
unsafe fn as_ref(&self) -> &sys::NixValue {
|
||||
unsafe { self.inner.as_ref() }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn as_mut(&mut self) -> &mut sys::nix_value {
|
||||
unsafe fn as_mut(&mut self) -> &mut sys::NixValue {
|
||||
unsafe { self.inner.as_mut() }
|
||||
}
|
||||
}
|
||||
|
|
@ -76,10 +76,10 @@ impl AsInnerPtr<sys::nix_value> for NixPath {
|
|||
impl NixValue for NixPath {
|
||||
#[inline]
|
||||
fn type_id(&self) -> sys::ValueType {
|
||||
sys::ValueType_NIX_TYPE_PATH
|
||||
sys::ValueType::Path
|
||||
}
|
||||
|
||||
fn from(inner: NonNull<sys::nix_value>, state: Rc<RefCell<NonNull<sys::EvalState>>>) -> Self {
|
||||
fn from(inner: NonNull<sys::NixValue>, state: Rc<RefCell<NonNull<sys::EvalState>>>) -> Self {
|
||||
let value = wrap::nix_fn!(|ctx: &ErrorContext| unsafe {
|
||||
sys::nix_get_path_string(ctx.as_ptr(), inner.as_ptr())
|
||||
})
|
||||
|
|
|
|||
|
|
@ -12,7 +12,7 @@ use crate::util::wrap;
|
|||
use crate::util::wrappers::AsInnerPtr;
|
||||
|
||||
pub struct NixString {
|
||||
inner: NonNull<sys::nix_value>,
|
||||
inner: NonNull<sys::NixValue>,
|
||||
state: Rc<RefCell<NonNull<sys::EvalState>>>,
|
||||
value: String,
|
||||
}
|
||||
|
|
@ -55,19 +55,19 @@ impl Debug for NixString {
|
|||
}
|
||||
}
|
||||
|
||||
impl AsInnerPtr<sys::nix_value> for NixString {
|
||||
impl AsInnerPtr<sys::NixValue> for NixString {
|
||||
#[inline]
|
||||
unsafe fn as_ptr(&self) -> *mut sys::nix_value {
|
||||
unsafe fn as_ptr(&self) -> *mut sys::NixValue {
|
||||
self.inner.as_ptr()
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn as_ref(&self) -> &sys::nix_value {
|
||||
unsafe fn as_ref(&self) -> &sys::NixValue {
|
||||
unsafe { self.inner.as_ref() }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn as_mut(&mut self) -> &mut sys::nix_value {
|
||||
unsafe fn as_mut(&mut self) -> &mut sys::NixValue {
|
||||
unsafe { self.inner.as_mut() }
|
||||
}
|
||||
}
|
||||
|
|
@ -75,10 +75,10 @@ impl AsInnerPtr<sys::nix_value> for NixString {
|
|||
impl NixValue for NixString {
|
||||
#[inline]
|
||||
fn type_id(&self) -> sys::ValueType {
|
||||
sys::ValueType_NIX_TYPE_STRING
|
||||
sys::ValueType::String
|
||||
}
|
||||
|
||||
fn from(inner: NonNull<sys::nix_value>, state: Rc<RefCell<NonNull<sys::EvalState>>>) -> Self {
|
||||
fn from(inner: NonNull<sys::NixValue>, state: Rc<RefCell<NonNull<sys::EvalState>>>) -> Self {
|
||||
let value = wrap::nix_string_callback!(
|
||||
|callback, userdata: *mut __UserData, ctx: &ErrorContext| unsafe {
|
||||
sys::nix_get_string(
|
||||
|
|
|
|||
|
|
@ -10,7 +10,7 @@ use crate::util::wrappers::AsInnerPtr;
|
|||
use crate::util::{panic_issue_call_failed, wrap};
|
||||
|
||||
pub struct NixThunk {
|
||||
inner: NonNull<sys::nix_value>,
|
||||
inner: NonNull<sys::NixValue>,
|
||||
state: Rc<RefCell<NonNull<sys::EvalState>>>,
|
||||
}
|
||||
|
||||
|
|
@ -51,19 +51,19 @@ impl Debug for NixThunk {
|
|||
}
|
||||
}
|
||||
|
||||
impl AsInnerPtr<sys::nix_value> for NixThunk {
|
||||
impl AsInnerPtr<sys::NixValue> for NixThunk {
|
||||
#[inline]
|
||||
unsafe fn as_ptr(&self) -> *mut sys::nix_value {
|
||||
unsafe fn as_ptr(&self) -> *mut sys::NixValue {
|
||||
self.inner.as_ptr()
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn as_ref(&self) -> &sys::nix_value {
|
||||
unsafe fn as_ref(&self) -> &sys::NixValue {
|
||||
unsafe { self.inner.as_ref() }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn as_mut(&mut self) -> &mut sys::nix_value {
|
||||
unsafe fn as_mut(&mut self) -> &mut sys::NixValue {
|
||||
unsafe { self.inner.as_mut() }
|
||||
}
|
||||
}
|
||||
|
|
@ -71,10 +71,10 @@ impl AsInnerPtr<sys::nix_value> for NixThunk {
|
|||
impl NixValue for NixThunk {
|
||||
#[inline]
|
||||
fn type_id(&self) -> sys::ValueType {
|
||||
sys::ValueType_NIX_TYPE_THUNK
|
||||
sys::ValueType::Thunk
|
||||
}
|
||||
|
||||
fn from(inner: NonNull<sys::nix_value>, state: Rc<RefCell<NonNull<sys::EvalState>>>) -> Self {
|
||||
fn from(inner: NonNull<sys::NixValue>, state: Rc<RefCell<NonNull<sys::EvalState>>>) -> Self {
|
||||
Self { inner, state }
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@ use crate::util::wrap;
|
|||
use crate::util::wrappers::AsInnerPtr;
|
||||
|
||||
pub struct FetchersSettings {
|
||||
inner: NonNull<sys::nix_fetchers_settings>,
|
||||
inner: NonNull<sys::NixFetchersSettings>,
|
||||
}
|
||||
|
||||
impl FetchersSettings {
|
||||
|
|
@ -41,19 +41,19 @@ impl Drop for FetchersSettings {
|
|||
}
|
||||
}
|
||||
|
||||
impl AsInnerPtr<sys::nix_fetchers_settings> for FetchersSettings {
|
||||
impl AsInnerPtr<sys::NixFetchersSettings> for FetchersSettings {
|
||||
#[inline]
|
||||
unsafe fn as_ptr(&self) -> *mut sys::nix_fetchers_settings {
|
||||
unsafe fn as_ptr(&self) -> *mut sys::NixFetchersSettings {
|
||||
self.inner.as_ptr()
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn as_ref(&self) -> &sys::nix_fetchers_settings {
|
||||
unsafe fn as_ref(&self) -> &sys::NixFetchersSettings {
|
||||
unsafe { self.inner.as_ref() }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn as_mut(&mut self) -> &mut sys::nix_fetchers_settings {
|
||||
unsafe fn as_mut(&mut self) -> &mut sys::NixFetchersSettings {
|
||||
unsafe { self.inner.as_mut() }
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,4 +1,3 @@
|
|||
use std::ffi::c_void;
|
||||
use std::ptr::NonNull;
|
||||
|
||||
use super::{FlakeReference, FlakeSettings};
|
||||
|
|
@ -26,7 +25,7 @@ pub enum FlakeLockMode {
|
|||
|
||||
/// Parameters that affect the locking of a flake.
|
||||
pub struct FlakeLockFlags {
|
||||
pub(crate) inner: NonNull<sys::nix_flake_lock_flags>,
|
||||
pub(crate) inner: NonNull<sys::NixFlakeLockFlags>,
|
||||
}
|
||||
|
||||
// impl Clone for FlakeLockFlags {
|
||||
|
|
@ -50,19 +49,19 @@ impl Drop for FlakeLockFlags {
|
|||
}
|
||||
}
|
||||
|
||||
impl AsInnerPtr<sys::nix_flake_lock_flags> for FlakeLockFlags {
|
||||
impl AsInnerPtr<sys::NixFlakeLockFlags> for FlakeLockFlags {
|
||||
#[inline]
|
||||
unsafe fn as_ptr(&self) -> *mut sys::nix_flake_lock_flags {
|
||||
unsafe fn as_ptr(&self) -> *mut sys::NixFlakeLockFlags {
|
||||
self.inner.as_ptr()
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn as_ref(&self) -> &sys::nix_flake_lock_flags {
|
||||
unsafe fn as_ref(&self) -> &sys::NixFlakeLockFlags {
|
||||
unsafe { self.inner.as_ref() }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn as_mut(&mut self) -> &mut sys::nix_flake_lock_flags {
|
||||
unsafe fn as_mut(&mut self) -> &mut sys::NixFlakeLockFlags {
|
||||
unsafe { self.inner.as_mut() }
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@ use crate::util::wrappers::AsInnerPtr;
|
|||
|
||||
// XXX: TODO: rename FlakeReference -> FlakeRef
|
||||
pub struct FlakeReference {
|
||||
inner: NonNull<sys::nix_flake_reference>,
|
||||
inner: NonNull<sys::NixFlakeReference>,
|
||||
fragment: String,
|
||||
}
|
||||
|
||||
|
|
@ -37,19 +37,19 @@ impl Drop for FlakeReference {
|
|||
}
|
||||
}
|
||||
|
||||
impl AsInnerPtr<sys::nix_flake_reference> for FlakeReference {
|
||||
impl AsInnerPtr<sys::NixFlakeReference> for FlakeReference {
|
||||
#[inline]
|
||||
unsafe fn as_ptr(&self) -> *mut sys::nix_flake_reference {
|
||||
unsafe fn as_ptr(&self) -> *mut sys::NixFlakeReference {
|
||||
self.inner.as_ptr()
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn as_ref(&self) -> &sys::nix_flake_reference {
|
||||
unsafe fn as_ref(&self) -> &sys::NixFlakeReference {
|
||||
unsafe { self.inner.as_ref() }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn as_mut(&mut self) -> &mut sys::nix_flake_reference {
|
||||
unsafe fn as_mut(&mut self) -> &mut sys::NixFlakeReference {
|
||||
unsafe { self.inner.as_mut() }
|
||||
}
|
||||
}
|
||||
|
|
@ -65,7 +65,7 @@ impl FlakeReference {
|
|||
flags: &FlakeReferenceParseFlags,
|
||||
reference: &str,
|
||||
) -> Result<FlakeReference, NixideError> {
|
||||
let mut ptr: *mut sys::nix_flake_reference = null_mut();
|
||||
let mut ptr: *mut sys::NixFlakeReference = null_mut();
|
||||
let fragment = wrap::nix_string_callback!(
|
||||
|callback, userdata: *mut __UserData, ctx: &ErrorContext| unsafe {
|
||||
sys::nix_flake_reference_and_fragment_from_string(
|
||||
|
|
|
|||
|
|
@ -1,4 +1,3 @@
|
|||
use std::ffi::c_void;
|
||||
use std::os::raw::c_char;
|
||||
use std::ptr::NonNull;
|
||||
|
||||
|
|
@ -12,7 +11,7 @@ use crate::util::wrappers::AsInnerPtr;
|
|||
/// Parameters for parsing a flake reference.
|
||||
#[derive(Debug)]
|
||||
pub struct FlakeReferenceParseFlags {
|
||||
inner: NonNull<sys::nix_flake_reference_parse_flags>,
|
||||
inner: NonNull<sys::NixFlakeReferenceParseFlags>,
|
||||
}
|
||||
|
||||
// impl Clone for FlakeReferenceParseFlags {
|
||||
|
|
@ -36,19 +35,19 @@ impl Drop for FlakeReferenceParseFlags {
|
|||
}
|
||||
}
|
||||
|
||||
impl AsInnerPtr<sys::nix_flake_reference_parse_flags> for FlakeReferenceParseFlags {
|
||||
impl AsInnerPtr<sys::NixFlakeReferenceParseFlags> for FlakeReferenceParseFlags {
|
||||
#[inline]
|
||||
unsafe fn as_ptr(&self) -> *mut sys::nix_flake_reference_parse_flags {
|
||||
unsafe fn as_ptr(&self) -> *mut sys::NixFlakeReferenceParseFlags {
|
||||
self.inner.as_ptr()
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn as_ref(&self) -> &sys::nix_flake_reference_parse_flags {
|
||||
unsafe fn as_ref(&self) -> &sys::NixFlakeReferenceParseFlags {
|
||||
unsafe { self.inner.as_ref() }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn as_mut(&mut self) -> &mut sys::nix_flake_reference_parse_flags {
|
||||
unsafe fn as_mut(&mut self) -> &mut sys::NixFlakeReferenceParseFlags {
|
||||
unsafe { self.inner.as_mut() }
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@ use crate::util::wrappers::AsInnerPtr;
|
|||
|
||||
/// Store settings for the flakes feature.
|
||||
pub struct FlakeSettings {
|
||||
inner: NonNull<sys::nix_flake_settings>,
|
||||
inner: NonNull<sys::NixFlakeSettings>,
|
||||
}
|
||||
|
||||
impl Drop for FlakeSettings {
|
||||
|
|
@ -19,19 +19,19 @@ impl Drop for FlakeSettings {
|
|||
}
|
||||
}
|
||||
|
||||
impl AsInnerPtr<sys::nix_flake_settings> for FlakeSettings {
|
||||
impl AsInnerPtr<sys::NixFlakeSettings> for FlakeSettings {
|
||||
#[inline]
|
||||
unsafe fn as_ptr(&self) -> *mut sys::nix_flake_settings {
|
||||
unsafe fn as_ptr(&self) -> *mut sys::NixFlakeSettings {
|
||||
self.inner.as_ptr()
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn as_ref(&self) -> &sys::nix_flake_settings {
|
||||
unsafe fn as_ref(&self) -> &sys::NixFlakeSettings {
|
||||
unsafe { self.inner.as_ref() }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn as_mut(&mut self) -> &mut sys::nix_flake_settings {
|
||||
unsafe fn as_mut(&mut self) -> &mut sys::NixFlakeSettings {
|
||||
unsafe { self.inner.as_mut() }
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -10,7 +10,7 @@ use crate::util::wrappers::AsInnerPtr;
|
|||
use crate::{EvalState, NixideResult, Value};
|
||||
|
||||
pub struct LockedFlake {
|
||||
inner: NonNull<sys::nix_locked_flake>,
|
||||
inner: NonNull<sys::NixLockedFlake>,
|
||||
|
||||
flakeref: FlakeReference,
|
||||
state: EvalState,
|
||||
|
|
@ -45,19 +45,19 @@ impl Drop for LockedFlake {
|
|||
}
|
||||
}
|
||||
|
||||
impl AsInnerPtr<sys::nix_locked_flake> for LockedFlake {
|
||||
impl AsInnerPtr<sys::NixLockedFlake> for LockedFlake {
|
||||
#[inline]
|
||||
unsafe fn as_ptr(&self) -> *mut sys::nix_locked_flake {
|
||||
unsafe fn as_ptr(&self) -> *mut sys::NixLockedFlake {
|
||||
self.inner.as_ptr()
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn as_ref(&self) -> &sys::nix_locked_flake {
|
||||
unsafe fn as_ref(&self) -> &sys::NixLockedFlake {
|
||||
unsafe { self.inner.as_ref() }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn as_mut(&mut self) -> &mut sys::nix_locked_flake {
|
||||
unsafe fn as_mut(&mut self) -> &mut sys::NixLockedFlake {
|
||||
unsafe { self.inner.as_mut() }
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,13 +1,14 @@
|
|||
use crate::errors::ErrorContext;
|
||||
use crate::sys;
|
||||
use crate::util::wrappers::AsInnerPtr as _;
|
||||
use crate::util::{panic_issue, panic_issue_call_failed, wrap};
|
||||
use crate::util::{panic_issue_call_failed, wrap};
|
||||
|
||||
/// Verbosity level
|
||||
///
|
||||
/// # NOTE
|
||||
///
|
||||
/// This should be kept in sync with the C++ implementation (nix::Verbosity)
|
||||
///
|
||||
#[derive(Debug, Clone, Copy)]
|
||||
pub enum NixVerbosity {
|
||||
Error,
|
||||
|
|
@ -20,28 +21,24 @@ pub enum NixVerbosity {
|
|||
Vomit,
|
||||
}
|
||||
|
||||
impl From<sys::nix_verbosity> for NixVerbosity {
|
||||
fn from(level: sys::nix_verbosity) -> NixVerbosity {
|
||||
impl From<sys::NixVerbosity> for NixVerbosity {
|
||||
fn from(level: sys::NixVerbosity) -> NixVerbosity {
|
||||
match level {
|
||||
sys::nix_verbosity_NIX_LVL_ERROR => NixVerbosity::Error,
|
||||
sys::nix_verbosity_NIX_LVL_WARN => NixVerbosity::Warn,
|
||||
sys::nix_verbosity_NIX_LVL_NOTICE => NixVerbosity::Notice,
|
||||
sys::nix_verbosity_NIX_LVL_INFO => NixVerbosity::Info,
|
||||
sys::nix_verbosity_NIX_LVL_TALKATIVE => NixVerbosity::Talkative,
|
||||
sys::nix_verbosity_NIX_LVL_CHATTY => NixVerbosity::Chatty,
|
||||
sys::nix_verbosity_NIX_LVL_DEBUG => NixVerbosity::Debug,
|
||||
sys::nix_verbosity_NIX_LVL_VOMIT => NixVerbosity::Vomit,
|
||||
value => panic_issue!(
|
||||
"nixide encountered unknown `nix_verbosity` value ({})",
|
||||
value
|
||||
),
|
||||
sys::NixVerbosity::Error => NixVerbosity::Error,
|
||||
sys::NixVerbosity::Warn => NixVerbosity::Warn,
|
||||
sys::NixVerbosity::Notice => NixVerbosity::Notice,
|
||||
sys::NixVerbosity::Info => NixVerbosity::Info,
|
||||
sys::NixVerbosity::Talkative => NixVerbosity::Talkative,
|
||||
sys::NixVerbosity::Chatty => NixVerbosity::Chatty,
|
||||
sys::NixVerbosity::Debug => NixVerbosity::Debug,
|
||||
sys::NixVerbosity::Vomit => NixVerbosity::Vomit,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Into<sys::nix_verbosity> for NixVerbosity {
|
||||
fn into(self) -> sys::nix_verbosity {
|
||||
self as sys::nix_verbosity
|
||||
impl Into<sys::NixVerbosity> for NixVerbosity {
|
||||
fn into(self) -> sys::NixVerbosity {
|
||||
self as sys::NixVerbosity
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue