Put all #[test] in a mod tests (#2728)

workspace: put all `#[test]` in a `mod tests`

editor/src/messages/portfolio/document/graph_operation/transform_utils.rs

@@ -91,6 +91,9 @@ pub fn get_current_normalized_pivot(inputs: &[NodeInput]) -> DVec2 {
 	if let Some(&TaggedValue::DVec2(pivot)) = inputs[5].as_value() { pivot } else { DVec2::splat(0.5) }
 }
 
+#[cfg(test)]
+mod tests {
+	use super::*;
 	/// ![](https://files.keavon.com/-/OptimisticSpotlessTinamou/capture.png)
 	///
 	/// Source:
@@ -134,6 +137,7 @@ fn derive_transform() {
 			}
 		}
 	}
+}
 
 /// Expand a bounds to avoid div zero errors
 fn clamp_bounds(bounds_min: DVec2, mut bounds_max: DVec2) -> [DVec2; 2] {

editor/src/messages/portfolio/document/utility_types/document_metadata.rs

@@ -522,6 +522,9 @@ pub struct NodeRelations {
 // Helper functions
 // ================
 
+#[cfg(test)]
+mod tests {
+	use super::*;
 	#[test]
 	fn test_tree() {
 		let mut metadata = DocumentMetadata::default();
@@ -568,3 +571,4 @@ fn test_tree() {
 			vec![NodeId(10), NodeId(9), NodeId(5), NodeId(4), NodeId(3), NodeId(2)]
 		);
 	}
+}

editor/src/messages/tool/common_functionality/snapping/distribution_snapper.rs

@@ -382,6 +382,9 @@ impl DistributionSnapper {
 	}
 }
 
+#[cfg(test)]
+mod tests {
+	use super::*;
 	#[test]
 	fn merge_intersecting_test() {
 		let mut rectangles = vec![Rect::from_square(DVec2::ZERO, 2.), Rect::from_square(DVec2::new(10., 0.), 2.)];
@@ -696,3 +699,4 @@ fn dist_snap_point_center_xy() {
 		assert_boxes_in_order(&snap_results.points[0].distribution_boxes_horizontal, 0);
 		assert_boxes_in_order(&snap_results.points[0].distribution_boxes_vertical, 1);
 	}
+}

editor/src/messages/tool/common_functionality/transformation_cage.rs

@@ -800,6 +800,10 @@ impl BoundingBoxManager {
 	}
 }
 
+#[cfg(test)]
+mod tests {
+	use super::*;
+
 	#[test]
 	fn skew_transform_singular() {
 		for edge in [
@@ -856,3 +860,4 @@ fn skew_transform_correct() {
 			assert_eq!(constructed_transform, final_transform);
 		}
 	}
+}

libraries/bezier-rs/src/subpath/core.rs

@@ -570,6 +570,10 @@ pub fn solve_spline_first_handle_closed(points: &[DVec2]) -> Vec<DVec2> {
 	x
 }
 
+#[cfg(test)]
+mod tests {
+	use super::*;
+
 	#[test]
 	fn closed_spline() {
 		// These points are just chosen arbitrary
@@ -595,3 +599,4 @@ fn closed_spline() {
 			);
 		}
 	}
+}

node-graph/gcore/src/graphic_element/renderer/quad.rs

@@ -150,6 +150,10 @@ impl core::ops::Mul<Quad> for DAffine2 {
 		Quad(rhs.0.map(|point| self.transform_point2(point)))
 	}
 }
