parameterize codecs in testReadFromZarrita

Author: brokkoli71

src/test/java/dev/zarr/zarrjava/ZarrTest.java

@@ -12,12 +12,7 @@
 import dev.zarr.zarrjava.store.S3Store;
 import dev.zarr.zarrjava.store.StoreHandle;
 import dev.zarr.zarrjava.utils.MultiArrayUtils;
-import dev.zarr.zarrjava.v3.Array;
-import dev.zarr.zarrjava.v3.ArrayMetadata;
-import dev.zarr.zarrjava.v3.DataType;
-import dev.zarr.zarrjava.v3.Group;
-import dev.zarr.zarrjava.v3.GroupMetadata;
-import dev.zarr.zarrjava.v3.Node;
+import dev.zarr.zarrjava.v3.*;
 
 import java.io.BufferedReader;
 import java.io.File;
@@ -38,6 +33,7 @@
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.ValueSource;
 
+import javax.management.InvalidAttributeValueException;
 import javax.xml.crypto.Data;
 
 public class ZarrTest {
@@ -134,32 +130,54 @@ public void testReadFromZarrita(String codec) throws IOException, ZarrException,
         Assertions.assertEquals(DataType.INT32, array.metadata.dataType);
         Assertions.assertArrayEquals(new int[]{2, 8}, array.metadata.chunkShape());
         Assertions.assertEquals(42, array.metadata.attributes.get("answer"));
+
         int[] expectedData = new int[16 * 16];
-        for (int i = 0; i < 16 * 16; i++) {
-            expectedData[i] = i;
-        }
+        Arrays.setAll(expectedData, p -> p);
         Assertions.assertArrayEquals(expectedData, (int[]) result.get1DJavaArray(ucar.ma2.DataType.INT));
     }
 
+    //TODO: add crc32c
     @ParameterizedTest
-    @ValueSource(strings = {"blosc", "gzip", "zstd", "bytes", "transpose", "sharding", "crc32c"})
+    @ValueSource(strings = {"blosc", "gzip", "zstd", "bytes", "transpose", "sharding"})
     public void testWriteToZarrita(String codec) throws IOException, ZarrException, InterruptedException {
         StoreHandle storeHandle = new FilesystemStore(TESTOUTPUT).resolve("write_to_zarrita", codec);
-
-//TODO: have correct codecs
-        Array array = Array.create(
-                storeHandle,
-                Array.metadataBuilder()
+        ArrayMetadataBuilder builder = Array.metadataBuilder()
                         .withShape(16, 16)
                         .withDataType(DataType.UINT32)
                         .withChunkShape(8, 8)
-                        .withFillValue(0)
-                        .withCodecs(c -> c.withSharding(new int[]{4, 4}, c1 -> c1.withBytes("LITTLE")))
-                        .build());
+                        .withFillValue(0);
+
+        switch (codec){
+            case "blosc":
+                builder = builder.withCodecs(c -> c.withBlosc());
+                break;
+            case "gzip":
+                builder = builder.withCodecs(c -> c.withGzip());
+                break;
+            case "zstd":
+                builder = builder.withCodecs(c -> c.withZstd(0));
+                break;
+            case "bytes":
+                builder = builder.withCodecs(c -> c.withBytes("LITTLE"));
+                break;
+            case "transpose":
+                builder = builder.withCodecs(c -> c.withTranspose("F"));
+                break;
+            case "sharding":
+                builder = builder.withCodecs(c -> c.withSharding(new int[]{4, 4}, c1 -> c1.withBytes("LITTLE")));
+                break;
+            case "crc32c":
+                //missing
+                break;
+            default:
+                throw new IllegalArgumentException("Invalid Codec: "+codec);
+        }
+
+        Array array = Array.create(storeHandle,builder.build());
 
-        ucar.ma2.Array testData = ucar.ma2.Array.factory(ucar.ma2.DataType.UINT, new int[]{16, 16});
-        testData.setInt(10, 42);
-        array.write(testData);
+        int[] data = new int[16*16];
+        Arrays.setAll(data, p -> p);
+        array.write(ucar.ma2.Array.factory(ucar.ma2.DataType.UINT, new int[]{16, 16}, data));
 
 
         String command = "zarrita/bin/python";
@@ -181,7 +199,6 @@ public void testWriteToZarrita(String codec) throws IOException, ZarrException,
         int exitCode = process.waitFor();
         assert exitCode == 0;
         //TODO return metadata from zarrita_read.py and do assertions here
-
     }
 
 

src/test/java/dev/zarr/zarrjava/zarrita_read.py

@@ -1,26 +1,43 @@
 import zarrita
 import numpy as np
+import sys
 
-store = zarrita.LocalStore('testoutput')
-expected_data = np.zeros((16, 16), dtype='int32')
-expected_data[0, 10] = 42
 
-a = zarrita.Array.open(store / 'array')
-assert np.array_equal(a[:, :], expected_data)
+codec_string = sys.argv[1]
+codec = []
+if codec_string == "blosc":
+    codec = [zarrita.codecs.bytes_codec(), zarrita.codecs.blosc_codec(typesize=4)]
+elif codec_string == "gzip":
+    codec = [zarrita.codecs.bytes_codec(), zarrita.codecs.gzip_codec()]
+elif codec_string == "zstd":
+    codec = [zarrita.codecs.bytes_codec(), zarrita.codecs.zstd_codec()]
+elif codec_string == "bytes":
+    codec = [zarrita.codecs.bytes_codec()]
+elif codec_string == "transpose":
+    codec = [zarrita.codecs.transpose_codec("F"), zarrita.codecs.bytes_codec()]
+elif codec_string == "sharding":
+    codec= zarrita.codecs.sharding_codec(chunk_shape=(4, 4), codecs=[zarrita.codecs.bytes_codec("little")]),
+elif codec_string == "crc32c":
+    codec = [zarrita.codecs.bytes_codec(), zarrita.codecs.crc32c_codec()]
+else:
+    raise ValueError(f"Invalid {codec=}")
 
 
+store = zarrita.LocalStore(sys.argv[2])
+expected_data = np.arange(16*16, dtype='int32').reshape(16, 16)
+
+a = zarrita.Array.open(store / 'write_to_zarrita' / codec_string)
+read_data = a[:, :]
+assert np.array_equal(read_data, expected_data), f"got:\n {read_data} \nbut expected:\n {expected_data}"
+
 # might need to check individual properties
 b = zarrita.Array.create(
-    store / "b",
+    store / 'read_from_zarrita_expected' / codec_string,
     shape=(16, 16),
-    chunk_shape=(16, 16),
+    chunk_shape=(8, 8),
     dtype="uint32",
     fill_value=0,
-    codecs=[
-        zarrita.codecs.bytes_codec(),
-    ],
+    codecs=codec
     )
 
-assert a.metadata == b.metadata
-
-print(a.metadata)
+assert a.metadata == b.metadata,  f"not equal: \n{a.metadata.codecs=}\n{b.metadata.codecs=}"