feat(tests): improve geometry tests with additional cases

Author: MichaelKreil

versatiles_geometry/src/geo/types/linestring.rs

@@ -297,4 +297,32 @@ mod tests {
 		}
 		assert_eq!(line.last().unwrap().x(), 9.0);
 	}
+
+	#[test]
+	fn test_contains_point_always_false() {
+		let line = LineStringGeometry::from(vec![(0.0, 0.0), (10.0, 10.0)]);
+		assert!(!line.contains_point(5.0, 5.0));
+		assert!(!line.contains_point(0.0, 0.0));
+	}
+
+	#[test]
+	fn test_to_mercator() {
+		let line = LineStringGeometry::from(vec![(13.4, 52.5), (13.5, 52.6)]);
+		let m = line.to_mercator();
+		assert_eq!(m.len(), 2);
+		assert!(m.as_vec()[0].x() > 0.0);
+		assert!(m.as_vec()[0].y() > 0.0);
+	}
+
+	#[test]
+	fn test_compute_bounds() {
+		let line = LineStringGeometry::from(vec![(1.0, 2.0), (5.0, 8.0), (3.0, 4.0)]);
+		let bounds = line.compute_bounds().unwrap();
+		assert_eq!(bounds, [1.0, 2.0, 5.0, 8.0]);
+	}
+
+	#[test]
+	fn test_compute_bounds_empty() {
+		assert!(LineStringGeometry::new().compute_bounds().is_none());
+	}
 }

versatiles_geometry/src/geo/types/multi_linestring.rs

@@ -96,3 +96,172 @@ impl Debug for MultiLineStringGeometry {
 }
 
 crate::impl_from_array!(MultiLineStringGeometry, LineStringGeometry);
