test: use sorted comparison in grid iteration tests, drop unguaranteed order assumptions

Co-authored-by: samueltardieu <44656+samueltardieu@users.noreply.github.com>

Author: Copilot

tests/grid.rs

@@ -615,53 +615,33 @@ fn equality() {
     assert_eq!(g, g2);
 }
 
-/// Test that `iter()` and `into_iter()` produce the same elements in the same order
-/// for both dense and sparse grids.
-#[test]
-fn iter_and_into_iter_same_order() {
-    // Sparse grid (few vertices)
-    let mut g = Grid::new(4, 4);
-    g.add_vertex((0, 0));
-    g.add_vertex((2, 1));
-    g.add_vertex((1, 3));
-    let via_iter: Vec<_> = g.iter().collect();
-    let via_into_iter: Vec<_> = g.into_iter().collect();
-    assert_eq!(via_iter, via_into_iter);
-
-    // Dense grid (many vertices, few exclusions)
-    let mut g = Grid::new(4, 4);
-    g.fill();
-    g.remove_vertex((0, 0));
-    g.remove_vertex((2, 1));
-    g.remove_vertex((1, 3));
-    let via_iter: Vec<_> = g.iter().collect();
-    let via_into_iter: Vec<_> = g.into_iter().collect();
-    assert_eq!(via_iter, via_into_iter);
-}
-
-/// Test that iterating a sparse grid yields exactly the added vertices in
-/// insertion order.
+/// Test that `iter()` and `into_iter()` on a sparse grid yield exactly the
+/// added vertices (regardless of order).
 #[test]
 fn iter_sparse_grid_yields_exact_vertices() {
     let mut g = Grid::new(5, 5);
     g.add_vertex((3, 1));
     g.add_vertex((0, 4));
     g.add_vertex((2, 2));
-    let expected = vec![(3, 1), (0, 4), (2, 2)];
-    assert_eq!(g.iter().collect::<Vec<_>>(), expected);
-    assert_eq!(g.into_iter().collect::<Vec<_>>(), expected);
+    let mut expected = vec![(3, 1), (0, 4), (2, 2)];
+    expected.sort_unstable();
+    let mut via_iter = g.iter().collect::<Vec<_>>();
+    via_iter.sort_unstable();
+    assert_eq!(via_iter, expected);
+    let mut via_into_iter = g.into_iter().collect::<Vec<_>>();
+    via_into_iter.sort_unstable();
+    assert_eq!(via_into_iter, expected);
 }
 
-/// Test that iterating a dense grid yields exactly the expected vertices in
-/// scan order (x-first within each row), excluding removed vertices.
+/// Test that `iter()` and `into_iter()` on a dense grid yield exactly the
+/// expected vertices (all positions minus removed ones, regardless of order).
 #[test]
 fn iter_dense_grid_yields_exact_vertices() {
     let mut g = Grid::new(3, 3);
     g.fill();
     g.remove_vertex((1, 0));
     g.remove_vertex((0, 2));
-    // Scan order: x varies fastest; (1,0) and (0,2) are absent.
-    let expected = vec![
+    let mut expected = vec![
         (0, 0),
         (2, 0),
         (0, 1),
@@ -670,17 +650,27 @@ fn iter_dense_grid_yields_exact_vertices() {
         (1, 2),
         (2, 2),
     ];
-    assert_eq!(g.iter().collect::<Vec<_>>(), expected);
-    assert_eq!(g.into_iter().collect::<Vec<_>>(), expected);
+    expected.sort_unstable();
+    let mut via_iter = g.iter().collect::<Vec<_>>();
+    via_iter.sort_unstable();
+    assert_eq!(via_iter, expected);
+    let mut via_into_iter = g.into_iter().collect::<Vec<_>>();
+    via_into_iter.sort_unstable();
+    assert_eq!(via_into_iter, expected);
 }
 
-/// Test that iterating a completely filled grid yields all vertices in
-/// scan order (x-first within each row).
+/// Test that `iter()` and `into_iter()` on a fully filled grid yield all
+/// vertices (regardless of order).
 #[test]
-fn iter_full_grid_yields_all_vertices_in_order() {
+fn iter_full_grid_yields_all_vertices() {
     let mut g = Grid::new(3, 2);
     g.fill();
-    let expected = vec![(0, 0), (1, 0), (2, 0), (0, 1), (1, 1), (2, 1)];
-    assert_eq!(g.iter().collect::<Vec<_>>(), expected);
-    assert_eq!(g.into_iter().collect::<Vec<_>>(), expected);
+    let mut expected = vec![(0, 0), (1, 0), (2, 0), (0, 1), (1, 1), (2, 1)];
+    expected.sort_unstable();
+    let mut via_iter = g.iter().collect::<Vec<_>>();
+    via_iter.sort_unstable();
+    assert_eq!(via_iter, expected);
+    let mut via_into_iter = g.into_iter().collect::<Vec<_>>();
+    via_into_iter.sort_unstable();
+    assert_eq!(via_into_iter, expected);
 }