Improvements in the test (not yet there)

Author: FrancescAlted

blosc/b2nd.c

@@ -1372,7 +1372,11 @@ int b2nd_concatenate(b2nd_context_t *ctx, const b2nd_array_t *src1,
                                                src2->sc->typesize * src2->extchunknitems));
     // Get multidimensional chunk position
     int64_t nchunk_ndim[B2ND_MAX_DIM] = {0};
-    blosc2_unidim_to_multidim(src2->ndim, (int64_t*)(src2->chunkshape), nchunk, nchunk_ndim);
+    int64_t chunkshape[B2ND_MAX_DIM] = {0};
+    for (int8_t i = 0; i < src2->ndim; ++i) {
+      chunkshape[i] = src2->chunkshape[i];
+    }
+    blosc2_unidim_to_multidim(src2->ndim, chunkshape, nchunk, nchunk_ndim);
 
     // Set positions for each dimension
     for (int8_t i = 0; i < src2->ndim; ++i) {
@@ -1390,7 +1394,7 @@ int b2nd_concatenate(b2nd_context_t *ctx, const b2nd_array_t *src1,
     }
 
     // Copy the chunk to the correct position
-    BLOSC_ERROR(b2nd_set_slice_cbuffer(buffer, (int64_t*)(src2->chunkshape),
+    BLOSC_ERROR(b2nd_set_slice_cbuffer(buffer, chunkshape,
                                        src2->sc->typesize * src2->extchunknitems,
                                        start, stop, *array));
   }

tests/b2nd/test_b2nd_concatenate.c

@@ -12,30 +12,31 @@
 
 typedef struct {
   int8_t ndim;
-  int64_t shape[B2ND_MAX_DIM];
-  int32_t chunkshape[B2ND_MAX_DIM];
-  int32_t blockshape[B2ND_MAX_DIM];
-  int64_t start[B2ND_MAX_DIM];
-  int64_t stop[B2ND_MAX_DIM];
+    int64_t shape1[B2ND_MAX_DIM];
+    int32_t chunkshape1[B2ND_MAX_DIM];
+    int32_t blockshape1[B2ND_MAX_DIM];
+    int64_t shape2[B2ND_MAX_DIM];
+    int32_t chunkshape2[B2ND_MAX_DIM];
+    int32_t blockshape2[B2ND_MAX_DIM];
 } test_shapes_t;
 
 
 CUTEST_TEST_SETUP(concatenate) {
   blosc2_init();
 
-  // Add parametrizations
+  // Add parametrization
   CUTEST_PARAMETRIZE(typesize, uint8_t, CUTEST_DATA(
       1,
-      2,
-      4,
-      8,
+//      2,
+//      4,
+//      8,
   ));
 
   CUTEST_PARAMETRIZE(backend, _test_backend, CUTEST_DATA(
       {false, false},
-      {true, false},
-      {true, true},
-      {false, true},
+//      {true, false},
+//      {true, true},
+//      {false, true},
   ));
 
 
@@ -47,13 +48,7 @@ CUTEST_TEST_SETUP(concatenate) {
       // {2, {14, 10}, {8, 5}, {2, 2}, {5, 3}, {9, 10}},
       // {3, {12, 10, 14}, {3, 5, 9}, {3, 4, 4}, {3, 0, 3}, {6, 7, 10}},
       // {4, {10, 21, 30, 5}, {8, 7, 15, 3}, {5, 5, 10, 1}, {5, 4, 3, 3}, {10, 8, 8, 4}},
-      {2, {50, 50}, {25, 13}, {8, 8}, {0, 0}, {10, 10}},
-      // The case below makes qemu-aarch64 (AARCH64 emulation) in CI (Ubuntu 22.04) to crash with a segfault.
-      // Interestingly, this works perfectly well on both intel64 (native) and in aarch64 (emulated via docker).
-      // Moreover, valgrind does not issue any warning at all when run in the later platforms.
-      // In conclusion, this *may* be revealing a bug in the qemu-aarch64 binaries in Ubuntu 22.04.
-      // {2, {143, 41}, {18, 13}, {7, 7}, {4, 2}, {6, 5}},
-      // Replacing the above line by this one makes qemu-aarch64 happy.
+      {2, {50, 50}, {25, 13}, {5, 8}, {50, 50}, {25, 13}, {5, 8}},
       // {2, {150, 45}, {15, 15}, {7, 7}, {4, 2}, {6, 5}},
       // {2, {10, 10}, {5, 7}, {2, 2}, {0, 0}, {5, 5}},
       // // Checks for fast path in setting a single chunk that is C contiguous
@@ -62,8 +57,15 @@ CUTEST_TEST_SETUP(concatenate) {
       // {3, {3, 8, 5}, {1, 4, 5}, {1, 2, 5}, {1, 4, 0}, {2, 8, 5}},
   ));
   CUTEST_PARAMETRIZE(fill_value, int8_t, CUTEST_DATA(
-    3, 113, 33, -5
-));
+      3,
+//    113,
+//    33,
+//    -5
+  ));
+  CUTEST_PARAMETRIZE(axis, int8_t, CUTEST_DATA(
+      0,
+      1,
+  ));
 
 }
 