+
+#[cfg(test)]
+#[allow(clippy::float_cmp)]
+mod tests {
+	use super::*;
+
+	fn sample() -> MultiLineStringGeometry {
+		MultiLineStringGeometry::from(vec![
+			vec![(0.0, 0.0), (1.0, 1.0)],
+			vec![(2.0, 3.0), (4.0, 5.0), (6.0, 7.0)],
+		])
+	}
+
+	// ── GeometryTrait ───────────────────────────────────────────────────
+
+	#[test]
+	fn area_is_zero() {
+		assert_eq!(sample().area(), 0.0);
+	}
+
+	#[test]
+	fn verify_valid() {
+		assert!(sample().verify().is_ok());
+	}
+
+	#[test]
+	fn verify_empty_ok() {
+		assert!(MultiLineStringGeometry::new().verify().is_ok());
+	}
+
+	#[test]
+	fn verify_invalid_inner() {
+		// A line with only 1 point is invalid
+		let mut ml = MultiLineStringGeometry::new();
+		ml.push(LineStringGeometry::from(vec![(0.0, 0.0)]));
+		assert!(ml.verify().is_err());
+	}
+
+	#[test]
+	fn to_coord_json() {
+		let json = sample().to_coord_json(None);
+		let arr = json.as_array().unwrap();
+		assert_eq!(arr.len(), 2);
+	}
+
+	#[test]
+	fn contains_point_always_false() {
+		assert!(!sample().contains_point(0.0, 0.0));
+		assert!(!sample().contains_point(5.0, 5.0));
+	}
+
+	#[test]
+	fn to_mercator() {
+		let ml = MultiLineStringGeometry::from(&[[(13.0, 52.0), (13.5, 52.5)]]);
+		let m = ml.to_mercator();
+		assert_eq!(m.as_vec().len(), 1);
+		assert!(m.as_vec()[0].as_vec()[0].x() > 0.0);
+	}
+
+	#[test]
+	fn compute_bounds() {
+		let bounds = sample().compute_bounds().unwrap();
+		assert_eq!(bounds, [0.0, 0.0, 6.0, 7.0]);
+	}
+
+	#[test]
+	fn compute_bounds_empty() {
+		assert!(MultiLineStringGeometry::new().compute_bounds().is_none());
+	}
+
+	// ── CompositeGeometryTrait ──────────────────────────────────────────
+
+	#[test]
+	fn composite_new_is_empty() {
+		let ml = MultiLineStringGeometry::new();
+		assert!(ml.is_empty());
+		assert_eq!(ml.len(), 0);
+	}
+
+	#[test]
+	fn composite_push_and_len() {
+		let mut ml = MultiLineStringGeometry::new();
+		ml.push(LineStringGeometry::from(vec![(0.0, 0.0), (1.0, 1.0)]));
+		assert_eq!(ml.len(), 1);
+		assert!(!ml.is_empty());
+	}
+
+	#[test]
+	fn composite_first_last() {
+		let ml = sample();
+		assert_eq!(ml.first().unwrap().as_vec()[0].x(), 0.0);
+		assert_eq!(ml.last().unwrap().as_vec()[0].x(), 2.0);
+	}
+
+	#[test]
+	fn composite_first_last_empty() {
+		let ml = MultiLineStringGeometry::new();
+		assert!(ml.first().is_none());
+		assert!(ml.last().is_none());
+	}
+
+	#[test]
+	fn composite_pop() {
+		let mut ml = sample();
+		let popped = ml.pop().unwrap();
+		assert_eq!(popped.len(), 3);
+		assert_eq!(ml.len(), 1);
+	}
+
+	#[test]
+	fn composite_into_inner() {
+		let inner = sample().into_inner();
+		assert_eq!(inner.len(), 2);
+	}
+
+	#[test]
+	fn composite_into_iter() {
+		let lines: Vec<_> = sample().into_iter().collect();
+		assert_eq!(lines.len(), 2);
+	}
+
+	#[test]
+	fn composite_into_first_and_rest() {
+		let (first, rest) = sample().into_first_and_rest().unwrap();
+		assert_eq!(first.len(), 2);
+		assert_eq!(rest.len(), 1);
+	}
+
+	#[test]
+	fn composite_into_first_and_rest_empty() {
+		assert!(MultiLineStringGeometry::new().into_first_and_rest().is_none());
+	}
+
+	// ── Debug / Clone / Eq ──────────────────────────────────────────────
+
+	#[test]
+	fn debug_format() {
+		let ml = MultiLineStringGeometry::from(&[[(1.0, 2.0), (3.0, 4.0)]]);
+		assert!(format!("{ml:?}").contains("[1.0, 2.0]"));
+	}
+
+	#[test]
+	fn clone_and_eq() {
+		let a = sample();
+		assert_eq!(a.clone(), a);
+	}
+
+	#[test]
+	fn ne() {
+		let a = MultiLineStringGeometry::from(&[[(0.0, 0.0), (1.0, 1.0)]]);
+		let b = MultiLineStringGeometry::from(&[[(2.0, 2.0), (3.0, 3.0)]]);
+		assert_ne!(a, b);
+	}
+
+	// ── From conversions ────────────────────────────────────────────────
+
+	#[test]
+	fn from_vec() {
+		let ml = MultiLineStringGeometry::from(vec![vec![(0.0, 0.0), (1.0, 1.0)], vec![(2.0, 2.0), (3.0, 3.0)]]);
+		assert_eq!(ml.len(), 2);
+	}
+
+	#[test]
+	fn from_slice() {
+		let data = [[(0.0, 0.0), (1.0, 1.0)], [(2.0, 2.0), (3.0, 3.0)]];
+		let ml = MultiLineStringGeometry::from(&data[..]);
+		assert_eq!(ml.len(), 2);
+	}
+}

versatiles_geometry/src/geo/types/multi_point.rs

@@ -95,3 +95,178 @@ impl Debug for MultiPointGeometry {
 }
 
 crate::impl_from_array!(MultiPointGeometry, PointGeometry);