+
+#[cfg(test)]
+mod tests {
+	use super::*;
 	#[test]
 	fn offset_quad() {
 		fn eq(a: Quad, b: Quad) -> bool {
@@ -190,3 +194,4 @@ fn intersect_quad() {
 		assert!(Quad::from_box([DVec2::ZERO, DVec2::splat(5.)]).intersects(Quad::from_box([DVec2::splat(4.), DVec2::splat(4.2)])));
 		assert!(!Quad::from_box([DVec2::ZERO, DVec2::splat(3.)]).intersects(Quad::from_box([DVec2::splat(4.), DVec2::splat(4.2)])));
 	}
+}

node-graph/gcore/src/raster/color.rs

@@ -1058,6 +1058,9 @@ impl Color {
 	}
 }
 
+#[cfg(test)]
+mod tests {
+	use super::*;
 	#[test]
 	fn hsl_roundtrip() {
 		for (red, green, blue) in [
@@ -1092,3 +1095,4 @@ fn hsl_roundtrip() {
 			assert!((col.a() - result.a()) < f32::EPSILON * 100.);
 		}
 	}
+}

node-graph/gcore/src/text/to_path.rs

@@ -239,6 +239,9 @@ impl<'a> Iterator for SplitWordsIncludingSpaces<'a> {
 	}
 }
 
+#[cfg(test)]
+mod tests {
+	use super::*;
 	#[test]
 	fn split_words_including_spaces() {
 		let mut split_words = SplitWordsIncludingSpaces::new("hello  world     .");
@@ -247,3 +250,4 @@ fn split_words_including_spaces() {
 		assert_eq!(split_words.next(), Some("."));
 		assert_eq!(split_words.next(), None);
 	}
+}

node-graph/gcore/src/vector/algorithms/spline.rs

@@ -136,6 +136,9 @@ pub fn solve_spline_first_handle_closed(points: &[DVec2]) -> Vec<DVec2> {
 	x
 }
 
+#[cfg(test)]
+mod tests {
+	use super::*;
 	#[test]
 	fn closed_spline() {
 		use crate::vector::misc::{dvec2_to_point, point_to_dvec2};
@@ -176,3 +179,4 @@ fn closed_spline() {
 			);
 		}
 	}
+}

node-graph/gcore/src/vector/generator_nodes.rs

@@ -245,6 +245,9 @@ fn grid<T: GridSpacing>(
 	VectorDataTable::new(vector_data)
 }
 
+#[cfg(test)]
+mod tests {
+	use super::*;
 	#[test]
 	fn isometric_grid_test() {
 		// Doesn't crash with weird angles
@@ -277,3 +280,4 @@ fn skew_isometric_grid_test() {
 			assert!([90., 150., 40.].into_iter().any(|target| (target - angle).abs() < 1e-10), "unexpected angle of {}", angle)
 		}
 	}
+}

node-graph/gcore/src/vector/vector_data.rs

@@ -676,6 +676,9 @@ fn assert_subpath_eq(generated: &[bezier_rs::Subpath<PointId>], expected: &[bezi
 	}
 }
 
+#[cfg(test)]
+mod tests {
+	use super::*;
 	#[test]
 	fn construct_closed_subpath() {
 		let circle = bezier_rs::Subpath::new_ellipse(DVec2::NEG_ONE, DVec2::ONE);
@@ -718,3 +721,4 @@ fn construct_many_subpath() {
 		let generated = vector_data.stroke_bezier_paths().collect::<Vec<_>>();
 		assert_subpath_eq(&generated, &[curve, circle]);
 	}
+}

node-graph/gcore/src/vector/vector_data/modification.rs

@@ -436,64 +436,6 @@ async fn path_modify(_ctx: impl Ctx, mut vector_data: VectorDataTable, modificat
 	vector_data
 }
 
-#[test]
-fn modify_new() {
-	let vector_data = VectorData::from_subpaths(
-		[bezier_rs::Subpath::new_ellipse(DVec2::ZERO, DVec2::ONE), bezier_rs::Subpath::new_rect(DVec2::NEG_ONE, DVec2::ZERO)],
-		false,
-	);
-
-	let modify = VectorModification::create_from_vector(&vector_data);
-
-	let mut new = VectorData::default();
-	modify.apply(&mut new);
-	assert_eq!(vector_data, new);
-}
-
-#[test]
-fn modify_existing() {
-	use bezier_rs::{Bezier, Subpath};
-	let subpaths = [
-		Subpath::new_ellipse(DVec2::ZERO, DVec2::ONE),
-		Subpath::new_rect(DVec2::NEG_ONE, DVec2::ZERO),
-		Subpath::from_beziers(
-			&[
-				Bezier::from_quadratic_dvec2(DVec2::new(0., 0.), DVec2::new(5., 10.), DVec2::new(10., 0.)),
-				Bezier::from_quadratic_dvec2(DVec2::new(10., 0.), DVec2::new(15., 10.), DVec2::new(20., 0.)),
-			],
-			false,
-		),
-	];
-	let mut vector_data = VectorData::from_subpaths(subpaths, false);
-
-	let mut modify_new = VectorModification::create_from_vector(&vector_data);
-	let mut modify_original = VectorModification::default();
-
-	for modification in [&mut modify_new, &mut modify_original] {
-		let point = vector_data.point_domain.ids()[0];
-		modification.modify(&VectorModificationType::ApplyPointDelta { point, delta: DVec2::X * 0.5 });
-		let point = vector_data.point_domain.ids()[9];
-		modification.modify(&VectorModificationType::ApplyPointDelta { point, delta: DVec2::X });
-	}
-
-	let mut new = VectorData::default();
-	modify_new.apply(&mut new);
-
-	modify_original.apply(&mut vector_data);
-
-	assert_eq!(vector_data, new);
-	assert_eq!(vector_data.point_domain.positions()[0], DVec2::X);
-	assert_eq!(vector_data.point_domain.positions()[9], DVec2::new(11., 0.));
-	assert_eq!(
-		vector_data.segment_bezier_iter().nth(8).unwrap().1,
-		Bezier::from_quadratic_dvec2(DVec2::new(0., 0.), DVec2::new(5., 10.), DVec2::new(11., 0.))
-	);
-	assert_eq!(
-		vector_data.segment_bezier_iter().nth(9).unwrap().1,
-		Bezier::from_quadratic_dvec2(DVec2::new(11., 0.), DVec2::new(16., 10.), DVec2::new(20., 0.))
-	);
-}
-
 // Do we want to enforce that all serialized/deserialized hashmaps are a vec of tuples?
 // TODO: Eventually remove this document upgrade code
 use serde::de::{SeqAccess, Visitor};
@@ -686,3 +628,66 @@ impl<'a> AppendBezpath<'a> {
 		}
 	}
 }
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	#[test]
+	fn modify_new() {
+		let vector_data = VectorData::from_subpaths(
+			[bezier_rs::Subpath::new_ellipse(DVec2::ZERO, DVec2::ONE), bezier_rs::Subpath::new_rect(DVec2::NEG_ONE, DVec2::ZERO)],
+			false,
+		);
+
+		let modify = VectorModification::create_from_vector(&vector_data);
+
+		let mut new = VectorData::default();
+		modify.apply(&mut new);
+		assert_eq!(vector_data, new);
+	}
+
+	#[test]
+	fn modify_existing() {
+		use bezier_rs::{Bezier, Subpath};
+		let subpaths = [
+			Subpath::new_ellipse(DVec2::ZERO, DVec2::ONE),
+			Subpath::new_rect(DVec2::NEG_ONE, DVec2::ZERO),
+			Subpath::from_beziers(
+				&[
+					Bezier::from_quadratic_dvec2(DVec2::new(0., 0.), DVec2::new(5., 10.), DVec2::new(10., 0.)),
+					Bezier::from_quadratic_dvec2(DVec2::new(10., 0.), DVec2::new(15., 10.), DVec2::new(20., 0.)),
+				],
+				false,
+			),
+		];
+		let mut vector_data = VectorData::from_subpaths(subpaths, false);
+
+		let mut modify_new = VectorModification::create_from_vector(&vector_data);
+		let mut modify_original = VectorModification::default();
+
+		for modification in [&mut modify_new, &mut modify_original] {
+			let point = vector_data.point_domain.ids()[0];
+			modification.modify(&VectorModificationType::ApplyPointDelta { point, delta: DVec2::X * 0.5 });
+			let point = vector_data.point_domain.ids()[9];
+			modification.modify(&VectorModificationType::ApplyPointDelta { point, delta: DVec2::X });
+		}
+
+		let mut new = VectorData::default();
+		modify_new.apply(&mut new);
+
+		modify_original.apply(&mut vector_data);
+
+		assert_eq!(vector_data, new);
+		assert_eq!(vector_data.point_domain.positions()[0], DVec2::X);
+		assert_eq!(vector_data.point_domain.positions()[9], DVec2::new(11., 0.));
+		assert_eq!(
+			vector_data.segment_bezier_iter().nth(8).unwrap().1,
+			Bezier::from_quadratic_dvec2(DVec2::new(0., 0.), DVec2::new(5., 10.), DVec2::new(11., 0.))
+		);
+		assert_eq!(
+			vector_data.segment_bezier_iter().nth(9).unwrap().1,
+			Bezier::from_quadratic_dvec2(DVec2::new(11., 0.), DVec2::new(16., 10.), DVec2::new(20., 0.))
+		);
+	}
+}