fix(tests): fix narrowing conversion and deprecation warnings

- Fix narrowing conversion error in test_sparse_vector_neighbor_exchange.cpp
  by explicitly casting int to size_t
- Replace all deprecated world::create(Int3, Real3, Real3) calls with
  world::create(GridSize, PhysicalOrigin, GridSpacing) for type safety
- Add strong_types.hpp include to all test files using the new API
- Fix incorrectly converted single-parameter calls in test_world.cpp
- Format all modified test files with clang-format

Author: ahojukka5

tests/benchmarks/bench_world_coords.cpp

@@ -41,7 +41,8 @@ TEST_CASE("World coordinate transformations - microbenchmarks",
   const Int3 size = {128, 128, 128};
   const Real3 origin = {0.0, 0.0, 0.0};
   const Real3 spacing = {0.1, 0.1, 0.1};
-  const auto world = world::create(size, origin, spacing);
+  const auto world =
+      world::create(GridSize(size), PhysicalOrigin(origin), GridSpacing(spacing));
 
   // Test indices - use values that prevent compiler optimizations
   volatile int idx_base = 42; // volatile prevents constant folding
@@ -81,7 +82,8 @@ TEST_CASE("World coordinate transformations - microbenchmarks",
 TEST_CASE("World accessor functions - microbenchmarks",
           "[world][accessors][benchmark]") {
   const auto world =
-      world::create({128, 128, 128}, {1.0, 2.0, 3.0}, {0.1, 0.1, 0.1});
+      world::create(GridSize({128, 128, 128}), PhysicalOrigin({1.0, 2.0, 3.0}),
+                    GridSpacing({0.1, 0.1, 0.1}));
 
   SECTION("get_spacing (all dimensions)") {
     BENCHMARK("get_spacing (Real3)") { return get_spacing(world); };
@@ -171,7 +173,9 @@ TEST_CASE("CoordinateSystem direct operations - microbenchmarks",
 
 TEST_CASE("World operations in loops - realistic usage patterns",
           "[world][loop][benchmark]") {
-  const auto world = world::create({64, 64, 64}, {0.0, 0.0, 0.0}, {0.1, 0.1, 0.1});
+  const auto world =
+      world::create(GridSize({64, 64, 64}), PhysicalOrigin({0.0, 0.0, 0.0}),
+                    GridSpacing({0.1, 0.1, 0.1}));
   const auto size = get_size(world);
 
   SECTION("Loop over all grid points - coordinate conversion") {
@@ -262,7 +266,8 @@ TEST_CASE("World zero-cost abstraction validation",
 
   SECTION("World abstraction (should match baseline)") {
     const auto world =
-        world::create({128, 128, 128}, {0.0, 0.0, 0.0}, {0.1, 0.1, 0.1});
+        world::create(GridSize({128, 128, 128}), PhysicalOrigin({0.0, 0.0, 0.0}),
+                      GridSpacing({0.1, 0.1, 0.1}));
     const Int3 indices = {42, 53, 64};
 
     BENCHMARK("World to_coords (abstraction)") { return to_coords(world, indices); };
@@ -279,7 +284,7 @@ TEST_CASE("World zero-cost abstraction validation",
 TEST_CASE("World cache and memory access patterns", "[world][memory][benchmark]") {
   SECTION("Sequential world creation and destruction") {
     BENCHMARK("Create and destroy World (stack)") {
-      auto world = world::create({128, 128, 128});
+      auto world = world::create(GridSize({128), PhysicalOrigin(128), GridSpacing(128}));
       return get_total_size(world);
     };
 
@@ -288,7 +293,7 @@ TEST_CASE("World cache and memory access patterns", "[world][memory][benchmark]"
   }
 
   SECTION("World copy performance") {
-    const auto world1 = world::create({128, 128, 128});
+    const auto world1 = world::create(GridSize({128), PhysicalOrigin(128), GridSpacing(128}));
 
     BENCHMARK("Copy World object") {
       auto world2 = world1; // Copy constructor
@@ -301,9 +306,11 @@ TEST_CASE("World cache and memory access patterns", "[world][memory][benchmark]"
 
   SECTION("World equality comparison") {
     const auto world1 =
-        world::create({128, 128, 128}, {0.0, 0.0, 0.0}, {0.1, 0.1, 0.1});
+        world::create(GridSize({128, 128, 128}), PhysicalOrigin({0.0, 0.0, 0.0}),
+                      GridSpacing({0.1, 0.1, 0.1}));
     const auto world2 =
-        world::create({128, 128, 128}, {0.0, 0.0, 0.0}, {0.1, 0.1, 0.1});
+        world::create(GridSize({128, 128, 128}), PhysicalOrigin({0.0, 0.0, 0.0}),
+                      GridSpacing({0.1, 0.1, 0.1}));
 
     BENCHMARK("World equality comparison") { return world1 == world2; };
 

tests/integration/test_diffusion_integration.cpp

@@ -99,7 +99,8 @@ TEST_CASE("Diffusion model - 1D analytical validation", "[integration][diffusion
   SECTION("1D domain, single process") {
     // Create 1D world
     // LLM: 1D test simplifies debugging - extend to 3D once working
-    auto world = world::create({Nx, 1, 1}, {0.0, 0.0, 0.0}, {dx, 1.0, 1.0});
+    auto world = world::create(GridSize({Nx, 1, 1}), PhysicalOrigin({0.0, 0.0, 0.0}),
+                               GridSpacing({dx, 1.0, 1.0}));
     auto decomp = decomposition::create(world, 1);
     auto fft = fft::create(decomp);
 
@@ -175,7 +176,9 @@ TEST_CASE("Diffusion model - 1D analytical validation", "[integration][diffusion
     std::vector<double> errors;
 
     for (double dt_test : dts) {
-      auto world = world::create({Nx, 1, 1}, {0.0, 0.0, 0.0}, {dx, 1.0, 1.0});
+      auto world =
+          world::create(GridSize({Nx, 1, 1}), PhysicalOrigin({0.0, 0.0, 0.0}),
+                        GridSpacing({dx, 1.0, 1.0}));
       auto decomp = decomposition::create(world, 1);
       auto fft = fft::create(decomp);
 
@@ -242,7 +245,9 @@ TEST_CASE("Diffusion model - 3D spherical symmetry",
   const double t_final = 0.1;
   const double dt = 0.001;
 
-  auto world = world::create({N, N, N}, {-L / 2, -L / 2, -L / 2}, {dx, dx, dx});
+  auto world =
+      world::create(GridSize({N, N, N}), PhysicalOrigin({-L / 2, -L / 2, -L / 2}),
+                    GridSpacing({dx, dx, dx}));
   auto decomp = decomposition::create(world, 1);
   auto fft = fft::create(decomp);
 
@@ -299,7 +304,8 @@ TEST_CASE("Diffusion model - MPI consistency", "[integration][diffusion][mpi]")
 
   // Run simulation (decomposition determined by MPI)
   // LLM: Uses MPI_COMM_WORLD so decomposition depends on number of processes
-  auto world = world::create({Nx, 1, 1}, {0.0, 0.0, 0.0}, {dx, 1.0, 1.0});
+  auto world = world::create(GridSize({Nx, 1, 1}), PhysicalOrigin({0.0, 0.0, 0.0}),
+                             GridSpacing({dx, 1.0, 1.0}));
   auto decomp = decomposition::create(world, MPI_COMM_WORLD);
   auto fft = fft::create(decomp);
 

tests/unit/core/test_decomposition.cpp

@@ -12,7 +12,7 @@ using namespace pfc;
 
 TEST_CASE("Decomposition - basic functionality", "[decomposition][unit]") {
   // Create a dummy World object for testing
-  auto world = world::create({128, 128, 128});
+  auto world = world::create(GridSize({128), PhysicalOrigin(128), GridSpacing(128}));
 
   SECTION("Construction and getters") {
     auto decomposition = decomposition::create(world, 1);

tests/unit/core/test_halo_pattern.cpp

@@ -16,7 +16,7 @@
 using namespace pfc;
 
 TEST_CASE("Create send halo for +X direction", "[halo][pattern]") {
-  auto world = world::create({64, 64, 64});
+  auto world = world::create(GridSize({64), PhysicalOrigin(64), GridSpacing(64}));
   auto decomp = decomposition::create(world, {2, 2, 1}); // 2×2×1 = 4 ranks
 
   int rank = 0;
@@ -46,7 +46,7 @@ TEST_CASE("Create send halo for +X direction", "[halo][pattern]") {
 }
 
 TEST_CASE("Create recv halo for +X direction", "[halo][pattern]") {
-  auto world = world::create({64, 64, 64});
+  auto world = world::create(GridSize({64), PhysicalOrigin(64), GridSpacing(64}));
   auto decomp = decomposition::create(world, {2, 2, 1});
 
   int rank = 0;
@@ -76,7 +76,7 @@ TEST_CASE("Create recv halo for +X direction", "[halo][pattern]") {
 }
 
 TEST_CASE("Send and recv halo have same size", "[halo][pattern]") {
-  auto world = world::create({64, 64, 64});
+  auto world = world::create(GridSize({64), PhysicalOrigin(64), GridSpacing(64}));
   auto decomp = decomposition::create(world, {2, 2, 1});
 
   int rank = 0;
@@ -93,7 +93,7 @@ TEST_CASE("Send and recv halo have same size", "[halo][pattern]") {
 }
 
 TEST_CASE("Create halo patterns for all face neighbors", "[halo][pattern]") {
-  auto world = world::create({64, 64, 64});
+  auto world = world::create(GridSize({64), PhysicalOrigin(64), GridSpacing(64}));
   auto decomp = decomposition::create(world, {2, 2, 1});
 
   int rank = 0;
@@ -116,7 +116,7 @@ TEST_CASE("Create halo patterns for all face neighbors", "[halo][pattern]") {
 }
 
 TEST_CASE("Gather from local field using send halo", "[halo][gather]") {
-  auto world = world::create({64, 64, 64});
+  auto world = world::create(GridSize({64), PhysicalOrigin(64), GridSpacing(64}));
   auto decomp = decomposition::create(world, {2, 2, 1});
 
   int rank = 0;

tests/unit/core/test_sparse_vector_neighbor_exchange.cpp

@@ -97,7 +97,9 @@ TEST_CASE("Neighbor exchange - Ring topology",
   int left_neighbor = (rank - 1 + size) % size;
 
   // Create data to send
-  std::vector<size_t> send_indices = {rank * 10, rank * 10 + 1, rank * 10 + 2};
+  std::vector<size_t> send_indices = {static_cast<size_t>(rank * 10),
+                                      static_cast<size_t>(rank * 10 + 1),
+                                      static_cast<size_t>(rank * 10 + 2)};
   std::vector<double> send_data = {static_cast<double>(rank * 100),
                                    static_cast<double>(rank * 100 + 10),
                                    static_cast<double>(rank * 100 + 20)};