make test conditional

Author: buraksenn

datafusion-cli/Cargo.lock

@@ -125,7 +125,7 @@ pub trait TreeNode: Sized {
     /// TreeNodeVisitor::f_up(ParentNode)
     /// ```
     #[cfg_attr(feature = "recursive-protection", recursive::recursive)]
-    fn visit<'n, V: TreeNodeVisitor<'n, Node = Self>>(
+    fn visit<'n, V: TreeNodeVisitor<'n, Node=Self>>(
         &'n self,
         visitor: &mut V,
     ) -> Result<TreeNodeRecursion> {
@@ -175,7 +175,7 @@ pub trait TreeNode: Sized {
     /// TreeNodeRewriter::f_up(ParentNode)
     /// ```
     #[cfg_attr(feature = "recursive-protection", recursive::recursive)]
-    fn rewrite<R: TreeNodeRewriter<Node = Self>>(
+    fn rewrite<R: TreeNodeRewriter<Node=Self>>(
         self,
         rewriter: &mut R,
     ) -> Result<Transformed<Self>> {
@@ -404,7 +404,7 @@ pub trait TreeNode: Sized {
                 TreeNodeRecursion::Continue
             })
         })
-        .map(|_| found)
+            .map(|_| found)
     }
 
     /// Low-level API used to implement other APIs.
@@ -884,7 +884,7 @@ impl<'a, T: 'a, C: TreeNodeContainer<'a, T>> TreeNodeContainer<'a, T> for Vec<C>
 }
 
 impl<'a, T: 'a, K: Eq + Hash, C: TreeNodeContainer<'a, T>> TreeNodeContainer<'a, T>
-    for HashMap<K, C>
+for HashMap<K, C>
 {
     fn apply_elements<F: FnMut(&'a T) -> Result<TreeNodeRecursion>>(
         &'a self,
@@ -924,7 +924,7 @@ impl<'a, T: 'a, K: Eq + Hash, C: TreeNodeContainer<'a, T>> TreeNodeContainer<'a,
 }
 
 impl<'a, T: 'a, C0: TreeNodeContainer<'a, T>, C1: TreeNodeContainer<'a, T>>
-    TreeNodeContainer<'a, T> for (C0, C1)
+TreeNodeContainer<'a, T> for (C0, C1)
 {
     fn apply_elements<F: FnMut(&'a T) -> Result<TreeNodeRecursion>>(
         &'a self,
@@ -950,12 +950,12 @@ impl<'a, T: 'a, C0: TreeNodeContainer<'a, T>, C1: TreeNodeContainer<'a, T>>
 }
 
 impl<
-        'a,
-        T: 'a,
-        C0: TreeNodeContainer<'a, T>,
-        C1: TreeNodeContainer<'a, T>,
-        C2: TreeNodeContainer<'a, T>,
-    > TreeNodeContainer<'a, T> for (C0, C1, C2)
+    'a,
+    T: 'a,
+    C0: TreeNodeContainer<'a, T>,
+    C1: TreeNodeContainer<'a, T>,
+    C2: TreeNodeContainer<'a, T>,
+> TreeNodeContainer<'a, T> for (C0, C1, C2)
 {
     fn apply_elements<F: FnMut(&'a T) -> Result<TreeNodeRecursion>>(
         &'a self,
@@ -1029,7 +1029,7 @@ impl<'a, T: 'a, C: TreeNodeContainer<'a, T>> TreeNodeRefContainer<'a, T> for Vec
 }
 
 impl<'a, T: 'a, C0: TreeNodeContainer<'a, T>, C1: TreeNodeContainer<'a, T>>
-    TreeNodeRefContainer<'a, T> for (&'a C0, &'a C1)
+TreeNodeRefContainer<'a, T> for (&'a C0, &'a C1)
 {
     fn apply_ref_elements<F: FnMut(&'a T) -> Result<TreeNodeRecursion>>(
         &self,
@@ -1042,12 +1042,12 @@ impl<'a, T: 'a, C0: TreeNodeContainer<'a, T>, C1: TreeNodeContainer<'a, T>>
 }
 
 impl<
-        'a,
-        T: 'a,
-        C0: TreeNodeContainer<'a, T>,
-        C1: TreeNodeContainer<'a, T>,
-        C2: TreeNodeContainer<'a, T>,
-    > TreeNodeRefContainer<'a, T> for (&'a C0, &'a C1, &'a C2)
+    'a,
+    T: 'a,
+    C0: TreeNodeContainer<'a, T>,
+    C1: TreeNodeContainer<'a, T>,
+    C2: TreeNodeContainer<'a, T>,
+> TreeNodeRefContainer<'a, T> for (&'a C0, &'a C1, &'a C2)
 {
     fn apply_ref_elements<F: FnMut(&'a T) -> Result<TreeNodeRecursion>>(
         &self,
@@ -1129,8 +1129,8 @@ impl<I: Iterator> TreeNodeIterator for I {
             }
             TreeNodeRecursion::Stop => Ok(item),
         })
-        .collect::<Result<Vec<_>>>()
-        .map(|data| Transformed::new(data, transformed, tnr))
+            .collect::<Result<Vec<_>>>()
+            .map(|data| Transformed::new(data, transformed, tnr))
     }
 }
 
@@ -1385,9 +1385,9 @@ pub(crate) mod tests {
             "f_up(i)",
             "f_up(j)",
         ]
-        .into_iter()
-        .map(|s| s.to_string())
-        .collect()
+            .into_iter()
+            .map(|s| s.to_string())
+            .collect()
     }
 
     // Expected transformed tree after a combined traversal
