fix: Inconsistent implementation of IntoIterator (#148)

Author: askyx

tpchgen/src/generators.rs

@@ -254,7 +254,7 @@ impl<'a> RegionGenerator<'a> {
     }
 }
 
-impl<'a> IntoIterator for &'a RegionGenerator<'a> {
+impl<'a> IntoIterator for RegionGenerator<'a> {
     type Item = Region<'a>;
     type IntoIter = RegionGeneratorIterator<'a>;
 
@@ -466,7 +466,7 @@ impl<'a> PartGenerator<'a> {
     }
 }
 
-impl<'a> IntoIterator for &'a PartGenerator<'a> {
+impl<'a> IntoIterator for PartGenerator<'a> {
     type Item = Part<'a>;
     type IntoIter = PartGeneratorIterator<'a>;
 
@@ -741,7 +741,7 @@ impl<'a> SupplierGenerator<'a> {
     }
 }
 
-impl<'a> IntoIterator for &'a SupplierGenerator<'a> {
+impl<'a> IntoIterator for SupplierGenerator<'a> {
     type Item = Supplier;
     type IntoIter = SupplierGeneratorIterator<'a>;
 
@@ -1043,7 +1043,7 @@ impl<'a> CustomerGenerator<'a> {
     }
 }
 
-impl<'a> IntoIterator for &'a CustomerGenerator<'a> {
+impl<'a> IntoIterator for CustomerGenerator<'a> {
     type Item = Customer<'a>;
     type IntoIter = CustomerGeneratorIterator<'a>;
 
@@ -1264,7 +1264,7 @@ impl<'a> PartSuppGenerator<'a> {
     }
 }
 
-impl<'a> IntoIterator for &'a PartSuppGenerator<'a> {
+impl<'a> IntoIterator for PartSuppGenerator<'a> {
     type Item = PartSupp<'a>;
     type IntoIter = PartSuppGeneratorIterator<'a>;
 
@@ -1585,7 +1585,7 @@ impl<'a> OrderGenerator<'a> {
     }
 }
 
-impl<'a> IntoIterator for &'a OrderGenerator<'a> {
+impl<'a> IntoIterator for OrderGenerator<'a> {
     type Item = Order<'a>;
     type IntoIter = OrderGeneratorIterator<'a>;
 
@@ -1986,7 +1986,7 @@ impl<'a> LineItemGenerator<'a> {
     }
 }
 
-impl<'a> IntoIterator for &'a LineItemGenerator<'a> {
+impl<'a> IntoIterator for LineItemGenerator<'a> {
     type Item = LineItem<'a>;
     type IntoIter = LineItemGeneratorIterator<'a>;
 

tpchgen/tests/integration_tests.rs

@@ -204,3 +204,163 @@ fn test_lineitem_sf_0_01() {
         item.to_string()
     })
 }
+
+struct TestIntoIterator<G>
+where
+    G: IntoIterator,
+    G::Item: std::fmt::Display,
+{
+    generator: Option<G>,
+}
+
+impl<G> TestIntoIterator<G>
+where
+    G: IntoIterator,
+    G::Item: std::fmt::Display,
+{
+    fn new(generator: G) -> Self {
+        Self {
+            generator: Some(generator),
+        }
+    }
+
+    pub fn to_string_vec(&mut self, take_num: i32) -> Vec<String> {
+        if let Some(generator) = self.generator.take() {
+            generator
+                .into_iter()
+                .take(take_num as usize)
+                .map(|item| item.to_string())
+                .collect()
+        } else {
+            vec![]
+        }
+    }
+}
+
+#[test]
+fn test_nation_into_iter() {
+    {
+        assert_eq!(
+            TestIntoIterator::new(NationGenerator::default())
+                .to_string_vec(5)
+                .len(),
+            5
+        );
+    }
+    {
+        let nation = NationGenerator::default();
+        assert_eq!(TestIntoIterator::new(nation).to_string_vec(5).len(), 5);
+    }
+}
+
+#[test]
+fn test_region_into_iter() {
+    {
+        assert_eq!(
+            TestIntoIterator::new(RegionGenerator::default())
+                .to_string_vec(5)
+                .len(),
+            5
+        );
+    }
+    {
+        let nation = RegionGenerator::default();
+        assert_eq!(TestIntoIterator::new(nation).to_string_vec(5).len(), 5);
+    }
+}
+
+#[test]
+fn test_part_into_iter() {
+    {
+        assert_eq!(
+            TestIntoIterator::new(PartGenerator::new(0.01, 1, 1))
+                .to_string_vec(5)
+                .len(),
+            5
+        );
+    }
+    {
+        let nation = PartGenerator::new(0.01, 1, 1);
+        assert_eq!(TestIntoIterator::new(nation).to_string_vec(5).len(), 5);
+    }
+}
+
+#[test]
+fn test_supplier_into_iter() {
+    {
+        assert_eq!(
+            TestIntoIterator::new(SupplierGenerator::new(0.01, 1, 1))
+                .to_string_vec(5)
+                .len(),
+            5
+        );
+    }
+    {
+        let nation = SupplierGenerator::new(0.01, 1, 1);
+        assert_eq!(TestIntoIterator::new(nation).to_string_vec(5).len(), 5);
+    }
+}
+
+#[test]
+fn test_partsupp_into_iter() {
+    {
+        assert_eq!(
+            TestIntoIterator::new(PartSuppGenerator::new(0.01, 1, 1))
+                .to_string_vec(5)
+                .len(),
+            5
+        );
+    }
+    {
+        let nation = PartSuppGenerator::new(0.01, 1, 1);
+        assert_eq!(TestIntoIterator::new(nation).to_string_vec(5).len(), 5);
+    }
+}
+
+#[test]
+fn test_customer_into_iter() {
+    {
+        assert_eq!(
+            TestIntoIterator::new(CustomerGenerator::new(0.01, 1, 1))
+                .to_string_vec(5)
+                .len(),
+            5
+        );
+    }
+    {
+        let nation = CustomerGenerator::new(0.01, 1, 1);
+        assert_eq!(TestIntoIterator::new(nation).to_string_vec(5).len(), 5);
+    }
+}
+
+#[test]
+fn test_orders_into_iter() {
+    {
+        assert_eq!(
+            TestIntoIterator::new(OrderGenerator::new(0.01, 1, 1))
+                .to_string_vec(5)
+                .len(),
+            5
+        );
+    }
+    {
+        let nation = OrderGenerator::new(0.01, 1, 1);
+        assert_eq!(TestIntoIterator::new(nation).to_string_vec(5).len(), 5);
+    }
+}
+
+#[test]
+fn test_lineitem_into_iter() {
+    {
+        assert_eq!(
+            TestIntoIterator::new(LineItemGenerator::new(0.01, 1, 1))
+                .to_string_vec(5)
+                .len(),
+            5
+        );
+    }
+    {
+        let nation = LineItemGenerator::new(0.01, 1, 1);
+        assert_eq!(TestIntoIterator::new(nation).to_string_vec(5).len(), 5);
+    }
+}