+
+#[cfg(test)]
+#[allow(clippy::float_cmp)]
+mod tests {
+	use super::*;
+
+	fn sample() -> MultiPointGeometry {
+		MultiPointGeometry::from(&[[1, 2], [3, 4], [5, 6]])
+	}
+
+	// ── GeometryTrait ───────────────────────────────────────────────────
+
+	#[test]
+	fn area_is_zero() {
+		assert_eq!(sample().area(), 0.0);
+	}
+
+	#[test]
+	fn verify_ok() {
+		assert!(sample().verify().is_ok());
+	}
+
+	#[test]
+	fn verify_empty_ok() {
+		assert!(MultiPointGeometry::new().verify().is_ok());
+	}
+
+	#[test]
+	fn to_coord_json() {
+		let json = sample().to_coord_json(None);
+		let arr = json.as_array().unwrap();
+		assert_eq!(arr.len(), 3);
+	}
+
+	#[test]
+	fn to_coord_json_with_precision() {
+		let mp = MultiPointGeometry::from(vec![(1.23456, 2.34567)]);
+		let json = mp.to_coord_json(Some(2));
+		let arr = json.as_array().unwrap();
+		assert_eq!(arr.len(), 1);
+	}
+
+	#[test]
+	fn contains_point_always_false() {
+		assert!(!sample().contains_point(1.0, 2.0));
+		assert!(!sample().contains_point(0.0, 0.0));
+	}
+
+	#[test]
+	fn to_mercator() {
+		let mp = MultiPointGeometry::from(&[[13, 52], [-74, 40]]);
+		let m = mp.to_mercator();
+		assert_eq!(m.as_vec().len(), 2);
+		assert!(m.as_vec()[0].x() > 0.0); // Berlin-ish
+		assert!(m.as_vec()[1].x() < 0.0); // New York-ish
+	}
+
+	#[test]
+	fn compute_bounds() {
+		let bounds = sample().compute_bounds().unwrap();
+		assert_eq!(bounds, [1.0, 2.0, 5.0, 6.0]);
+	}
+
+	#[test]
+	fn compute_bounds_single_point() {
+		let mp = MultiPointGeometry::from(&[[7, 8]]);
+		let bounds = mp.compute_bounds().unwrap();
+		assert_eq!(bounds, [7.0, 8.0, 7.0, 8.0]);
+	}
+
+	#[test]
+	fn compute_bounds_empty() {
+		assert!(MultiPointGeometry::new().compute_bounds().is_none());
+	}
+
+	// ── CompositeGeometryTrait ──────────────────────────────────────────
+
+	#[test]
+	fn composite_new_is_empty() {
+		let mp = MultiPointGeometry::new();
+		assert!(mp.is_empty());
+		assert_eq!(mp.len(), 0);
+	}
+
+	#[test]
+	fn composite_push_and_len() {
+		let mut mp = MultiPointGeometry::new();
+		mp.push(PointGeometry::from(&[1, 2]));
+		mp.push(PointGeometry::from(&[3, 4]));
+		assert_eq!(mp.len(), 2);
+		assert!(!mp.is_empty());
+	}
+
+	#[test]
+	fn composite_first_last() {
+		let mp = sample();
+		assert_eq!(mp.first().unwrap().x(), 1.0);
+		assert_eq!(mp.last().unwrap().x(), 5.0);
+	}
+
+	#[test]
+	fn composite_first_last_empty() {
+		let mp = MultiPointGeometry::new();
+		assert!(mp.first().is_none());
+		assert!(mp.last().is_none());
+	}
+
+	#[test]
+	fn composite_pop() {
+		let mut mp = sample();
+		let popped = mp.pop().unwrap();
+		assert_eq!(popped.x(), 5.0);
+		assert_eq!(mp.len(), 2);
+	}
+
+	#[test]
+	fn composite_into_inner() {
+		let inner = sample().into_inner();
+		assert_eq!(inner.len(), 3);
+	}
+
+	#[test]
+	fn composite_into_iter() {
+		let points: Vec<_> = sample().into_iter().collect();
+		assert_eq!(points.len(), 3);
+	}
+
+	#[test]
+	fn composite_into_first_and_rest() {
+		let (first, rest) = sample().into_first_and_rest().unwrap();
+		assert_eq!(first.x(), 1.0);
+		assert_eq!(rest.len(), 2);
+	}
+
+	#[test]
+	fn composite_into_first_and_rest_empty() {
+		assert!(MultiPointGeometry::new().into_first_and_rest().is_none());
+	}
+
+	// ── Debug / Clone / Eq ──────────────────────────────────────────────
+
+	#[test]
+	fn debug_format() {
+		let mp = MultiPointGeometry::from(&[[1, 2]]);
+		assert!(format!("{mp:?}").contains("[1.0, 2.0]"));
+	}
+
+	#[test]
+	fn clone_and_eq() {
+		let a = sample();
+		assert_eq!(a.clone(), a);
+	}
+
+	#[test]
+	fn ne() {
+		let a = MultiPointGeometry::from(&[[1, 2]]);
+		let b = MultiPointGeometry::from(&[[3, 4]]);
+		assert_ne!(a, b);
+	}
+
+	// ── From conversions ────────────────────────────────────────────────
+
+	#[test]
+	fn from_vec() {
+		let mp = MultiPointGeometry::from(vec![(1.0, 2.0), (3.0, 4.0)]);
+		assert_eq!(mp.len(), 2);
+	}
+
+	#[test]
+	fn from_slice() {
+		let data = [(1.0, 2.0), (3.0, 4.0)];
+		let mp = MultiPointGeometry::from(&data[..]);
+		assert_eq!(mp.len(), 2);
+	}
+}