@@ -1458,9 +1458,9 @@ pub(crate) mod tests {
             "f_up(i)",
             "f_up(j)",
         ]
-        .into_iter()
-        .map(|s| s.to_string())
-        .collect()
+            .into_iter()
+            .map(|s| s.to_string())
+            .collect()
     }
 
     fn f_down_jump_on_a_transformed_down_tree() -> TestTreeNode<String> {
@@ -1492,9 +1492,9 @@ pub(crate) mod tests {
             "f_up(i)",
             "f_up(j)",
         ]
-        .into_iter()
-        .map(|s| s.to_string())
-        .collect()
+            .into_iter()
+            .map(|s| s.to_string())
+            .collect()
     }
 
     fn f_down_jump_on_e_transformed_tree() -> TestTreeNode<String> {
@@ -1545,9 +1545,9 @@ pub(crate) mod tests {
             "f_up(i)",
             "f_up(j)",
         ]
-        .into_iter()
-        .map(|s| s.to_string())
-        .collect()
+            .into_iter()
+            .map(|s| s.to_string())
+            .collect()
     }
 
     fn f_up_jump_on_a_transformed_tree() -> TestTreeNode<String> {
@@ -1601,9 +1601,9 @@ pub(crate) mod tests {
             "f_up(i)",
             "f_up(j)",
         ]
-        .into_iter()
-        .map(|s| s.to_string())
-        .collect()
+            .into_iter()
+            .map(|s| s.to_string())
+            .collect()
     }
 
     fn f_up_jump_on_e_transformed_tree() -> TestTreeNode<String> {
@@ -1628,9 +1628,9 @@ pub(crate) mod tests {
             "f_down(d)",
             "f_down(a)",
         ]
-        .into_iter()
-        .map(|s| s.to_string())
-        .collect()
+            .into_iter()
+            .map(|s| s.to_string())
+            .collect()
     }
 
     fn f_down_stop_on_a_transformed_tree() -> TestTreeNode<String> {
@@ -1707,9 +1707,9 @@ pub(crate) mod tests {
             "f_down(a)",
             "f_up(a)",
         ]
-        .into_iter()
-        .map(|s| s.to_string())
-        .collect()
+            .into_iter()
+            .map(|s| s.to_string())
+            .collect()
     }
 
     fn f_up_stop_on_a_transformed_tree() -> TestTreeNode<String> {
@@ -1755,9 +1755,9 @@ pub(crate) mod tests {
             "f_up(c)",
             "f_up(e)",
         ]
-        .into_iter()
-        .map(|s| s.to_string())
-        .collect()
+            .into_iter()
+            .map(|s| s.to_string())
+            .collect()
     }
 
     fn f_up_stop_on_e_transformed_tree() -> TestTreeNode<String> {
@@ -1876,7 +1876,7 @@ pub(crate) mod tests {
     }
 
     type TestRewriterF<T> =
-        Box<dyn FnMut(TestTreeNode<T>) -> Result<Transformed<TestTreeNode<T>>>>;
+    Box<dyn FnMut(TestTreeNode<T>) -> Result<Transformed<TestTreeNode<T>>>>;
 
     struct TestRewriter<T> {
         f_down: TestRewriterF<T>,
@@ -2349,6 +2349,7 @@ pub(crate) mod tests {
         Ok(())
     }
 
+    #[cfg(feature = "recursive-protection")]
     #[test]
     fn test_large_tree() {
         let mut item = TestTreeNode::new_leaf("initial".to_string());