zarr-developers
diff --git a/‎src/zarr/core/group.py
Lines changed: 10 additions & 16 deletions b/‎src/zarr/core/group.py
Lines changed: 10 additions & 16 deletions
diff --git a/‎tests/v3/test_group.py
Lines changed: 13 additions & 3 deletions b/‎tests/v3/test_group.py
Lines changed: 13 additions & 3 deletions
@@ -706,46 +706,40 @@ async def tree(self, expand: bool = False, level: int | None = None) -> Any:
         raise NotImplementedError
 
     async def empty(self, *, name: str, shape: ChunkCoords, **kwargs: Any) -> AsyncArray:
-        path = str(self.store_path / name)
-        return await async_api.empty(shape=shape, path=path, **kwargs)
+        return await async_api.empty(shape=shape, store=self.store_path, path=name, **kwargs)
 
     async def zeros(self, *, name: str, shape: ChunkCoords, **kwargs: Any) -> AsyncArray:
-        path = str(self.store_path / name)
-        return await async_api.zeros(shape=shape, path=path, **kwargs)
+        return await async_api.zeros(shape=shape, store=self.store_path, path=name, **kwargs)
 
     async def ones(self, *, name: str, shape: ChunkCoords, **kwargs: Any) -> AsyncArray:
-        path = str(self.store_path / name)
-        return await async_api.ones(shape=shape, path=path, **kwargs)
+        return await async_api.ones(shape=shape, store=self.store_path, path=name, **kwargs)
 
     async def full(
         self, *, name: str, shape: ChunkCoords, fill_value: Any | None, **kwargs: Any
     ) -> AsyncArray:
-        path = str(self.store_path / name)
-        return await async_api.full(shape=shape, fill_value=fill_value, path=path, **kwargs)
+        return await async_api.full(
+            shape=shape, fill_value=fill_value, store=self.store_path, path=name, **kwargs
+        )
 
     async def empty_like(
         self, *, name: str, prototype: async_api.ArrayLike, **kwargs: Any
     ) -> AsyncArray:
-        path = str(self.store_path / name)
-        return await async_api.empty_like(a=prototype, path=path, **kwargs)
+        return await async_api.empty_like(a=prototype, store=self.store_path, path=name, **kwargs)
 
     async def zeros_like(
         self, *, name: str, prototype: async_api.ArrayLike, **kwargs: Any
     ) -> AsyncArray:
-        path = str(self.store_path / name)
-        return await async_api.zeros_like(a=prototype, path=path, **kwargs)
+        return await async_api.zeros_like(a=prototype, store=self.store_path, path=name, **kwargs)
 
     async def ones_like(
         self, *, name: str, prototype: async_api.ArrayLike, **kwargs: Any
     ) -> AsyncArray:
-        path = str(self.store_path / name)
-        return await async_api.ones_like(a=prototype, path=path, **kwargs)
+        return await async_api.ones_like(a=prototype, store=self.store_path, path=name, **kwargs)
 
     async def full_like(
         self, *, name: str, prototype: async_api.ArrayLike, **kwargs: Any
     ) -> AsyncArray:
-        path = str(self.store_path / name)
-        return await async_api.full_like(a=prototype, path=path, **kwargs)
+        return await async_api.full_like(a=prototype, store=self.store_path, path=name, **kwargs)
 
     async def move(self, source: str, dest: str) -> None:
         raise NotImplementedError
 
@@ -400,51 +400,61 @@ def test_group_array_creation(
     assert isinstance(empty_array, Array)
     assert empty_array.fill_value == 0
     assert empty_array.shape == shape
+    assert empty_array.store_path.store == store
 
     empty_like_array = group.empty_like(name="empty_like", prototype=empty_array)
     assert isinstance(empty_like_array, Array)
     assert empty_like_array.fill_value == 0
     assert empty_like_array.shape == shape
+    assert empty_like_array.store_path.store == store
 
     empty_array_bool = group.empty(name="empty_bool", shape=shape, dtype=np.dtype("bool"))
     assert isinstance(empty_array_bool, Array)
     assert not empty_array_bool.fill_value
-    assert empty_array.shape == shape
+    assert empty_array_bool.shape == shape
+    assert empty_array_bool.store_path.store == store
 
     empty_like_array_bool = group.empty_like(name="empty_like_bool", prototype=empty_array_bool)
     assert isinstance(empty_like_array_bool, Array)
     assert not empty_like_array_bool.fill_value
-    assert empty_like_array.shape == shape
+    assert empty_like_array_bool.shape == shape
+    assert empty_like_array_bool.store_path.store == store
 
     zeros_array = group.zeros(name="zeros", shape=shape)
     assert isinstance(zeros_array, Array)
     assert zeros_array.fill_value == 0
     assert zeros_array.shape == shape
+    assert zeros_array.store_path.store == store
 
     zeros_like_array = group.zeros_like(name="zeros_like", prototype=zeros_array)
     assert isinstance(zeros_like_array, Array)
     assert zeros_like_array.fill_value == 0
     assert zeros_like_array.shape == shape
+    assert zeros_like_array.store_path.store == store
 
     ones_array = group.ones(name="ones", shape=shape)
     assert isinstance(ones_array, Array)
     assert ones_array.fill_value == 1
     assert ones_array.shape == shape
+    assert ones_array.store_path.store == store
 
-    ones_like_array = group.ones_like(name="ones", prototype=ones_array)
+    ones_like_array = group.ones_like(name="ones_like", prototype=ones_array)
     assert isinstance(ones_like_array, Array)
     assert ones_like_array.fill_value == 1
     assert ones_like_array.shape == shape
+    assert ones_like_array.store_path.store == store
 
     full_array = group.full(name="full", shape=shape, fill_value=42)
     assert isinstance(full_array, Array)
     assert full_array.fill_value == 42
     assert full_array.shape == shape
+    assert full_array.store_path.store == store
 
     full_like_array = group.full_like(name="full_like", prototype=full_array, fill_value=43)
     assert isinstance(full_like_array, Array)
     assert full_like_array.fill_value == 43
     assert full_like_array.shape == shape
+    assert full_like_array.store_path.store == store
 
 
 @pytest.mark.parametrize("store", ("local", "memory", "zip"), indirect=["store"])