完善在main.rs中的测试

Author: Natural-selection1

src/main.rs

@@ -1,11 +1,3 @@
-#![allow(
-    unused,
-    clippy::filter_map_bool_then,
-    clippy::nonminimal_bool,
-    clippy::unnecessary_lazy_evaluations,
-    clippy::if_same_then_else,
-    clippy::useless_conversion
-)]
 use better_comprehension::{
     b_tree_map, b_tree_set, binary_heap, hash_map, hash_set, iterator_ref, linked_list, vec_deque,
     vector,
@@ -21,11 +13,22 @@ fn main() {
     test_vec_deque();
     test_hash_set();
     test_hash_map();
-    test_自建类型();
+    test_custom_type();
     test_ref_iterator();
+    test_pattern_matching();
+    test_nested_comprehension();
+    test_ownership_handling();
 }
 
 fn test_vec() {
+    // 简单示例
+    {
+        let vec_1 = vec!["AB".to_string(), "CD".to_string()];
+        let vec: Vec<String> = vector![x.clone() for x in vec_1];
+        assert_eq!(vec, vec!["AB".to_string(), "CD".to_string()]);
+    }
+
+    // 条件返回不同值
     {
         let result = vector![
             [x, y] if x > y else [y, x]
@@ -45,79 +48,198 @@ fn test_vec() {
                 [6, 6]
             ]
         );
-        println!("测试返回元组_2迭代器_有条件");
     }
+
+    // 多层循环和引用
     {
         let vec_comprehension1 = vec![("a", 1), ("b", 2), ("c", 3)];
         let vec_comprehension2 = vec![("a", 1), ("b", 2), ("c", 3)];
         let vec_comprehension3 = vec![("a", 1), ("b", 2), ("c", 3)];
         let _result = vector![
-            y if x > *z else y
+            y if x > z else y
             for z in &vec_comprehension3
-            for x in vec_comprehension1.clone()
-            for y in vec_comprehension2
+            for x in vec_comprehension1
+            for y in &vec_comprehension2
         ];
-
-        println!("{:#?}", vec_comprehension1);
-        // println!("{:#?}", vec_comprehension2);
-        println!("{:#?}", vec_comprehension3);
-        println!("{:#?}", _result);
     }
 }
 
 fn test_binary_heap() {
+    // 简单示例
     let vec = vec![1, 2, 3];
-    let result = binary_heap![x for x in vec];
+    let result = binary_heap![*x for x in vec];
     assert_eq!(result.into_sorted_vec(), vec![1, 2, 3]);
+
+    // 条件返回不同值
+    let binary_heap = binary_heap![
+        i if i-1 == 0 || j-2 == 0 else i+10
+        for i in 1..=3 if i != 2
+        for j in 1..=3 if j+i != 4];
+    assert_eq!(binary_heap.into_sorted_vec(), vec![1, 1, 3, 13]);
 }
 
 fn test_linked_list() {
+    // 简单示例
     let vec = vec![1, 2, 3];
-    let result = linked_list![x for x in vec];
+    let result = linked_list![*x for x in vec];
     assert_eq!(result, LinkedList::from([1, 2, 3]));
+
+    // 过滤值
+    let linked_list = linked_list![i*2 for i in 1..=3 if i != 2];
+    assert_eq!(linked_list, LinkedList::from([2, 6]));
 }
 
 fn test_b_tree_set() {
+    // 简单示例
     let vec = vec![1, 2, 3];
-    let result = b_tree_set![x for x in vec];
+    let result = b_tree_set![*x for x in vec];
     assert_eq!(result, BTreeSet::from([1, 2, 3]));
+
+    // 条件返回不同值
+    let b_tree_set = b_tree_set! {
+        i if i-1 == 0 else i+10
+        for i in 1..=3 if i != 2
+    };
+    assert_eq!(b_tree_set, BTreeSet::from([1, 13]));
 }
 
 fn test_b_tree_map() {
+    // 简单示例
     let vec_key = vec!["key_1", "key_2", "key_3"];
     let vec_value = [1, 2, 3];
 
-    let result = b_tree_map![x , y for y in vec_value for x in vec_key];
+    let result = b_tree_map![*x , *y for y in vec_value for x in vec_key];
     assert_eq!(
         result,
         BTreeMap::from([("key_1", 3), ("key_2", 3), ("key_3", 3)])
     );
+
+    // 键值对分隔符测试
+    let vec_key = [
+        "key_1".to_string(),
+        "key_2".to_string(),
+        "key_3".to_string(),
+    ];
+    let vec_value = [1, 2, 3];
+
+    // 使用冒号分隔
+    let b_tree_map1 = b_tree_map! {
+        key.clone() : *value
+        for key in vec_key.iter()
+        for value in vec_value
+    };
+
+    // 使用箭头分隔
+    let vec_key = [
+        "key_1".to_string(),
+        "key_2".to_string(),
+        "key_3".to_string(),
+    ];
+    let b_tree_map2 = b_tree_map! {
+        key.clone() => *value
+        for key in vec_key.iter()
+        for value in vec_value
+    };
+
+    // 使用逗号分隔
+    let vec_key = [
+        "key_1".to_string(),
+        "key_2".to_string(),
+        "key_3".to_string(),
+    ];
+    let b_tree_map3 = b_tree_map! {
+        key.clone() , *value
+        for key in vec_key.iter()
+        for value in vec_value
+    };
+
+    let expected = BTreeMap::from([
+        ("key_1".to_string(), 3),
+        ("key_2".to_string(), 3),
+        ("key_3".to_string(), 3),
+    ]);
+
+    assert_eq!(b_tree_map1, expected);
+    assert_eq!(b_tree_map2, expected);
+    assert_eq!(b_tree_map3, expected);
 }
 
 fn test_vec_deque() {
+    // 简单示例
     let vec = vec![1, 2, 3];
-    let result = vec_deque![x for x in vec];
+    let result = vec_deque![*x for x in vec];
     assert_eq!(result, VecDeque::from([1, 2, 3]));
+
+    // 模式匹配示例
+    #[derive(Debug, PartialEq, Eq)]
+    struct Person {
+        name: String,
+        age: i32,
+    }
+    let people = [
+        Person {
+            name: "Joe".to_string(),
+            age: 20,
+        },
+        Person {
+            name: "Bob".to_string(),
+            age: 25,
+        },
+    ];
+    let vec_deque = vec_deque![name.clone() for Person { name, .. } in people];
+    assert_eq!(
+        vec_deque,
+        VecDeque::from(["Joe".to_string(), "Bob".to_string()])
+    );
 }
 
 fn test_hash_set() {
+    // 简单示例
     let vec = vec![1, 2, 3];
-    let result = hash_set![x for x in vec];
+    let result = hash_set![*x for x in vec];
     assert_eq!(result, HashSet::from([1, 2, 3]));
+
+    // 过滤值
+    let hash_set = hash_set![i*2 for i in 1..=3 if i != 2];
+    assert_eq!(hash_set, HashSet::from([2, 6]));
 }
 
 fn test_hash_map() {
+    // 简单示例
     let vec_key = vec!["key_1", "key_2", "key_3"];
     let vec_value = [1, 2, 3];
 
-    let result = hash_map![x , y for y in vec_value for x in vec_key];
+    let result = hash_map![*x , *y for y in vec_value for x in vec_key];
     assert_eq!(
         result,
         HashMap::from([("key_1", 3), ("key_2", 3), ("key_3", 3)])
     );
+
+    // 键值对分隔符测试
+    let vec_key = vec![
+        "key_1".to_string(),
+        "key_2".to_string(),
+        "key_3".to_string(),
+    ];
+    let vec_value = [1, 2, 3];
+
+    let hash_map = hash_map! {
+        key.clone() : *value
+        for key in vec_key
+        for value in vec_value
+    };
+
+    assert_eq!(
+        hash_map,
+        HashMap::from([
+            ("key_1".to_string(), 3),
+            ("key_2".to_string(), 3),
+            ("key_3".to_string(), 3)
+        ])
+    );
 }
 
-fn test_自建类型() {
+fn test_custom_type() {
     #[derive(Debug, PartialEq, Eq)]
     struct MyType {
         x: i32,
@@ -127,31 +249,104 @@ fn test_自建类型() {
     let vec_y = vec![2, 4, 6];
     let vec_x = vec![1, 3, 5];
     let _result = vector![
-        MyType { x, y }
+        MyType { x: *x, y: *y }
         for y in vec_y
-        for x in vec_x if y == x + 1
+        for x in vec_x if *y == *x + 1
+    ];
+}
+
+fn test_pattern_matching() {
+    #[derive(Debug, PartialEq, Eq)]
+    struct Person {
+        name: String,
+        age: i32,
+    }
+
+    let people = [
+        Person {
+            name: "Joe".to_string(),
+            age: 20,
+        },
+        Person {
+            name: "Bob".to_string(),
+            age: 25,
+        },
+        Person {
+            name: "Alice".to_string(),
+            age: 30,
+        },
+    ];
+
+    // 使用模式匹配提取字段
+    let names = vector![name.clone() for Person { name, .. } in &people];
+    assert_eq!(
+        names,
+        vec!["Joe".to_string(), "Bob".to_string(), "Alice".to_string()]
+    );
+
+    // 使用模式匹配和条件过滤
+    let adult_names = vector![
+        name.clone()
+        for Person { name, age } in people
+        if *age >= 25
+    ];
+    assert_eq!(adult_names, vec!["Bob".to_string(), "Alice".to_string()]);
+}
+
+fn test_nested_comprehension() {
+    // 嵌套推导式示例
+    let vec = vector![
+        (top, bottom)
+        for top in 1..=3 if top != 2
+        for bottom in 4..=6 if bottom+top != 4
+    ];
+    assert_eq!(vec, vec![(1, 4), (1, 5), (1, 6), (3, 4), (3, 5), (3, 6)]);
+
+    // 多层条件嵌套
+    let vec = vector![
+        (i, j, k)
+        for i in 1..=2
+        for j in 3..=4 if i+j > 4
+        for k in 5..=6 if i+j+k > 10
+    ];
+    assert_eq!(vec, vec![(1, 4, 6), (2, 3, 6), (2, 4, 5), (2, 4, 6)]);
+}
+
+fn test_ownership_handling() {
+    // 测试所有权处理
+    let vec_1 = vec!["ABC".to_string(), "DEF".to_string()];
+    let vec_2 = ["abc".to_string(), "def".to_string()];
+    let vec_3 = vec![123, 456];
+
+    let vec = vector![
+        (i.clone(), j.clone(), *k)
+        for i in vec_1 if i == "ABC"
+        for j in vec_2.iter() if j == "abc"
+        for k in vec_3 if k == &123
     ];
-    println!("{:#?}", _result);
+
+    assert_eq!(vec, vec![("ABC".to_string(), "abc".to_string(), 123)]);
 }
 
 fn test_ref_iterator() {
     let vec_1 = ["123".to_string(), "456".to_string(), "789".to_string()];
     let vec_2 = ["ABC".to_string(), "DEF".to_string(), "GHI".to_string()];
 
-    // let result = iterator_ref![x for x in vec_1 if x.contains("1") for i in 1..=9]; // 范围最外层
-
-    // let result2 = iterator_ref![x for i in 1..=9 for x in vec_1 if x.contains("123")]; // 范围最内层
+    // 基于引用的迭代器推导式
+    let mut result3 = iterator_ref![
+        (x.clone(), y.clone()) if x.contains("1") else (y.clone(), x.clone())
+        for x in vec_1 if x.contains("1") || x.contains("7")
+        for _ in 1..=2
+        for y in vec_2 if y.contains("D") || x.contains("3")
+    ];
 
-    let result3 = iterator_ref![
-    (x, y)
-    for x in vec_1 if x.contains("1") || x.contains("7")
-    for i in 1..=9
-    for y in vec_2 if y.contains("A") || y.contains("D") || x.contains("3")];
+    // 验证迭代器已耗尽
+    for _ in 0..=9 {
+        result3.next();
+    }
+    assert_eq!(result3.next(), None);
 
-    // println!("{:#?}", result2);
-    // for (x, y) in result3 {
-    //     println!("{:#?}", x);
-    //     println!("{:#?}", y);
-    //     println!("--------------------------------");
-    // }
+    // 验证原始集合未被消耗
+    assert_eq!(vec_1.len(), 3);
+    assert_eq!(vec_2.len(), 3);
 }