incorporate feedback for java version and merge tests

Author: brokkoli71

pom.xml

@@ -9,8 +9,8 @@
     <version>0.0.1-SNAPSHOT</version>
 
     <properties>
-        <maven.compiler.source>11</maven.compiler.source>
-        <maven.compiler.target>11</maven.compiler.target>
+        <maven.compiler.source>8</maven.compiler.source>
+        <maven.compiler.target>8</maven.compiler.target>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
         <jackson.version>2.14.2</jackson.version>
         <aws.version>1.12.477</aws.version>

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

@@ -129,13 +129,17 @@ public void testZstdLibrary(int clevel, boolean checksumFlag) throws IOException
 
     @ParameterizedTest
     @ValueSource(strings = {"blosc", "gzip", "zstd", "bytes", "transpose", "sharding_start", "sharding_end", "crc32c"})
-    public void testWriteToZarrita(String codec) throws IOException, ZarrException, InterruptedException {
+    public void testWriteRead(String codec) throws IOException, ZarrException, InterruptedException {
+        int[] testData = new int[16 * 16 * 16];
+        Arrays.setAll(testData, p -> p);
+
         StoreHandle storeHandle = new FilesystemStore(TESTOUTPUT).resolve("write_to_zarrita", codec);
         ArrayMetadataBuilder builder = Array.metadataBuilder()
-                .withShape(16, 16)
+                .withShape(16, 16, 16)
                 .withDataType(DataType.UINT32)
-                .withChunkShape(8, 8)
-                .withFillValue(0);
+                .withChunkShape(2, 4, 8)
+                .withFillValue(0)
+                .withAttributes(Map.of("test_key", "test_value"));
 
         switch (codec) {
             case "blosc":
@@ -151,13 +155,13 @@ public void testWriteToZarrita(String codec) throws IOException, ZarrException,
                 builder = builder.withCodecs(c -> c.withBytes("LITTLE"));
                 break;
             case "transpose":
-                builder = builder.withCodecs(c -> c.withTranspose(new int[]{1, 0}));
+                builder = builder.withCodecs(c -> c.withTranspose(new int[]{1, 0, 2}));
                 break;
             case "sharding_start":
-                builder = builder.withCodecs(c -> c.withSharding(new int[]{4, 4}, c1 -> c1.withBytes("LITTLE"), "start"));
+                builder = builder.withCodecs(c -> c.withSharding(new int[]{2, 2, 4}, c1 -> c1.withBytes("LITTLE"), "start"));
                 break;
             case "sharding_end":
-                builder = builder.withCodecs(c -> c.withSharding(new int[]{4, 4}, c1 -> c1.withBytes("LITTLE"), "end"));
+                builder = builder.withCodecs(c -> c.withSharding(new int[]{2, 2, 4}, c1 -> c1.withBytes("LITTLE"), "end"));
                 break;
             case "crc32c":
                 builder = builder.withCodecs(CodecBuilder::withCrc32c);
@@ -166,12 +170,21 @@ public void testWriteToZarrita(String codec) throws IOException, ZarrException,
                 throw new IllegalArgumentException("Invalid Codec: " + codec);
         }
 
-        Array array = Array.create(storeHandle, builder.build());
+        Array writeArray = Array.create(storeHandle, builder.build());
+        writeArray.write(ucar.ma2.Array.factory(ucar.ma2.DataType.UINT, new int[]{16, 16, 16}, testData));
+
+        //read in zarr-java
+        Array readArray = Array.open(storeHandle);
+        ucar.ma2.Array result = readArray.read();
 
-        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));
+        Assertions.assertArrayEquals(new int[]{16, 16, 16}, result.getShape());
+        Assertions.assertEquals(DataType.UINT32, readArray.metadata.dataType);
+        Assertions.assertArrayEquals(new int[]{2, 4, 8}, readArray.metadata.chunkShape());
+        Assertions.assertEquals("test_value", readArray.metadata.attributes.get("test_key"));
 
+        Assertions.assertArrayEquals(testData, (int[]) result.get1DJavaArray(ucar.ma2.DataType.INT));
+
+        //read in zarrita
         String command = pythonPath();
 
         ProcessBuilder pb = new ProcessBuilder(command, PYTHON_TEST_PATH.resolve("zarrita_read.py").toString(), codec, TESTOUTPUT.toString());
@@ -192,64 +205,6 @@ public void testWriteToZarrita(String codec) throws IOException, ZarrException,
         assert exitCode == 0;
     }
 
