fix/tests-fixed-for-no-std-execution

README.md

@@ -531,7 +531,7 @@ The conditions to implement these variants are identical to the original traits.
 
 Now we can achieve our simpler `Repo` type.
 
-```rust
+```rust ignore
 use orx_iterable::obj_safe::*;
 
 struct Repo {

tests/chained.rs

@@ -1,5 +1,5 @@
 mod common_testers;
-use common_testers::{obj_test_col, obj_test_it, test_col, test_it};
+use common_testers::{test_col, test_it};
 use orx_iterable::*;
 use std::collections::VecDeque;
 
@@ -46,8 +46,11 @@ fn chained_mut() {
 
 // obj
 
+#[cfg(feature = "std")]
 #[test]
 fn obj_chained() {
+    use common_testers::obj_test_it;
+
     let a = vec![1, 3, 4];
     let b = [8, 10];
     let c = VecDeque::from_iter([2, 7].into_iter());
@@ -57,8 +60,11 @@ fn obj_chained() {
     obj_test_it(vec![1, 3, 4, 8, 10, 2, 7], &a.chained(b.chained(&c)));
 }
 
+#[cfg(feature = "std")]
 #[test]
 fn obj_into_chained() {
+    use common_testers::obj_test_col;
+
     let a = vec![1, 3, 4];
     let b = [8, 10];
     obj_test_col(vec![1, 3, 4, 8, 10], &a.into_chained(b));
@@ -72,8 +78,11 @@ fn obj_into_chained() {
     );
 }
 
+#[cfg(feature = "std")]
 #[test]
 fn obj_chained_mut() {
+    use common_testers::obj_test_col;
+
     let mut a = vec![1, 3, 4];
     let mut b = [8, 10];
     obj_test_col(vec![1, 3, 4, 8, 10], &a.chained_mut(&mut b));

tests/collection.rs

@@ -1,6 +1,6 @@
 mod common_testers;
 mod custom_iterables;
-use common_testers::{obj_test_col, test_col};
+use common_testers::test_col;
 use std::collections::{LinkedList, VecDeque};
 
 #[test]
@@ -31,8 +31,11 @@ fn custom_collection() {
 
 // obj
 
+#[cfg(feature = "std")]
 #[test]
 fn obj_std_collections() {
+    use common_testers::obj_test_col;
+
     let values = || vec![1, 3, 7];
 
     obj_test_col(values(), &[1, 3, 7]);
@@ -41,8 +44,11 @@ fn obj_std_collections() {
     obj_test_col(values(), &LinkedList::from_iter([1, 3, 7].into_iter()));
 }
 
+#[cfg(feature = "std")]
 #[test]
 fn obj_custom_collection() {
+    use common_testers::obj_test_col;
+
     let col = custom_iterables::EvensThenOddsCol {
         evens: vec![4, 12, 8, 2],
         odds: vec![1, 7],

tests/common_testers.rs

@@ -1,6 +1,5 @@
 #![allow(dead_code)]
 
-use orx_iterable::obj_safe::*;
 use orx_iterable::*;
 
 pub fn test_it<'a>(values: Vec<usize>, col: impl Iterable<Item = &'a usize>) {
@@ -32,7 +31,11 @@ pub fn test_col(values: Vec<usize>, col: impl Collection<Item = usize>) {
 
 // obj
 
-pub fn obj_test_it<'a>(values: Vec<usize>, col: &dyn IterableObj<Item = &'a usize>) {
+#[cfg(feature = "std")]
+pub fn obj_test_it<'a>(
+    values: Vec<usize>,
+    col: &dyn orx_iterable::obj_safe::IterableObj<Item = &'a usize>,
+) {
     let sum = values.iter().sum::<usize>();
     let count = values.len();
 
@@ -41,7 +44,11 @@ pub fn obj_test_it<'a>(values: Vec<usize>, col: &dyn IterableObj<Item = &'a usiz
     assert_eq!(col.boxed_iter().copied().sum::<usize>(), sum);
 }
 
-pub fn obj_test_it_val(values: Vec<usize>, col: &dyn IterableObj<Item = usize>) {
+#[cfg(feature = "std")]
+pub fn obj_test_it_val(
+    values: Vec<usize>,
+    col: &dyn orx_iterable::obj_safe::IterableObj<Item = usize>,
+) {
     let sum = values.iter().sum::<usize>();
     let count = values.len();
 
@@ -50,7 +57,11 @@ pub fn obj_test_it_val(values: Vec<usize>, col: &dyn IterableObj<Item = usize>)
     assert_eq!(col.boxed_iter().sum::<usize>(), sum);
 }
 
-pub fn obj_test_col(values: Vec<usize>, col: &dyn CollectionObj<Item = usize>) {
+#[cfg(feature = "std")]
+pub fn obj_test_col(
+    values: Vec<usize>,
+    col: &dyn orx_iterable::obj_safe::CollectionObj<Item = usize>,
+) {
     let sum = values.iter().sum::<usize>();
     let count = values.len();
 

tests/copied_cloned.rs

@@ -1,5 +1,4 @@
 mod custom_iterables;
-use orx_iterable::obj_safe::*;
 use orx_iterable::*;
 use std::collections::{LinkedList, VecDeque};
 
@@ -47,9 +46,10 @@ fn copied_cloned() {
     test(vec![4, 12, 8, 2, 1, 7], col.cloned());
 }
 
+#[cfg(feature = "std")]
 #[test]
 fn obj_copied_cloned() {
-    fn test(values: Vec<usize>, col: &dyn IterableObj<Item = usize>) {
+    fn test(values: Vec<usize>, col: &dyn orx_iterable::obj_safe::IterableObj<Item = usize>) {
         let sum = values.iter().sum::<usize>();
         let count = values.len();
 

tests/empty.rs

@@ -1,4 +1,3 @@
-use orx_iterable::obj_safe::*;
 use orx_iterable::*;
 
 #[test]
@@ -31,8 +30,11 @@ fn empty_col() {
 
 // obj
 
+#[cfg(feature = "std")]
 #[test]
 fn obj_empty() {
+    use orx_iterable::obj_safe::*;
+
     let it = orx_iterable::empty::<usize>();
 
     assert_eq!(it.boxed_iter().count(), 0);
@@ -44,8 +46,11 @@ fn obj_empty() {
     assert_eq!(it.boxed_iter().sum::<usize>(), 0);
 }
 
+#[cfg(feature = "std")]
 #[test]
 fn obj_empty_col() {
+    use orx_iterable::obj_safe::*;
+
     let mut it = orx_iterable::empty_col::<usize>();
 
     assert_eq!(it.boxed_iter().count(), 0);

tests/enumerated.rs

@@ -1,4 +1,3 @@
-use obj_safe::IterableObj;
 use orx_iterable::*;
 
 fn test_it<'a>(values: Vec<(usize, usize)>, col: impl Iterable<Item = (usize, &'a usize)>) {
@@ -21,24 +20,30 @@ fn enumerated() {
     );
 }
 
-// obj
+#[cfg(feature = "std")]
+mod object_safe {
+    use orx_iterable::{obj_safe::*, *};
 
-fn obj_test_it<'a>(values: Vec<(usize, usize)>, col: &dyn IterableObj<Item = (usize, &'a usize)>) {
-    let sum_values = values.iter().map(|x| x.1).sum::<usize>();
-    let sum_indices = values.iter().map(|x| x.0).sum::<usize>();
-    let count = values.len();
+    fn obj_test_it<'a>(
+        values: Vec<(usize, usize)>,
+        col: &dyn IterableObj<Item = (usize, &'a usize)>,
+    ) {
+        let sum_values = values.iter().map(|x| x.1).sum::<usize>();
+        let sum_indices = values.iter().map(|x| x.0).sum::<usize>();
+        let count = values.len();
 
-    // tests
-    assert_eq!(col.boxed_iter().count(), count);
-    assert_eq!(col.boxed_iter().map(|x| x.0).sum::<usize>(), sum_indices);
-    assert_eq!(col.boxed_iter().map(|x| x.1).sum::<usize>(), sum_values);
-}
+        // tests
+        assert_eq!(col.boxed_iter().count(), count);
+        assert_eq!(col.boxed_iter().map(|x| x.0).sum::<usize>(), sum_indices);
+        assert_eq!(col.boxed_iter().map(|x| x.1).sum::<usize>(), sum_values);
+    }
 
-#[test]
-fn obj_enumerated() {
-    let a = vec![1, 2, 3, 4];
-    obj_test_it(
-        a.clone().into_iter().enumerate().collect::<Vec<_>>(),
-        &a.enumerated(),
-    );
+    #[test]
+    fn obj_enumerated() {
+        let a = vec![1, 2, 3, 4];
+        obj_test_it(
+            a.clone().into_iter().enumerate().collect::<Vec<_>>(),
+            &a.enumerated(),
+        );
+    }
 }

tests/fields_of_generic_iterables.rs

@@ -1,3 +1,5 @@
+#![cfg(feature = "std")]
+
 use orx_iterable::*;
 use std::collections::{BTreeSet, LinkedList, VecDeque};
 

tests/fields_of_iterable_objects.rs

@@ -1,3 +1,5 @@
+#![cfg(feature = "std")]
+
 use orx_iterable::{obj_safe::*, IntoCloningIterable};
 use std::{
     collections::{BTreeSet, LinkedList, VecDeque},

tests/filter_mapped.rs

@@ -1,4 +1,3 @@
-use obj_safe::IterableObj;
 use orx_iterable::*;
 
 fn test_it(values: Vec<usize>, col: impl Iterable<Item = usize>) {
@@ -26,29 +25,32 @@ fn filter_mapped() {
     );
 }
 
-// obj
-
-fn obj_test_it(values: Vec<usize>, col: &dyn IterableObj<Item = usize>) {
-    let sum = values.iter().sum::<usize>();
-    let count = values.len();
-
-    // tests
-    assert_eq!(col.boxed_iter().count(), count);
-    assert_eq!(col.boxed_iter().sum::<usize>(), sum);
-}
-
-#[test]
-fn obj_filter_mapped() {
-    obj_test_it(
-        vec![1, 4, 7, 11],
-        &vec![1, 15, 4, 7, 33, 11].filter_mapped(|x| (*x < 12).then_some(*x)),
-    );
-
-    assert_eq!(
-        vec![4.to_string()],
-        [1, 4, 7, 11]
-            .filter_mapped(|x| (*x % 2 == 0).then_some(x.to_string()))
-            .iter()
-            .collect::<Vec<_>>(),
-    );
+#[cfg(feature = "std")]
+mod object_safe {
+    use orx_iterable::{obj_safe::*, *};
+
+    fn obj_test_it(values: Vec<usize>, col: &dyn IterableObj<Item = usize>) {
+        let sum = values.iter().sum::<usize>();
+        let count = values.len();
+
+        // tests
+        assert_eq!(col.boxed_iter().count(), count);
+        assert_eq!(col.boxed_iter().sum::<usize>(), sum);
+    }
+
+    #[test]
+    fn obj_filter_mapped() {
+        obj_test_it(
+            vec![1, 4, 7, 11],
+            &vec![1, 15, 4, 7, 33, 11].filter_mapped(|x| (*x < 12).then_some(*x)),
+        );
+
+        assert_eq!(
+            vec![4.to_string()],
+            [1, 4, 7, 11]
+                .filter_mapped(|x| (*x % 2 == 0).then_some(x.to_string()))
+                .iter()
+                .collect::<Vec<_>>(),
+        );
+    }
 }

tests/filtered.rs

@@ -1,6 +1,5 @@
 mod common_testers;
-use common_testers::{obj_test_col, obj_test_it, test_col, test_it};
-use orx_iterable::obj_safe::*;
+use common_testers::{test_col, test_it};
 use orx_iterable::*;
 
 #[test]
@@ -46,17 +45,23 @@ fn filtered_mut() {
 
 // obj
 
+#[cfg(feature = "std")]
 #[test]
 fn obj_filtered() {
+    use common_testers::obj_test_it;
+
     let a = vec![1, 3, 4, 8, 10];
 
     obj_test_it(vec![1, 3, 4, 8, 10], &a.filtered(|x| **x < 100));
     obj_test_it(vec![1, 3, 4], &a.filtered(|x| **x < 5));
     obj_test_it(vec![3, 4], &a.filtered(|x| **x < 5 && **x > 1));
 }
 
+#[cfg(feature = "std")]
 #[test]
 fn obj_into_filtered() {
+    use common_testers::obj_test_col;
+
     let a = vec![1, 3, 4, 8, 10];
     obj_test_col(vec![1, 3, 4, 8, 10], &a.into_filtered(|x| *x < 100));
 
@@ -67,8 +72,12 @@ fn obj_into_filtered() {
     obj_test_col(vec![3, 4], &a.into_filtered(|x| *x < 5 && *x > 1));
 }
 
+#[cfg(feature = "std")]
 #[test]
 fn obj_filtered_mut() {
+    use common_testers::{obj_test_col, obj_test_it};
+    use orx_iterable::obj_safe::*;
+
     let mut a = vec![1, 3, 4, 8, 10];
 
     obj_test_col(vec![1, 3, 4, 8, 10], &a.filtered_mut(|x| *x < 100));