@@ -72,38 +74,45 @@ CUTEST_TEST_TEST(concatenate) {
   CUTEST_GET_PARAMETER(shapes, test_shapes_t);
   CUTEST_GET_PARAMETER(typesize, uint8_t);
   CUTEST_GET_PARAMETER(fill_value, int8_t);
+  CUTEST_GET_PARAMETER(axis, int8_t);
 
   char *urlpath = "test_concatenate.b2frame";
+  char *urlpath1 = "test_concatenate1.b2frame";
+  char *urlpath2 = "test_concatenate2.b2frame";
   blosc2_remove_urlpath(urlpath);
+  blosc2_remove_urlpath(urlpath1);
+  blosc2_remove_urlpath(urlpath2);
+
+  // Create a helper buffer for storing the final array for the concatenation in C
+  int64_t helpershape[B2ND_MAX_DIM] = {0};
+  size_t buffersize = typesize;
+  for (int i = 0; i < shapes.ndim; ++i) {
+    if (i == axis) {
+      buffersize *= (size_t) (shapes.shape1[i] + shapes.shape2[i]);
+    }
+    else {
+      buffersize *= (size_t) shapes.shape1[i];
+    }
+  }
 
   blosc2_cparams cparams = BLOSC2_CPARAMS_DEFAULTS;
   cparams.nthreads = 2;
   cparams.typesize = typesize;
-  blosc2_storage b2_storage = {.cparams=&cparams};
+  blosc2_storage b2_storage1 = {.cparams=&cparams};
   if (backend.persistent) {
-    b2_storage.urlpath = urlpath;
+    b2_storage1.urlpath = urlpath1;
   }
-  b2_storage.contiguous = backend.contiguous;
+  b2_storage1.contiguous = backend.contiguous;
+  b2nd_context_t *ctx1 = b2nd_create_ctx(&b2_storage1, shapes.ndim, shapes.shape1,
+                                        shapes.chunkshape1, shapes.blockshape1, NULL,
+                                        0, NULL, 0);
 
-  b2nd_context_t *ctx = b2nd_create_ctx(&b2_storage, shapes.ndim, shapes.shape,
-                                        shapes.chunkshape, shapes.blockshape, NULL, 0, NULL, 0);
-
-  /* Create dest buffer */
-  int64_t shape[B2ND_MAX_DIM] = {0};
-  int64_t buffersize = typesize;
-  for (int i = 0; i < ctx->ndim; ++i) {
-    shape[i] = shapes.stop[i] - shapes.start[i];
-    buffersize *= shape[i];
-  }
-
-  // uint8_t *buffer = malloc(buffersize);
-  // CUTEST_ASSERT("Buffer filled incorrectly", fill_buf(buffer, typesize, buffersize / typesize));
 
   /* Create src1 with zeros */
   b2nd_array_t *src1;
-  BLOSC_ERROR(b2nd_zeros(ctx, &src1));
-  
-  /* Create src2 with ones */
+  BLOSC_ERROR(b2nd_zeros(ctx1, &src1));
+
+  /* Create src2 with a value */
   b2nd_array_t *src2;
   uint8_t *value = malloc(typesize);
   switch (typesize) {
@@ -126,35 +135,80 @@ CUTEST_TEST_TEST(concatenate) {
     }
     break;
   }
-  B2ND_TEST_ASSERT(b2nd_full(ctx, &src2, value));
+  blosc2_storage b2_storage2 = {.cparams=&cparams};
+  if (backend.persistent) {
+    b2_storage2.urlpath = urlpath2;
+  }
+  b2_storage2.contiguous = backend.contiguous;
+  b2nd_context_t *ctx2 = b2nd_create_ctx(&b2_storage2, shapes.ndim, shapes.shape2,
+                                         shapes.chunkshape2, shapes.blockshape2,
+                                         NULL, 0, NULL, 0);
+  B2ND_TEST_ASSERT(b2nd_full(ctx2, &src2, value));
 
   /* Concatenate src1 and src2 */
   b2nd_array_t *array = NULL;
-  B2ND_TEST_ASSERT(b2nd_concatenate(ctx, src1, src2, &array, 0));
-
-  // for (uint64_t i = 0; i < (uint64_t) buffersize / typesize; ++i) {
-  //   uint64_t k = i + 1;
-  //   switch (typesize) {
-  //     case 8:
-  //       CUTEST_ASSERT("Elements are not equals!",
-  //                     (uint64_t) k == ((uint64_t *) destbuffer)[i]);
-  //       break;
-  //     case 4:
-  //       CUTEST_ASSERT("Elements are not equals!",
-  //                     (uint32_t) k == ((uint32_t *) destbuffer)[i]);
-  //       break;
-  //     case 2:
-  //       CUTEST_ASSERT("Elements are not equals!",
-  //                     (uint16_t) k == ((uint16_t *) destbuffer)[i]);
-  //       break;
-  //     case 1:
-  //       CUTEST_ASSERT("Elements are not equals!",
-  //                     (uint8_t) k == ((uint8_t *) destbuffer)[i]);
-  //       break;
-  //     default:
-  //       B2ND_TEST_ASSERT(BLOSC2_ERROR_INVALID_PARAM);
-  //   }
-  // }
+  blosc2_storage b2_storage = {.cparams=&cparams};
+  if (backend.persistent) {
+    b2_storage.urlpath = urlpath;
+  }
+  b2_storage2.contiguous = backend.contiguous;
+  b2nd_context_t *ctx = b2nd_create_ctx(&b2_storage, shapes.ndim, shapes.shape1,
+                                        shapes.chunkshape1, shapes.blockshape1,
+                                        NULL, 0, NULL, 0);
+  B2ND_TEST_ASSERT(b2nd_concatenate(ctx, src1, src2, &array, axis));
+
+  // Check the shape of the concatenated array
+  for (int i = 0; i < ctx->ndim; ++i) {
+    if (i == axis) {
+      CUTEST_ASSERT("Shape is not equal!",
+                    array->shape[i] == shapes.shape1[i] + shapes.shape2[i]);
+    }
+    else {
+      CUTEST_ASSERT("Shape is not equal!",
+                    array->shape[i] == shapes.shape1[i]);
+    }
+  }
+
+  // Check the chunkshape of the concatenated array
+  for (int i = 0; i < ctx->ndim; ++i) {
+    CUTEST_ASSERT("Chunkshape is not equal!", array->chunkshape[i] == shapes.chunkshape1[i]);
+  }
+
+  // Check the data in the concatenated array
+  int64_t start[B2ND_MAX_DIM] = {0};
+  int64_t stop[B2ND_MAX_DIM] = {0};
+  int64_t buffershape[B2ND_MAX_DIM] = {0};
+  for (int i = 0; i < ctx->ndim; ++i) {
+    start[i] = 0;
+    stop[i] = array->shape[i];
+    buffershape[i] = stop[i] - start[i];
+    buffersize *= buffershape[i];
+  }
+  uint8_t *buffer = malloc(buffersize);
+  B2ND_TEST_ASSERT(b2nd_get_slice_cbuffer(array, start, stop, buffer, buffershape, buffersize));
+  for (int64_t i = 0; i < buffersize / typesize; ++i) {
+    switch (typesize) {
+    case 8:
+      B2ND_TEST_ASSERT(((int64_t *) buffer)[i] == (i + 1));
+      break;
+    case 4:
+      B2ND_TEST_ASSERT(((int32_t *) buffer)[i] == (i + 1));
+      break;
+    case 2:
+      B2ND_TEST_ASSERT(((int16_t *) buffer)[i] == (i + 1));
+      break;
+    case 1:
+      printf("Checking value at index %lld: %d\n", i, ((int8_t *) buffer)[i]);
+        CUTEST_ASSERT("Value is not equal!", ((int8_t *) buffer)[i] == 0);
+      break;
+    default:
+      // Check the value in the buffer
+      for (int j = 0; j < typesize; ++j) {
+        B2ND_TEST_ASSERT(buffer[i * typesize + j] == value[j]);
+      }
+      break;
+    }
+  }
 
   /* Free mallocs */
   // free(buffer);
@@ -164,7 +218,11 @@ CUTEST_TEST_TEST(concatenate) {
   B2ND_TEST_ASSERT(b2nd_free(src2));
   B2ND_TEST_ASSERT(b2nd_free(array));
   B2ND_TEST_ASSERT(b2nd_free_ctx(ctx));
+  B2ND_TEST_ASSERT(b2nd_free_ctx(ctx1));
+  B2ND_TEST_ASSERT(b2nd_free_ctx(ctx2));
   blosc2_remove_urlpath(urlpath);
+  blosc2_remove_urlpath(urlpath1);
+  blosc2_remove_urlpath(urlpath2);
 
   return 0;
 }