-
-    @ParameterizedTest
-    @ValueSource(strings = {"blosc", "gzip", "zstd", "bytes", "transpose", "sharding_start", "sharding_end", "crc32c"})
-    public void testCodecsWriteRead(String codec) throws IOException, ZarrException {
-        int[] testData = new int[16 * 16 * 16];
-        Arrays.setAll(testData, p -> p);
-
-        StoreHandle storeHandle = new FilesystemStore(TESTOUTPUT).resolve("testWriteAndRead3d", codec);
-        ArrayMetadataBuilder builder = Array.metadataBuilder()
-                .withShape(16, 16, 16)
-                .withDataType(DataType.UINT32)
-                .withChunkShape(2, 4, 8)
-                .withFillValue(0)
-                .withAttributes(Map.of("test_key", "test_value"));
-
-        switch (codec) {
-            case "blosc":
-                builder = builder.withCodecs(CodecBuilder::withBlosc);
-                break;
-            case "gzip":
-                builder = builder.withCodecs(CodecBuilder::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(new int[]{1, 0, 2}));
-                break;
-            case "sharding_start":
-                builder = builder.withCodecs(c -> c.withSharding(new int[]{2, 2, 4}, c1 -> c1.withBytes("LITTLE"), "end"));
-                break;
-            case "sharding_end":
-                builder = builder.withCodecs(c -> c.withSharding(new int[]{2, 2, 4}, c1 -> c1.withBytes("LITTLE"), "start"));
-                break;
-            case "crc32c":
-                builder = builder.withCodecs(CodecBuilder::withCrc32c);
-                break;
-            default:
-                throw new IllegalArgumentException("Invalid Codec: " + codec);
-        }
-
-        Array writeArray = Array.create(storeHandle, builder.build());
-        writeArray.write(ucar.ma2.Array.factory(ucar.ma2.DataType.UINT, new int[]{16, 16, 16}, testData));
-
-        Array readArray = Array.open(storeHandle);
-        ucar.ma2.Array result = readArray.read();
-
-        Assertions.assertArrayEquals(new int[]{16, 16, 16}, result.getShape());
-        Assertions.assertEquals(DataType.UINT32, readArray.metadata.dataType);
-        Assertions.assertArrayEquals(new int[]{2, 4, 8}, readArray.metadata.chunkShape());
-        Assertions.assertEquals("test_value", readArray.metadata.attributes.get("test_key"));
-
-        Assertions.assertArrayEquals(testData, (int[]) result.get1DJavaArray(ucar.ma2.DataType.INT));
-    }
-
     @ParameterizedTest
     @CsvSource({"0,true", "0,false", "5, true", "5, false"})
     public void testZstdCodecReadWrite(int clevel, boolean checksum) throws ZarrException, IOException {

src/test/python-scripts/zarrita_read.py

@@ -14,32 +14,32 @@
 elif codec_string == "bytes":
     codec = [zarrita.codecs.bytes_codec()]
 elif codec_string == "transpose":
-    codec = [zarrita.codecs.transpose_codec((1, 0)), zarrita.codecs.bytes_codec()]
+    codec = [zarrita.codecs.transpose_codec((1, 0, 2)), zarrita.codecs.bytes_codec()]
 elif codec_string == "sharding_start":
-    codec= zarrita.codecs.sharding_codec(chunk_shape=(4, 4), codecs=[zarrita.codecs.bytes_codec("little")], index_location= zarrita.metadata.ShardingCodecIndexLocation.start),
+    codec= zarrita.codecs.sharding_codec(chunk_shape=(2, 2, 4), codecs=[zarrita.codecs.bytes_codec("little")], index_location= zarrita.metadata.ShardingCodecIndexLocation.start),
 elif codec_string == "sharding_end":
-    codec= zarrita.codecs.sharding_codec(chunk_shape=(4, 4), codecs=[zarrita.codecs.bytes_codec("little")], index_location= zarrita.metadata.ShardingCodecIndexLocation.end),
+    codec= zarrita.codecs.sharding_codec(chunk_shape=(2, 2, 4), codecs=[zarrita.codecs.bytes_codec("little")], index_location= zarrita.metadata.ShardingCodecIndexLocation.end),
 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)
+expected_data = np.arange(16*16*16, dtype='int32').reshape(16, 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 / 'read_from_zarrita_expected' / codec_string,
-    shape=(16, 16),
-    chunk_shape=(8, 8),
+    shape=(16, 16, 16),
+    chunk_shape=(2, 4, 8),
     dtype="uint32",
     fill_value=0,
+    attributes={'test_key': 'test_value'},
     codecs=codec
     )
 
-assert a.metadata == b.metadata,  f"not equal: \n{a.metadata.codecs=}\n{b.metadata.codecs=}"
+assert a.metadata == b.metadata,  f"not equal: \n{a.metadata=}\n{b.metadata=}"