xnd 0.2.0dev6 → 0.2.0dev7

data/ext/ruby_xnd/xnd/libxnd/xnd.h

@@ -35,12 +35,23 @@
 #define XND_H
 
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #include <stdlib.h>
 #include <stdint.h>
 #include <string.h>
 #include <assert.h>
 #include "ndtypes.h"
 
+#ifdef __cplusplus
+  #include <cstdint>
+#else
+  #include <stdint.h>
+  #include <inttypes.h>
+#endif
+
 
 #ifdef _MSC_VER
   #if defined (XND_EXPORT)
@@ -50,8 +61,13 @@
   #else
     #define XND_API
   #endif
+
+  #include "malloc.h"
+  #define ALLOCA(type, name, nmemb) type *name = _alloca(nmemb * sizeof(type))
 #else
   #define XND_API
+
+  #define ALLOCA(type, name, nmemb) type name[nmemb]
 #endif
 
 
@@ -73,24 +89,32 @@
 #define XND_OWN_DATA     0x00000002U /* data pointer */
 #define XND_OWN_STRINGS  0x00000004U /* embedded string pointers */
 #define XND_OWN_BYTES    0x00000008U /* embedded bytes pointers */
-#define XND_OWN_POINTERS 0x00000010U /* embedded pointers */
+#define XND_OWN_ARRAYS   0x00000010U /* embedded array pointers */
+#define XND_OWN_POINTERS 0x00000020U /* embedded pointers */
+#define XND_CUDA_MANAGED 0x00000040U /* cuda managed memory */
 
 #define XND_OWN_ALL (XND_OWN_TYPE |    \
                      XND_OWN_DATA |    \
                      XND_OWN_STRINGS | \
                      XND_OWN_BYTES |   \
+                     XND_OWN_ARRAYS |  \
                      XND_OWN_POINTERS)
 
 #define XND_OWN_EMBEDDED (XND_OWN_DATA |    \
                           XND_OWN_STRINGS | \
                           XND_OWN_BYTES |   \
+                          XND_OWN_ARRAYS |  \
                           XND_OWN_POINTERS)
 
 
 /* Convenience macros to extract embedded values. */
 #define XND_POINTER_DATA(ptr) (*((char **)ptr))
+#define XND_STRING_DATA(ptr) ((*((const char **)ptr)) == NULL ? "" : (*((const char **)ptr)))
 #define XND_BYTES_SIZE(ptr) (((ndt_bytes_t *)ptr)->size)
 #define XND_BYTES_DATA(ptr) (((ndt_bytes_t *)ptr)->data)
+#define XND_ARRAY_SHAPE(ptr) (((ndt_array_t *)ptr)->shape)
+#define XND_ARRAY_DATA(ptr) (((ndt_array_t *)ptr)->data)
+#define XND_UNION_TAG(ptr) (*((uint8_t *)ptr))
 
 
 /* Bitmap tree. */
@@ -142,6 +166,7 @@ typedef struct xnd_view {
 
 XND_API xnd_master_t *xnd_empty_from_string(const char *s, uint32_t flags, ndt_context_t *ctx);
 XND_API xnd_master_t *xnd_empty_from_type(const ndt_t *t, uint32_t flags, ndt_context_t *ctx);
+XND_API void xnd_clear(xnd_t * const x, const uint32_t flags);
 XND_API void xnd_del(xnd_master_t *x);
 
 /* Create and delete pristine xnd_t buffers. */
@@ -153,18 +178,22 @@ XND_API void xnd_del_buffer(xnd_t *x, uint32_t flags);
 /*                         Traverse xnd memory blocks                        */
 /*****************************************************************************/
 
+XND_API bool have_stored_index(const ndt_t *t);
+XND_API int64_t get_stored_index(const ndt_t *t);
+XND_API xnd_t apply_stored_index(const xnd_t *x, ndt_context_t *ctx);
+XND_API xnd_t apply_stored_indices(const xnd_t *x, ndt_context_t *ctx);
+
 XND_API xnd_t xnd_subtree_index(const xnd_t *x, const int64_t *indices, int len,
                                 ndt_context_t *ctx);
 
 XND_API xnd_t xnd_subtree(const xnd_t *x, const xnd_index_t indices[], int len,
                           ndt_context_t *ctx);
 
-XND_API xnd_t xnd_multikey(const xnd_t *x, const xnd_index_t indices[], int len,
-                           ndt_context_t *ctx);
-
 XND_API xnd_t xnd_subscript(const xnd_t *x, const xnd_index_t indices[], int len,
                             ndt_context_t *ctx);
 
+XND_API xnd_t xnd_reshape(const xnd_t *x, int64_t shape[], int ndim, char order, ndt_context_t *ctx);
+
 XND_API xnd_t *xnd_split(const xnd_t *x, int64_t *n, int max_outer, ndt_context_t *ctx);
 
 XND_API int xnd_equal(const xnd_t *x, const xnd_t *y, ndt_context_t *ctx);
@@ -173,6 +202,14 @@ XND_API int xnd_strict_equal(const xnd_t *x, const xnd_t *y, ndt_context_t *ctx)
 XND_API int xnd_copy(xnd_t *y, const xnd_t *x, uint32_t flags, ndt_context_t *ctx);
 
 
+/*****************************************************************************/
+/*                               Bounds checking                             */
+/*****************************************************************************/
+
+XND_API int xnd_bounds_check(const ndt_t *t, const int64_t linear_index,
+                             const int64_t bufsize, ndt_context_t *ctx);
+
+
 /*****************************************************************************/
 /*                                  Bitmaps                                  */
 /*****************************************************************************/
@@ -193,6 +230,8 @@ XND_API int xnd_is_na(const xnd_t *x);
 XND_API extern const xnd_t xnd_error;
 XND_API extern const xnd_bitmap_t xnd_bitmap_empty;
 
+XND_API int xnd_err_occurred(const xnd_t *x);
+
 
 /*****************************************************************************/
 /*                                 Unstable API                              */
@@ -219,10 +258,43 @@ XND_API bool xnd_double_is_little_endian(void);
 XND_API bool xnd_double_is_big_endian(void);
 
 
+/*****************************************************************************/
+/*                                  BFloat16                                 */
+/*****************************************************************************/
+
+XND_API void xnd_bfloat_pack(char *p, double x);
+XND_API double xnd_bfloat_unpack(char *p);
+
+
+/*****************************************************************************/
+/*                                   Cuda                                    */
+/*****************************************************************************/
+
+void *xnd_cuda_calloc_managed(uint16_t align, int64_t size, ndt_context_t *ctx);
+void xnd_cuda_free(void *ptr);
+int xnd_cuda_mem_prefetch_async(const void *ptr, int64_t count, int dev, ndt_context_t *ctx);
+int xnd_cuda_device_synchronize(ndt_context_t *ctx);
+
+
 /*****************************************************************************/
 /*                           Static inline functions                         */
 /*****************************************************************************/
 
+/* Check index bounds and adjust negative indices. */
+static inline int64_t
+adjust_index(const int64_t i, const int64_t shape, ndt_context_t *ctx)
+{
+    const int64_t k = i < 0 ? i + shape : i;
+
+    if (k < 0 || k >= shape || k > XND_SSIZE_MAX) {
+        ndt_err_format(ctx, NDT_IndexError,
+            "index with value %" PRIi64 " out of bounds", i);
+        return -1;
+    }
+
+    return k;
+}
+
 /*
  * This looks inefficient, but both gcc and clang clean up unused xnd_t members.
  */
@@ -258,6 +330,14 @@ xnd_fixed_shape(const xnd_t *x)
     return t->FixedDim.shape;
 }
 
+static inline int64_t
+xnd_fixed_step(const xnd_t *x)
+{
+    const ndt_t *t = x->type;
+    assert(t->tag == FixedDim);
+    return t->Concrete.FixedDim.step;
+}
+
 static inline int64_t
 xnd_fixed_shape_at(const xnd_t *x, const int i)
 {
@@ -339,6 +419,25 @@ xnd_record_next(const xnd_t *x, const int64_t i, ndt_context_t *ctx)
     return next;
 }
 
+static inline xnd_t
+xnd_union_next(const xnd_t *x, ndt_context_t *ctx)
+{
+    uint8_t i = XND_UNION_TAG(x->ptr);
+    const ndt_t *t = x->type;
+    xnd_t next;
+
+    next.bitmap = xnd_bitmap_next(x, i, ctx);
+    if (ndt_err_occurred(ctx)) {
+        return xnd_error;
+    }
+
+    next.index = 0;
+    next.type = t->Union.types[i];
+    next.ptr = x->ptr+1;
+
+    return next;
+}
+
 static inline xnd_t
 xnd_ref_next(const xnd_t *x, ndt_context_t *ctx)
 {
@@ -393,6 +492,23 @@ xnd_nominal_next(const xnd_t *x, ndt_context_t *ctx)
     return next;
 }
 
+static inline xnd_t
+xnd_array_next(const xnd_t *x, const int64_t i)
+{
+    const ndt_t *t = x->type;
+    const ndt_t *u = t->Array.type;
+    xnd_t next;
+
+    assert(t->tag == Array);
+
+    next.bitmap = x->bitmap;
+    next.index = 0;
+    next.type = u;
+    next.ptr = XND_ARRAY_DATA(x->ptr) + i * next.type->datasize;
+
+    return next;
+}
+
 #if NDT_SYS_BIG_ENDIAN == 1
   #define XND_REV_COND NDT_LITTLE_ENDIAN
 #else
@@ -445,5 +561,30 @@ le(uint32_t flags)
         dest = _x;                                      \
     } while (0)
 
+#define APPLY_STORED_INDICES_INT(x) \
+    xnd_t _##x##tail;                              \
+    if (have_stored_index(x->type)) {              \
+        _##x##tail = apply_stored_indices(x, ctx); \
+        if (xnd_err_occurred(&_##x##tail)) {       \
+            return -1;                             \
+        }                                          \
+        x = &_##x##tail;                           \
+    }
+
+#define APPLY_STORED_INDICES_XND(x) \
+    xnd_t _##x##tail;                              \
+    if (have_stored_index(x->type)) {              \
+        _##x##tail = apply_stored_indices(x, ctx); \
+        if (xnd_err_occurred(&_##x##tail)) {       \
+            return xnd_error;                      \
+        }                                          \
+        x = &_##x##tail;                           \
+    }
+
+
+#ifdef __cplusplus
+} /* END extern "C" */
+#endif
+
 
 #endif /* XND_H */

data/ext/ruby_xnd/xnd/python/test_xnd.py

@@ -33,11 +33,12 @@
 import sys, unittest, argparse
 from math import isinf, isnan
 from ndtypes import ndt, typedef
-from xnd import xnd, XndEllipsis
+from xnd import xnd, XndEllipsis, data_shapes
 from xnd._xnd import _test_view_subscript, _test_view_new
 from xnd_support import *
 from xnd_randvalue import *
 from _testbuffer import ndarray, ND_WRITABLE
+import random
 
 
 try:
@@ -59,6 +60,24 @@ def check_buffer(x):
         del x
         y.tobytes()
 
+def check_copy_contiguous(self, x):
+    y = x.copy_contiguous()
+    xv = x.value
+    yv = y.value
+    if have_none(xv) and have_none(yv):
+        self.assertEqual(xv, yv)
+    else:
+        self.assertEqual(x, y)
+
+    dtype = maxtype.get(x.dtype)
+    if dtype is not None:
+        y = x.copy_contiguous(dtype=dtype)
+        yv = y.value
+        if have_none(xv) and have_none(yv):
+            self.assertEqual(xv, yv)
+        else:
+            self.assertEqual(x, y)
+
 
 class XndTestCase(unittest.TestCase):
 
@@ -68,7 +87,17 @@ class XndTestCase(unittest.TestCase):
 
     def assertNotStrictEqual(self, x, y):
         self.assertFalse(x.strict_equal(y))
-        self.assertNotEqual(x, y)
+
+    def check_serialize(self, x):
+        try:
+            b = x.serialize()
+        except NotImplementedError:
+            return
+        try:
+            y = x.deserialize(b)
+        except NotImplementedError:
+            return
+        self.assertEqual(x, y)
 
 
 class TestModule(XndTestCase):
@@ -145,6 +174,12 @@ class TestFixedDim(XndTestCase):
                 self.assertEqual(x.type, t)
                 self.assertEqual(x.value, vv)
                 self.assertEqual(len(x), len(vv))
+                self.assertTrue(x.type.is_c_contiguous())
+
+        self.assertRaises(ValueError, xnd.empty, "?3 * int64")
+        self.assertRaises(ValueError, xnd.empty, "?2 * 3 * int64")
+        self.assertRaises(ValueError, xnd.empty, "2 * ?3 * int64")
+        self.assertRaises(ValueError, xnd.empty, "?2 * ?3 * int64")
 
     def test_fixed_dim_subscript(self):
         test_cases = [
@@ -161,6 +196,8 @@ class TestFixedDim(XndTestCase):
             t = ndt(s)
             x = xnd(v, type=t)
             check_buffer(x)
+            self.check_serialize(x)
+            self.assertTrue(x.type.is_c_contiguous())
 
             for i in range(3):
                 self.assertEqual(x[i].value, nd[i])
@@ -175,9 +212,11 @@ class TestFixedDim(XndTestCase):
             for start in list(range(-3, 4)) + [None]:
                 for stop in list(range(-3, 4)) + [None]:
                     for step in list(range(-3, 0)) + list(range(1, 4)) + [None]:
-                        s = slice(start, stop, step)
-                        self.assertEqual(x[s].value, nd[s])
-                        check_buffer(x[s])
+                        sl = slice(start, stop, step)
+                        self.assertEqual(x[sl].value, nd[sl])
+                        check_buffer(x[sl])
+                        self.check_serialize(x[sl])
+                        check_copy_contiguous(self, x[sl])
 
             self.assertEqual(x[:, 0].value, nd[:, 0])
             self.assertEqual(x[:, 1].value, nd[:, 1])
@@ -368,6 +407,13 @@ class TestFixedDim(XndTestCase):
                     y[indices] = w
                     self.assertNotStrictEqual(x, y)
 
+    def test_fixed_dim_equal(self):
+        x = xnd([1,2,3], dtype='int64')
+        y = xnd([1,2,3], dtype='float32')
+
+        self.assertEqual(x, y)
+        self.assertNotStrictEqual(x, y)
+
 
 class TestFortran(XndTestCase):
 
@@ -396,6 +442,7 @@ class TestFortran(XndTestCase):
                 self.assertEqual(x.type, t)
                 self.assertEqual(x.value, vv)
                 self.assertEqual(len(x), len(vv))
+                self.assertTrue(x.type.is_f_contiguous())
 
     def test_fortran_subscript(self):
         test_cases = [
@@ -412,6 +459,8 @@ class TestFortran(XndTestCase):
             t = ndt(s)
             x = xnd(v, type=t)
             check_buffer(x)
+            self.check_serialize(x)
+            self.assertTrue(x.type.is_f_contiguous())
 
             for i in range(3):
                 self.assertEqual(x[i].value, nd[i])
@@ -426,9 +475,11 @@ class TestFortran(XndTestCase):
             for start in list(range(-3, 4)) + [None]:
                 for stop in list(range(-3, 4)) + [None]:
                     for step in list(range(-3, 0)) + list(range(1, 4)) + [None]:
-                        s = slice(start, stop, step)
-                        self.assertEqual(x[s].value, nd[s])
-                        check_buffer(x[s])
+                        sl = slice(start, stop, step)
+                        self.assertEqual(x[sl].value, nd[sl])
+                        check_buffer(x[sl])
+                        self.check_serialize(x[sl])
+                        check_copy_contiguous(self, x[sl])
 
             self.assertEqual(x[:, 0].value, nd[:, 0])
             self.assertEqual(x[:, 1].value, nd[:, 1])
@@ -642,6 +693,14 @@ class TestVarDim(XndTestCase):
                 self.assertEqual(x.type, t)
                 self.assertEqual(x.value, vv)
                 self.assertEqual(len(x), len(vv))
+                self.assertTrue(x.type.is_var_contiguous())
+                check_copy_contiguous(self, x)
+                self.check_serialize(x)
+
+        self.assertRaises(NotImplementedError, xnd.empty, "?var(offsets=[0, 3]) * int64")
+        self.assertRaises(NotImplementedError, xnd.empty, "?var(offsets=[0, 2]) * var(offsets=[0, 3, 10]) * int64")
+        self.assertRaises(NotImplementedError, xnd.empty, "var(offsets=[0, 2]) * ?var(offsets=[0, 3, 10]) * int64")
+        self.assertRaises(NotImplementedError, xnd.empty, "?var(offsets=[0, 2]) * ?var(offsets=[0, 3, 10]) * int64")
 
     def test_var_dim_assign(self):
         ### Regular data ###
@@ -712,39 +771,41 @@ class TestVarDim(XndTestCase):
         x = xnd([0, 1, 2, 3, 4], type="var(offsets=[0,5]) * complex128")
         sig = ndt("var... * complex128 -> var... * complex128")
 
-        spec = sig.apply([x.type])
-        self.assertTrue(type_equal(spec.out_types[0], x.type))
+        spec = sig.apply(x.type)
+        self.assertTrue(type_equal(spec.types[1], x.type))
 
         y = x[::-1]
-        spec = sig.apply([y.type])
-        self.assertTrue(type_equal(spec.out_types[0], y.type))
+        spec = sig.apply(y.type)
+        self.assertTrue(type_equal(spec.types[1], y.type))
 
         y = x[1:3:-1]
-        spec = sig.apply([y.type])
-        self.assertTrue(type_equal(spec.out_types[0], y.type))
+        spec = sig.apply(y.type)
+        self.assertTrue(type_equal(spec.types[1], y.type))
 
         sig = ndt("var... * complex128, var... * complex128 -> var... * complex128")
-        spec = sig.apply([x.type, x.type])
-        self.assertTrue(type_equal(spec.out_types[0], x.type))
+        spec = sig.apply(x.type, x.type)
+        self.assertTrue(type_equal(spec.types[1], x.type))
 
         y = x[::-1]
         sig = ndt("var... * complex128, var... * complex128 -> var... * complex128")
-        spec = sig.apply([x.type, y.type])
-        self.assertTrue(type_equal(spec.out_types[0], x.type))
+        spec = sig.apply(x.type, y.type)
+        self.assertTrue(type_equal(spec.types[1], x.type))
 
         x = xnd([[0], [1, 2], [3, 4, 5]], dtype="complex128")
         y = xnd([[3, 4, 5], [1, 2], [0]], dtype="complex128")
         z = y[::-1]
         sig = ndt("var... * complex128, var... * complex128 -> var... * complex128")
-        spec = sig.apply([x.type, z.type])
-        self.assertTrue(type_equal(spec.out_types[0], x.type))
+        spec = sig.apply(x.type, z.type)
+        self.assertTrue(type_equal(spec.types[1], x.type))
+        self.assertEqual(x.dtype, ndt("complex128"))
 
         x = xnd([[0], [1, 2], [3, 4, 5]], dtype="complex128")
         y = xnd([[5, 4, 3], [2, 1], [0]], dtype="complex128")
         z = y[::-1, ::-1]
         sig = ndt("var... * complex128, var... * complex128 -> var... * complex128")
-        spec = sig.apply([x.type, z.type])
-        self.assertTrue(type_equal(spec.out_types[0], x.type))
+        spec = sig.apply(x.type, z.type)
+        self.assertTrue(type_equal(spec.types[1], x.type))
+        self.assertEqual(x.dtype, ndt("complex128"))
 
     def test_var_dim_richcompare(self):
 
@@ -786,13 +847,19 @@ class TestVarDim(XndTestCase):
         x = xnd([[1], [4,5], [6,7,8], [9,10,11,12]])
 
         y = xnd([[1], [6,7,8]])
-        self.assertStrictEqual(x[::2], y)
+        z = x[::2]
+        self.assertStrictEqual(z, y)
+        self.assertFalse(z.type.is_var_contiguous())
 
         y = xnd([[9,10,11,12], [4,5]])
-        self.assertStrictEqual(x[::-2], y)
+        z = x[::-2]
+        self.assertStrictEqual(z, y)
+        self.assertFalse(z.type.is_var_contiguous())
 
         y = xnd([[12,11,10,9], [5,4]])
-        self.assertStrictEqual(x[::-2, ::-1], y)
+        z = x[::-2, ::-1]
+        self.assertStrictEqual(z, y)
+        self.assertFalse(z.type.is_var_contiguous())
 
         # Test corner cases and many dtypes.
         for v, t, u, _, _ in EQUAL_TEST_CASES:
@@ -807,11 +874,15 @@ class TestVarDim(XndTestCase):
                 x = xnd(vv, type=ttt)
                 y = xnd(vv, type=ttt)
                 self.assertStrictEqual(x, y)
+                check_copy_contiguous(self, x)
+                self.check_serialize(x)
 
                 if u is not None:
                     uuu = ndt(uu)
                     y = xnd(vv, type=uuu)
                     self.assertStrictEqual(x, y)
+                    check_copy_contiguous(self, y)
+                    self.check_serialize(y)
 
         for v, t, u, w, eq in EQUAL_TEST_CASES:
             for vv, tt, uu, indices in [
@@ -836,6 +907,8 @@ class TestVarDim(XndTestCase):
                 else:
                     self.assertNotStrictEqual(x, y)
 
+                check_copy_contiguous(self, x)
+
                 if u is not None:
                     uuu = ndt(uu)
                     y = xnd(vv, type=uuu)
@@ -844,6 +917,8 @@ class TestVarDim(XndTestCase):
                     else:
                         self.assertNotStrictEqual(x, y)
 
+                    check_copy_contiguous(self, y)
+
                 if w is not None:
                     y = xnd(vv, type=ttt)
                     y[indices] = w
@@ -853,6 +928,47 @@ class TestVarDim(XndTestCase):
                     y[indices] = w
                     self.assertNotStrictEqual(x, y)
 
+                    check_copy_contiguous(self, y)
+
+    def test_var_dim_nested(self):
+
+        t = "var(offsets=[0,2]) * var(offsets=[0,1,3]) * (var(offsets=[0,2]) * var(offsets=[0,3,7]) * float32, int64)"
+        v = [[([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0, 6.0]], -1)],
+             [([[7.0, 8.0, 9.0], [10.0, 11.0, 12.0, 13.0]], -2),
+              ([[14.0, 15.0, 16.0], [17.0, 18.0, 19.0, 20.0]], -3)]]
+
+        x = xnd(v, type=t)
+
+        self.assertEqual(x, v)
+        self.assertEqual(x.value, v)
+
+        self.assertEqual(x[0], v[0])
+        self.assertEqual(x[1], v[1])
+
+        self.assertEqual(x[0,0], v[0][0])
+        self.assertEqual(x[1,0], v[1][0])
+        self.assertEqual(x[1,1], v[1][1])
+
+        self.assertEqual(x[0,0,0], v[0][0][0])
+        self.assertEqual(x[0,0,1], v[0][0][1])
+
+        self.assertEqual(x[1,0,0], v[1][0][0])
+        self.assertEqual(x[1,0,1], v[1][0][1])
+
+        self.assertEqual(x[1,1,0], v[1][1][0])
+        self.assertEqual(x[1,1,1], v[1][1][1])
+
+        self.assertEqual(x[0,0,0,0], v[0][0][0][0])
+        self.assertEqual(x[0,0,0,1], v[0][0][0][1])
+
+        self.assertEqual(x[0,0,0,0], v[0][0][0][0])
+        self.assertEqual(x[0,0,0,1], v[0][0][0][1])
+
+        self.assertEqual(x[1,0,0,0,1], v[1][0][0][0][1])
+        self.assertEqual(x[1,0,0,0,1], v[1][0][0][0][1])
+
+        check_copy_contiguous(self, x)
+
 
 class TestSymbolicDim(XndTestCase):
 
@@ -925,17 +1041,20 @@ class TestTuple(XndTestCase):
         x[1] = v[1]
         x[2] = v[2]
         self.assertEqual(x.value, v)
+        check_copy_contiguous(self, x)
 
         v = (-2.5+125j, None, None)
         x[0] = v[0]
         x[1] = v[1]
         x[2] = v[2]
         self.assertEqual(x.value, v)
+        check_copy_contiguous(self, x)
 
         x = xnd([("a", 100, 10.5), ("a", 100, 10.5)])
         x[0][1] = 20000000
         self.assertEqual(x[0][1], 20000000)
         self.assertEqual(x[0, 1], 20000000)
+        check_copy_contiguous(self, x)
 
     def test_tuple_overflow(self):
         # Type cannot be created.
@@ -955,6 +1074,7 @@ class TestTuple(XndTestCase):
         lst = [(None, 1, 2), (3, None, 4), (5, 6, None)]
         x = xnd(lst, dtype="(?int64, ?int64, ?int64)")
         self.assertEqual(x.value, lst)
+        self.assertEqual(x.dtype, ndt("(?int64, ?int64, ?int64)"))
 
     def test_tuple_richcompare(self):
 
@@ -998,6 +1118,7 @@ class TestTuple(XndTestCase):
         x = xnd(v, type=t)
         y = xnd(v, type=t)
         self.assertStrictEqual(x, y)
+        check_copy_contiguous(self, x)
 
         w = y[0].value
         y[0] = 11
@@ -1040,6 +1161,7 @@ class TestTuple(XndTestCase):
                 x = xnd(vv, type=ttt)
                 y = xnd(vv, type=ttt)
                 self.assertStrictEqual(x, y)
+                check_copy_contiguous(self, x)
 
                 if u is not None:
                     uuu = ndt(uu)
@@ -1065,6 +1187,8 @@ class TestTuple(XndTestCase):
                 else:
                     self.assertNotStrictEqual(x, y)
 
+                check_copy_contiguous(self, x)
+
                 if u is not None:
                     uuu = ndt(uu)
                     y = xnd(vv, type=uuu)
@@ -1112,6 +1236,7 @@ class TestRecord(XndTestCase):
         x['z'] = v['z']
 
         self.assertEqual(x.value, v)
+        check_copy_contiguous(self, x)
 
         ### Optional data ###
         x = xnd.empty("{x: complex64, y: ?bytes, z: ?string}")
@@ -1121,17 +1246,20 @@ class TestRecord(XndTestCase):
         x['y'] = v['y']
         x['z'] = v['z']
         self.assertEqual(x.value, v)
+        check_copy_contiguous(self, x)
 
         v = R['x': -2.5+125j, 'y': None, 'z': None]
         x['x'] = v['x']
         x['y'] = v['y']
         x['z'] = v['z']
         self.assertEqual(x.value, v)
+        check_copy_contiguous(self, x)
 
         x = xnd([R['x': "abc", 'y': 100, 'z': 10.5]])
         x[0][1] = 20000000
         self.assertEqual(x[0][1], 20000000)
         self.assertEqual(x[0, 1], 20000000)
+        check_copy_contiguous(self, x)
 
     def test_record_overflow(self):
         # Type cannot be created.
@@ -1152,6 +1280,8 @@ class TestRecord(XndTestCase):
                R['a': 5, 'b': 6, 'c': None]]
         x = xnd(lst, dtype="{a: ?int64, b: ?int64, c: ?int64}")
         self.assertEqual(x.value, lst)
+        check_copy_contiguous(self, x)
+        self.assertEqual(x.dtype, ndt("{a: ?int64, b: ?int64, c: ?int64}"))
 
     def test_record_richcompare(self):
 
@@ -1197,12 +1327,14 @@ class TestRecord(XndTestCase):
         x = xnd(v, type=t)
         y = xnd(v, type=t)
         self.assertStrictEqual(x, y)
+        check_copy_contiguous(self, x)
 
         w = y[0].value
         y[0] = 11
         self.assertNotStrictEqual(x, y)
         y[0] = w
         self.assertStrictEqual(x, y)
+        check_copy_contiguous(self, x)
 
         w = y[1].value
         y[1] = "\U00001234\U00001001abx"
@@ -1237,6 +1369,7 @@ class TestRecord(XndTestCase):
                 ttt = ndt(tt)
 
                 x = xnd(vv, type=ttt)
+                check_copy_contiguous(self, x)
 
                 y = xnd(vv, type=ttt)
                 self.assertStrictEqual(x, y)
@@ -1245,6 +1378,7 @@ class TestRecord(XndTestCase):
                     uuu = ndt(uu)
                     y = xnd(vv, type=uuu)
                     self.assertStrictEqual(x, y)
+                    check_copy_contiguous(self, y)
 
         for v, t, u, w, eq in EQUAL_TEST_CASES:
             for vv, tt, uu, indices in [
@@ -1257,6 +1391,7 @@ class TestRecord(XndTestCase):
                 uuu = ndt(uu)
 
                 x = xnd(vv, type=ttt)
+                check_copy_contiguous(self, x)
 
                 y = xnd(vv, type=ttt)
                 if eq:
@@ -1270,11 +1405,490 @@ class TestRecord(XndTestCase):
                         self.assertStrictEqual(x, y)
                     else:
                         self.assertNotStrictEqual(x, y)
+                    check_copy_contiguous(self, y)
 
                 if w is not None:
                     y = xnd(vv, type=ttt)
                     y[indices] = w
                     self.assertNotStrictEqual(x, y)
+                    check_copy_contiguous(self, y)
+
+
+class TestUnion(XndTestCase):
+
+    def test_union_empty(self):
+        for v, s in DTYPE_EMPTY_TEST_CASES:
+            for vv, ss in [
+               (('X', v), "[X of %s]" % s),
+               (('X', {'y': v}), "[X of {y: %s}]" % s),
+
+               (('X', 0 * [v]), "[X of 0 * %s]" % s),
+               (('X', {'y': 0 * [v]}), "[X of {y: 0 * %s}]" % s),
+               (('X', 1 * [v]), "[X of 1 * %s]" % s),
+               (('X', 3 * [v]), "[X of 3 * %s]" % s),
+               (('X', 3 * [v]), "[X of 3 * %s | Y of complex128]" % s)]:
+
+                if "ref" in ss or "&" in ss:
+                    # unsupported types for union members
+                    continue
+
+                t = ndt(ss)
+                x = xnd.empty(ss)
+                self.assertEqual(x.type, t)
+                self.assertEqual(x.value, vv)
+
+    def test_union_assign(self):
+        ### Regular data ###
+        x = xnd.empty("[X of complex64 | Y of bytes | Z of string]")
+
+        v = ('X', 1+20j)
+        x[()] = v
+        self.assertEqual(x.value, v)
+        check_copy_contiguous(self, x)
+
+        v = ('Y', b"abc")
+        x[()] = v
+        self.assertEqual(x.value, v)
+        check_copy_contiguous(self, x)
+
+        v = ('Z', "abc")
+        x[()] = v
+        self.assertEqual(x.value, v)
+        check_copy_contiguous(self, x)
+
+    def test_union_indexing(self):
+        ### Regular data ###
+        x = xnd.empty("[X of complex64 | Y of bytes | Z of string]")
+
+        v = ('X', 1+20j)
+        x[()] = v
+        self.assertEqual(x[0], v[1])
+        self.assertEqual(x['X'], v[1])
+        self.assertRaises(ValueError, x.__getitem__, 1)
+        self.assertRaises(ValueError, x.__getitem__, 'Y')
+        self.assertRaises(ValueError, x.__getitem__, 2)
+        self.assertRaises(ValueError, x.__getitem__, 'Z')
+        self.assertRaises(ValueError, x.__getitem__, -1)
+        self.assertRaises(IndexError, x.__getitem__, 3)
+        self.assertRaises(ValueError, x.__getitem__, 'A')
+
+    def test_union_overflow(self):
+        # Type cannot be created.
+        s = "[a: 4611686018427387904 * uint8, b: 4611686018427387904 * uint8}"
+        self.assertRaises(ValueError, xnd.empty, s)
+
+        if HAVE_64_BIT:
+            # Allocation fails.
+            s = "[A of 2 * uint8 | B of 9223372036854775808 * uint8]"
+            self.assertRaises(ValueError, xnd.empty, s)
+        else:
+            # Allocation fails.
+            s = "[A of 2 * uint8 | B of 2147483648 * uint8}"
+            self.assertRaises(ValueError, xnd.empty, s)
+
+    def test_union_optional_values(self):
+        lst = [('A', None), ('B', 10), ('C', (None, "abc"))]
+        x = xnd(lst, dtype="[A of ?int64 | B of int64 | C of (?int64, string)]")
+        self.assertEqual(x.value, lst)
+        check_copy_contiguous(self, x)
+        self.assertEqual(x.dtype, ndt("[A of ?int64 | B of int64 | C of (?int64, string)]"))
+
+    def test_union_richcompare(self):
+
+        # Simple tests.
+        x = xnd(('Record', R['a': 1, 'b': 2.0, 'c': "3", 'd': b"123"]),
+                type="[Int of int64 | Record of {a: uint8, b: float32, c: string, d: bytes}]")
+
+        self.assertIs(x.__lt__(x), NotImplemented)
+        self.assertIs(x.__le__(x), NotImplemented)
+        self.assertIs(x.__gt__(x), NotImplemented)
+        self.assertIs(x.__ge__(x), NotImplemented)
+
+        y = x.copy_contiguous()
+        self.assertStrictEqual(x, y)
+
+        self.assertNotStrictEqual(x, xnd(R['z': 1, 'b': 2.0, 'c': "3", 'd': b"123"]))
+        self.assertNotStrictEqual(x, xnd(R['a': 2, 'b': 2.0, 'c': "3", 'd': b"123"]))
+        self.assertNotStrictEqual(x, xnd(R['a': 1, 'b': 2.1, 'c': "3", 'd': b"123"]))
+        self.assertNotStrictEqual(x, xnd(R['a': 1, 'b': 2.0, 'c': "", 'd': b"123"]))
+        self.assertNotStrictEqual(x, xnd(R['a': 1, 'b': 2.0, 'c': "345", 'd': "123"]))
+        self.assertNotStrictEqual(x, xnd(R['a': 1, 'b': 2.0, 'c': "3", 'd': b""]))
+        self.assertNotStrictEqual(x, xnd(R['a': 1, 'b': 2.0, 'c': "3", 'd': b"12345"]))
+
+        # Nested structures.
+        t = """
+            {a: uint8,
+             b: fixed_string(100, 'utf32'),
+             c: {x: complex128,
+                 y: 2 * 3 * {v: [Int of int64 | Tuple of (bytes, string)],
+                             u: bytes}},
+             d: ref(string)}
+            """
+
+        v = R['a': 10,
+              'b': "\U00001234\U00001001abc",
+              'c': R['x': 12.1e244+3j,
+                     'y': [[R['v': ('Tuple', (b"123", "456")), 'u': 10 * b"22"],
+                            R['v': ('Int', 10), 'u': 10 * b"23"],
+                            R['v': ('Int', 20), 'u': 10 * b"24"]],
+                           [R['v': ('Int', 30), 'u': b"a"],
+                            R['v': ('Tuple', (b"01234", "56789")), 'u': b"ab"],
+                            R['v': ('Tuple', (b"", "")), 'u': b"abc"]]]],
+              'd': "xyz"]
+
+        x = xnd(v, type=t)
+        y = xnd(v, type=t)
+        self.assertStrictEqual(x, y)
+        check_copy_contiguous(self, x)
+
+        w = y['c', 'y', 0, 0, 'v'].value
+        y['c', 'y', 0, 0, 'v'] = ('Int', 12345)
+        self.assertNotStrictEqual(x, y)
+        y['c', 'y', 0, 0, 'v'] = w
+        self.assertStrictEqual(x, y)
+        check_copy_contiguous(self, x)
+
+        # Test corner cases and many dtypes.
+        for v, t, u, _, _ in EQUAL_TEST_CASES:
+            for vv, tt, uu in [
+               (('Some', 0 * [v]), "[Int of int64 | Some of 0 * %s]" % t, "[Int of int64 | Some of 0 * %s]" % u),
+               (('Some', {'y': 0 * [v]}), "[Float of float16 | Some of {y: 0 * %s}]" % t, "[Float of float16 | Some of {y: 0 * %s}]" % u)]:
+
+                if "ref" in tt or "&" in tt:
+                    # unsupported types for union members
+                    continue
+
+                if "ref" in uu or "&" in uu:
+                    # unsupported types for union members
+                    continue
+
+                ttt = ndt(tt)
+
+                x = xnd(vv, type=ttt)
+                check_copy_contiguous(self, x)
+
+                y = xnd(vv, type=ttt)
+                self.assertStrictEqual(x, y)
+
+                if u is not None:
+                    uuu = ndt(uu)
+                    y = xnd(vv, type=uuu)
+                    self.assertStrictEqual(x, y)
+                    check_copy_contiguous(self, y)
+
+        for v, t, u, w, eq in EQUAL_TEST_CASES:
+            for vv, tt, uu, indices in [
+               (('Some', v), "[Some of %s]" % t, "[Some of %s]" % u, (0,)),
+               (('Some', 3 * [v]), "[Some of 3 * %s]" % t, "[Some of 3 * %s]" % u, (0, 2))]:
+
+                if "ref" in tt or "&" in tt:
+                    # unsupported types for union members
+                    continue
+
+                if "ref" in uu or "&" in uu:
+                    # unsupported types for union members
+                    continue
+
+                ttt = ndt(tt)
+                uuu = ndt(uu)
+
+                x = xnd(vv, type=ttt)
+                check_copy_contiguous(self, x)
+
+                y = xnd(vv, type=ttt)
+                if eq:
+                    self.assertStrictEqual(x, y)
+                else:
+                    self.assertNotStrictEqual(x, y)
+
+                if u is not None:
+                    y = xnd(vv, type=uuu)
+                    if eq:
+                        self.assertStrictEqual(x, y)
+                    else:
+                        self.assertNotStrictEqual(x, y)
+                    check_copy_contiguous(self, y)
+
+
+class TestArray(XndTestCase):
+
+    def test_array_empty(self):
+        for v, s in DTYPE_EMPTY_TEST_CASES:
+            for _, ss in [
+               (0 * [v], "array * %s" % s),
+               (1 * [v], "array * %s" % s),
+               (2 * [v], "array * %s" % s),
+               (1000 * [v], "array * %s" % s),
+
+               (0 * [0 * [v]], "array * array * %s" % s),
+               (0 * [1 * [v]], "array * array * %s" % s),
+               (1 * [0 * [v]], "array * array * %s" % s),
+
+               (1 * [1 * [v]], "array * array * %s" % s),
+               (1 * [2 * [v]], "array * array * %s" % s),
+               (2 * [1 * [v]], "array * array * %s" % s),
+               (2 * [2 * [v]], "array * array * %s" % s),
+               (2 * [3 * [v]], "array * array * %s" % s),
+               (3 * [2 * [v]], "array * array * %s" % s),
+               (3 * [40 * [v]], "array * array * %s" % s)]:
+
+                if "?" in ss or "ref" in ss or "&" in ss:
+                    continue
+
+                t = ndt(ss)
+                x = xnd.empty(ss)
+                self.assertEqual(x.type, t)
+                self.assertEqual(x.value, [])
+                self.assertEqual(len(x), len([]))
+                self.assertFalse(x.type.is_c_contiguous())
+
+    def test_array_subscript(self):
+        test_cases = [
+            ([[11.12-2.3j, -1222+20e8j],
+              [complex("inf"), -0.00002j],
+              [0.201+1j, -1+1e301j]], "array * array * complex128"),
+        ]
+
+        for v, s in test_cases:
+            nd = NDArray(v)
+            t = ndt(s)
+            x = xnd(v, type=t)
+            self.assertFalse(x.type.is_c_contiguous())
+
+            for i in range(3):
+                self.assertEqual(x[i].value, nd[i])
+
+            for i in range(3):
+                for k in range(2):
+                    self.assertEqual(x[i][k], nd[i][k])
+                    self.assertEqual(x[i, k], nd[i][k])
+
+            self.assertEqual(x[()].value, nd[:])
+
+    def test_array_assign(self):
+        x = xnd.empty("array * array * float64")
+        v = [[0.0, 1.0, 2.0, 3.0], [4.0, 5.0, 6.0, 7.0]]
+
+        # Full slice
+        x[()] = v
+        self.assertEqual(x.value, v)
+
+        # Subarray, variable shapes
+        x[0] = v[0] = [1.2, -3e45, float("inf")]
+        self.assertEqual(x.value, v)
+
+        x[1] = v[1] = [-11.25, 3.355e301, -0.000002, -5000.2, -322.25]
+        self.assertEqual(x.value, v)
+
+        # Subarray, fixed shapes
+        x[0] = v[0] = [1.2, -3e45, float("inf"), -322.25]
+        self.assertEqual(x.value, v)
+
+        x[1] = v[1] = [-11.25, 3.355e301, -0.000002, -5000.2]
+        self.assertEqual(x.value, v)
+
+        # Single values
+        for i in range(2):
+            for j in range(4):
+                x[i][j] = v[i][j] = 3.22 * i + j
+        self.assertEqual(x.value, v)
+
+        # Tuple indexing
+        for i in range(2):
+            for j in range(4):
+                x[i, j] = v[i][j] = -3.002e1 * i + j
+        self.assertEqual(x.value, v)
+
+    def test_array_richcompare(self):
+
+        x = xnd([1,2,3,4], type="array * int64")
+
+        self.assertIs(x.__lt__(x), NotImplemented)
+        self.assertIs(x.__le__(x), NotImplemented)
+        self.assertIs(x.__gt__(x), NotImplemented)
+        self.assertIs(x.__ge__(x), NotImplemented)
+
+        self.assertStrictEqual(x, xnd([1,2,3,4], type="array * int64"))
+
+        # Different type, shape and/or data.
+        self.assertNotStrictEqual(x, xnd([1,2,3,100]))
+        self.assertNotStrictEqual(x, xnd([1,2,3,100], type="array * int64"))
+        self.assertNotStrictEqual(x, xnd([1,2,3], type="array * int64"))
+        self.assertNotStrictEqual(x, xnd([1,2,3,4,5], type="array * int64"))
+
+        self.assertStrictEqual(x[()], x)
+
+        # Simple multidimensional arrays.
+        x = xnd([[1,2,3], [4,5,6], [7,8,9], [10,11,12]], type="array * array * int64")
+        y = xnd([[1,2,3], [4,5,6], [7,8,9], [10,11,12]], type="array * array * int64")
+        self.assertStrictEqual(x, y)
+
+        for i in range(4):
+            for k in range(3):
+                v = y[i, k]
+                y[i, k] = 100
+                self.assertNotStrictEqual(x, y)
+                y[i, k] = v
+
+        # Flexible multidimensional arrays.
+        x = xnd([[1], [4,5], [7,8,9]], type="array * array * int64")
+        y = xnd([[1], [4,5], [7,8,9]], type="array * array * int64")
+        self.assertStrictEqual(x, y)
+
+        for i in range(3):
+            v = y[i, 0]
+            y[i, 0] = 100
+            self.assertNotStrictEqual(x, y)
+            y[i, 0] = v
+
+        # Test corner cases and many dtypes.
+        for v, t, u, _, _ in EQUAL_TEST_CASES:
+            for vv, tt, uu in [
+               (0 * [v], "array * %s" % t, "array * %s" % u),
+               (0 * [0 * [v]], "array * array * %s" % t, "array * array * %s" % u),
+               (0 * [1 * [v]], "array * array * %s" % t, "array * array * %s" % u),
+               (1 * [0 * [v]], "array * array * %s" % t, "array * array * %s" % u)]:
+
+                if "?" in tt or "ref" in tt or "&" in tt:
+                    continue
+                if "?" in uu or "ref" in uu or "&" in uu:
+                    continue
+
+                ttt = ndt(tt)
+
+                x = xnd(vv, type=ttt)
+                y = xnd(vv, type=ttt)
+                self.assertStrictEqual(x, y)
+
+                if u is not None:
+                    uuu = ndt(uu)
+                    y = xnd(vv, type=uuu)
+                    self.assertStrictEqual(x, y)
+
+        for v, t, u, w, eq in EQUAL_TEST_CASES:
+            for vv, tt, uu, indices in [
+               (1 * [v], "array * %s" % t, "array * %s" % u, (0,)),
+               (2 * [v], "array * %s" % t, "array * %s" % u, (1,)),
+               (1000 * [v], "array * %s" % t, "array * %s" % u, (961,))]:
+
+                if "?" in tt or "ref" in tt or "&" in tt:
+                    continue
+                if "?" in uu or "ref" in uu or "&" in uu:
+                    continue
+
+                ttt = ndt(tt)
+                uuu = ndt(uu)
+
+                x = xnd(vv, type=ttt)
+
+                y = xnd(vv, type=ttt)
+                if eq:
+                    self.assertStrictEqual(x, y)
+                else:
+                    self.assertNotStrictEqual(x, y)
+
+                if u is not None:
+                    y = xnd(vv, type=uuu)
+                    if eq:
+                        self.assertStrictEqual(x, y)
+                    else:
+                        self.assertNotStrictEqual(x, y)
+
+                if w is not None:
+                    y = xnd(vv, type=ttt)
+                    y[indices] = w
+                    self.assertNotStrictEqual(x, y)
+
+                    y = xnd(vv, type=uuu)
+                    y[indices] = w
+                    self.assertNotStrictEqual(x, y)
+
+    def test_array_equal(self):
+        x = xnd([1,2,3], type='array * int64')
+        y = xnd([1,2,3], type='array * float32')
+
+        self.assertEqual(x, y)
+        self.assertNotStrictEqual(x, y)
+
+    def test_array_geojson_tuple(self):
+        v = { "type": "FeatureCollection",
+              "features": (
+                 { "type": "Feature",
+                   "geometry": { "type": "Point",
+                                 "coordinates": [110.0, 0.7] },
+                   "properties": {"prop0": "value0"} },
+                 { "type": "Feature",
+                   "geometry": { "type": "LineString",
+                                 "coordinates": [[102.1, 0.1], [103.2, 1.1], [104.3, 0.1], [105.5, 1.1]] },
+                   "properties": {"prop0": "value0", "prop1": 0} }
+              ),
+            }
+
+        t = """
+              { type: string,
+                features: (
+                  { type: string,
+                    geometry: { type: string,
+                                coordinates: array * float64 },
+                    properties: { prop0: string } },
+                  { type: string,
+                    geometry: { type: string,
+                                coordinates: array * array * float64 },
+                    properties: { prop0: string, prop1: int64 } }
+                )
+              }
+            """
+
+        x = xnd(v, type=t)
+
+        p = [110.0, 0.7]
+        ls = [[102.1, 0.1], [103.2, 1.1], [104.3, 0.1], [105.5, 1.1]]
+
+        self.assertEqual(x['features', 0, 'geometry', 'coordinates'], p)
+        self.assertEqual(x['features', 1, 'geometry', 'coordinates'],  ls)
+
+        p = [110.0, 0.7, 1.1, 200]
+        ls = [[102.1, 0.1], [103.2, 1.1], [104.3, 0.1], [105.5, 1.1], [107, 1.2]]
+        x['features', 0, 'geometry', 'coordinates'] = p
+        x['features', 1, 'geometry', 'coordinates'] = ls
+
+        self.assertEqual(x['features', 0, 'geometry', 'coordinates', 3], 200)
+        self.assertEqual(x['features', 1, 'geometry', 'coordinates', 4, 1], 1.2)
+
+    def test_array_geojson_union(self):
+        typedef("id",
+          """[
+            String of string
+          | Int of int64
+          ]""")
+
+        typedef("position", "array * float64")
+
+        typedef("geometry",
+          """[
+            Point of position
+          | MultiPoint of array * position
+          | LineString of array * position
+          | MultiLineString of array * array * position
+          | Polygon of array * position
+          | MultiPolygon of array * array * position
+          ]""")
+
+        v = [ ("Point", [110.0, 0.7]),
+              ("LineString", [[102.1, 0.1], [103.2, 1.1], [104.3, 0.1], [105.5, 1.1]])]
+
+        x = xnd(v, type="array * geometry")
+
+        p = [110.0, 0.7]
+        ls = [[102.1, 0.1], [103.2, 1.1], [104.3, 0.1], [105.5, 1.1]]
+
+        self.assertEqual(x[0, 'Point'], p)
+        self.assertEqual(x[1, 'LineString'],  ls)
+
+        p = [110.0, 0.7, 1.1, 200]
+        ls = [[102.1, 0.1], [103.2, 1.1], [104.3, 0.1], [105.5, 1.1], [107, 1.2]]
+        x[0, 'Point'] = p
+        x[1, 'LineString'] = ls
 
 
 class TestRef(XndTestCase):
@@ -1327,6 +1941,8 @@ class TestRef(XndTestCase):
         v = 2 * [3 * [inner]]
 
         x = xnd(v, type="2 * 3 * ref(4 * 5 * string)")
+        check_copy_contiguous(self, x)
+        self.assertEqual(x.dtype, ndt("ref(4 * 5 * string)"))
 
         for i in range(2):
             for j in range(3):
@@ -1334,6 +1950,7 @@ class TestRef(XndTestCase):
                     for l in range(5):
                         self.assertEqual(x[i][j][k][l], inner[k][l])
                         self.assertEqual(x[i, j, k, l], inner[k][l])
+                        check_copy_contiguous(self, x[i, j, k, l])
 
     def test_ref_assign(self):
         # If a ref is a dtype but contains an array itself, assigning through
@@ -1388,6 +2005,7 @@ class TestRef(XndTestCase):
                 ttt = ndt(tt)
 
                 x = xnd(vv, type=ttt)
+                check_copy_contiguous(self, x)
 
                 y = xnd(vv, type=ttt)
                 self.assertStrictEqual(x, y)
@@ -1472,6 +2090,7 @@ class TestConstr(XndTestCase):
         v = 2 * [3 * [inner]]
 
         x = xnd(v, type="2 * 3 * InnerArray(4 * 5 * string)")
+        check_copy_contiguous(self, x)
 
         for i in range(2):
             for j in range(3):
@@ -1479,6 +2098,7 @@ class TestConstr(XndTestCase):
                     for l in range(5):
                         self.assertEqual(x[i][j][k][l], inner[k][l])
                         self.assertEqual(x[i, j, k, l], inner[k][l])
+                        check_copy_contiguous(self, x[i, j, k, l])
 
     def test_constr_assign(self):
         # If a constr is a dtype but contains an array itself, assigning through
@@ -1622,6 +2242,7 @@ class TestNominal(XndTestCase):
         v = 2 * [3 * [inner]]
 
         x = xnd(v, type="2 * 3 * inner")
+        check_copy_contiguous(self, x)
 
         for i in range(2):
             for j in range(3):
@@ -1731,6 +2352,7 @@ class TestCategorical(XndTestCase):
     def test_categorical_richcompare(self):
         t = "3 * categorical(NA, 'January', 'August')"
         x = xnd(['August', 'January', 'January'], type=t)
+        check_copy_contiguous(self, x)
 
         y = xnd(['August', 'January', 'January'], type=t)
         self.assertStrictEqual(x, y)
@@ -1773,12 +2395,14 @@ class TestFixedString(XndTestCase):
         v = ["\u1111\u2222\u3333", "\u1112\u2223\u3334"]
         x = xnd(v, type=t)
         self.assertEqual(x.value, v)
+        check_copy_contiguous(self, x)
 
 
         t = "2 * fixed_string(3, 'utf32')"
         v = ["\U00011111\U00022222\U00033333", "\U00011112\U00022223\U00033334"]
         x = xnd(v, type=t)
         self.assertEqual(x.value, v)
+        check_copy_contiguous(self, x)
 
     def test_fixed_string_assign(self):
         t = "2 * fixed_string(3, 'utf32')"
@@ -1826,6 +2450,7 @@ class TestFixedString(XndTestCase):
             self.assertStrictEqual(x, y)
             y[()] = w
             self.assertNotStrictEqual(x, y)
+            check_copy_contiguous(self, x)
 
 
 class TestFixedBytesKind(XndTestCase):
@@ -1861,7 +2486,7 @@ class TestFixedBytes(XndTestCase):
 
         x[0] = b"xyz"
         self.assertEqual(x.value, [b"xyz", b"123"])
-
+        check_copy_contiguous(self, x)
 
         t = "2 * fixed_bytes(size=3, align=1)"
         v = [b"abc", b"123"]
@@ -1941,6 +2566,7 @@ class TestString(XndTestCase):
 
         self.assertEqual(x[0]['b'], "thisguy")
         self.assertEqual(x[1]['b'], "thatguy")
+        check_copy_contiguous(self, x)
 
     def test_string_assign(self):
         t = '2 * {a: complex128, b: string}'
@@ -1987,6 +2613,8 @@ class TestBytes(XndTestCase):
         v = 2 * [inner]
 
         x = xnd(v, type=t)
+        check_copy_contiguous(self, x)
+
         for i in range(2):
             for k in range(3):
                 x[i, k] = inner[k] = bytes(chr(ord('x') + k), "ascii")
@@ -2009,9 +2637,11 @@ class TestBool(XndTestCase):
         # From bool.
         x = xnd(True, type="bool")
         self.assertIs(x.value, True)
+        check_copy_contiguous(self, x)
 
         x = xnd(False, type="bool")
         self.assertIs(x.value, False)
+        check_copy_contiguous(self, x)
 
         # From int.
         x = xnd(1, type="bool")
@@ -2023,6 +2653,7 @@ class TestBool(XndTestCase):
         # From object (for numpy compat: np.bool([1,2,3]))
         x = xnd([1,2,3], type="bool")
         self.assertIs(x.value, True)
+        check_copy_contiguous(self, x)
 
         x = xnd(None, type="?bool")
         self.assertIs(x.value, None)
@@ -2074,6 +2705,7 @@ class TestSigned(XndTestCase):
             t = "int%d" % n
             x = xnd(i, type=t)
             self.assertEqual(x.value, 10)
+            check_copy_contiguous(self, x)
 
         # Test broken input.
         for n in (8, 16, 32, 64):
@@ -2123,6 +2755,7 @@ class TestUnsigned(XndTestCase):
             t = "uint%d" % n
             x = xnd(i, type=t)
             self.assertEqual(x.value, 10)
+            check_copy_contiguous(self, x)
 
         # Test broken input.
         for n in (8, 16, 32, 64):
@@ -2151,6 +2784,63 @@ class TestFloatKind(XndTestCase):
 
 class TestFloat(XndTestCase):
 
+    def test_bfloat16(self):
+        fromhex = float.fromhex
+
+        # Test bounds.
+        DENORM_MIN = fromhex("0x1p-133")
+        LOWEST = fromhex("-0x1.fep127")
+        MAX = fromhex("0x1.fep127")
+
+        x = xnd(DENORM_MIN, type="bfloat16")
+        self.assertEqual(x.value, DENORM_MIN)
+        check_copy_contiguous(self, x)
+
+        x = xnd(LOWEST, type="bfloat16")
+        self.assertEqual(x.value, LOWEST)
+        check_copy_contiguous(self, x)
+
+        x = xnd(MAX, type="bfloat16")
+        self.assertEqual(x.value, MAX)
+        check_copy_contiguous(self, x)
+
+        # Test special values.
+        x = xnd(float("inf"), type="bfloat16")
+        self.assertTrue(isinf(x.value))
+
+        x = xnd(float("nan"), type="bfloat16")
+        self.assertTrue(isnan(x.value))
+
+        # Richcompare.
+        self.assertStrictEqual(xnd(1.2e7, type="bfloat16"), xnd(1.2e7, type="bfloat16"))
+        self.assertStrictEqual(xnd(float("inf"), type="bfloat16"), xnd(float("inf"), type="bfloat16"))
+        self.assertStrictEqual(xnd(float("-inf"), type="bfloat16"), xnd(float("-inf"), type="bfloat16"))
+
+        self.assertNotStrictEqual(xnd(1.2e7, type="bfloat16"), xnd(-1.2e7, type="bfloat16"))
+        self.assertNotStrictEqual(xnd(float("inf"), type="bfloat16"), xnd(float("-inf"), type="bfloat16"))
+        self.assertNotStrictEqual(xnd(float("-inf"), type="bfloat16"), xnd(float("inf"), type="bfloat16"))
+        self.assertNotStrictEqual(xnd(float("nan"), type="bfloat16"), xnd(float("nan"), type="bfloat16"))
+
+    def test_bfloat16_compare_tf(self):
+        TEST_CASES = [
+          ("0x1p-133", 9.183549615799121e-41),
+          ("0x1p-134", 0.0),
+          ("0x0.1p-134", 0.0),
+          ("-0x1.fep127", -3.3895313892515355e+38),
+          ("-0x1.fep128", float("-inf")),
+          ("0x1.fep127", 3.3895313892515355e+38),
+          ("0x1.fep128", float("inf")),
+          ("-0x2", -2.0),
+          ("-0x1.1", -1.0625),
+          ("-0x1.12345p22", -4489216.0),
+          ("0x7.2p37", 979252543488.0)]
+
+        for s, ans in TEST_CASES:
+            d = float.fromhex(s)
+            x = xnd(d, type="bfloat16")
+            self.assertEqual(x, ans)
+            self.assertEqual(x.value, ans)
+
     @requires_py36
     def test_float16(self):
         fromhex = float.fromhex
@@ -2170,12 +2860,15 @@ class TestFloat(XndTestCase):
 
         x = xnd(DENORM_MIN, type="float16")
         self.assertEqual(x.value, DENORM_MIN)
+        check_copy_contiguous(self, x)
 
         x = xnd(LOWEST, type="float16")
         self.assertEqual(x.value, LOWEST)
+        check_copy_contiguous(self, x)
 
         x = xnd(MAX, type="float16")
         self.assertEqual(x.value, MAX)
+        check_copy_contiguous(self, x)
 
         self.assertRaises(OverflowError, xnd, INF, type="float16")
         self.assertRaises(OverflowError, xnd, -INF, type="float16")
@@ -2208,12 +2901,15 @@ class TestFloat(XndTestCase):
 
         x = xnd(DENORM_MIN, type="float32")
         self.assertEqual(x.value, DENORM_MIN)
+        check_copy_contiguous(self, x)
 
         x = xnd(LOWEST, type="float32")
         self.assertEqual(x.value, LOWEST)
+        check_copy_contiguous(self, x)
 
         x = xnd(MAX, type="float32")
         self.assertEqual(x.value, MAX)
+        check_copy_contiguous(self, x)
 
         self.assertRaises(OverflowError, xnd, INF, type="float32")
         self.assertRaises(OverflowError, xnd, -INF, type="float32")
@@ -2245,12 +2941,15 @@ class TestFloat(XndTestCase):
 
         x = xnd(DENORM_MIN, type="float64")
         self.assertEqual(x.value, DENORM_MIN)
+        check_copy_contiguous(self, x)
 
         x = xnd(LOWEST, type="float64")
         self.assertEqual(x.value, LOWEST)
+        check_copy_contiguous(self, x)
 
         x = xnd(MAX, type="float64")
         self.assertEqual(x.value, MAX)
+        check_copy_contiguous(self, x)
 
         # Test special values.
         x = xnd(float("inf"), type="float64")
@@ -2298,14 +2997,17 @@ class TestComplex(XndTestCase):
         v = complex(DENORM_MIN, DENORM_MIN)
         x = xnd(v, type="complex32")
         self.assertEqual(x.value, v)
+        check_copy_contiguous(self, x)
 
         v = complex(LOWEST, LOWEST)
         x = xnd(v, type="complex32")
         self.assertEqual(x.value, v)
+        check_copy_contiguous(self, x)
 
         v = complex(MAX, MAX)
         x = xnd(v, type="complex32")
         self.assertEqual(x.value, v)
+        check_copy_contiguous(self, x)
 
         v = complex(INF, INF)
         self.assertRaises(OverflowError, xnd, v, type="complex32")
@@ -2348,14 +3050,17 @@ class TestComplex(XndTestCase):
         v = complex(DENORM_MIN, DENORM_MIN)
         x = xnd(v, type="complex64")
         self.assertEqual(x.value, v)
+        check_copy_contiguous(self, x)
 
         v = complex(LOWEST, LOWEST)
         x = xnd(v, type="complex64")
         self.assertEqual(x.value, v)
+        check_copy_contiguous(self, x)
 
         v = complex(MAX, MAX)
         x = xnd(v, type="complex64")
         self.assertEqual(x.value, v)
+        check_copy_contiguous(self, x)
 
         v = complex(INF, INF)
         self.assertRaises(OverflowError, xnd, INF, type="complex64")
@@ -2401,10 +3106,12 @@ class TestComplex(XndTestCase):
         v = complex(LOWEST, LOWEST)
         x = xnd(v, type="complex128")
         self.assertEqual(x.value, v)
+        check_copy_contiguous(self, x)
 
         v = complex(MAX, MAX)
         x = xnd(v, type="complex128")
         self.assertEqual(x.value, v)
+        check_copy_contiguous(self, x)
 
         # Test special values.
         x = xnd(complex("inf"), type="complex128")
@@ -2441,6 +3148,7 @@ class TestPrimitive(XndTestCase):
                 x = xnd.empty(ts)
                 self.assertEqual(x.value, value)
                 self.assertEqual(x.type, ndt(ts))
+                check_copy_contiguous(self, x)
 
 
 class TestTypevar(XndTestCase):
@@ -2453,6 +3161,93 @@ class TestTypevar(XndTestCase):
 
 class TestTypeInference(XndTestCase):
 
+    def test_data_shape_extraction(self):
+
+        test_cases = [
+            (None, [None], []),
+            (1, [1], []),
+            ((1, 2), [(1, 2)], []),
+            ([], [], [[0]]),
+            ([None], [None], [[1]]),
+            ([1], [1], [[1]]),
+            ([()], [()], [[1]]),
+            ([(1, 2)], [(1, 2)], [[1]]),
+            ([[]], [], [[0], [1]]),
+            ([[None]], [None], [[1], [1]]),
+            ([[None, 1]], [None, 1], [[2], [1]]),
+            ([[1, None]], [1, None], [[2], [1]]),
+            ([None, []], [], [[None, 0], [2]]),
+            ([[], None], [], [[0, None], [2]]),
+            ([[None], None], [None], [[1, None], [2]]),
+            ([None, [None]], [None], [[None, 1], [2]]),
+            ([None, [1]], [1], [[None, 1], [2]]),
+            ([[1], None], [1], [[1, None], [2]]),
+            ([[], []], [], [[0, 0], [2]]),
+            ([[1], []], [1], [[1, 0], [2]]),
+            ([[], [1]], [1], [[0, 1], [2]]),
+            ([[1], [2]], [1, 2], [[1, 1], [2]]),
+            ([[2], [1]], [2, 1], [[1, 1], [2]]),
+            ([[1], [2, 3]], [1, 2, 3], [[1, 2], [2]]),
+            ([[1, 2], [3]], [1, 2, 3], [[2, 1], [2]]),
+            ([None, [1], [2, 3]], [1, 2, 3], [[None, 1, 2], [3]]),
+            ([[1], None, [2, 3]], [1, 2, 3], [[1, None, 2], [3]]),
+            ([[1], [2, 3], None], [1, 2, 3], [[1, 2, None], [3]]),
+            ([None, [[1], []], [[2, 3]]], [1, 2, 3], [[1, 0, 2], [None, 2, 1], [3]]),
+            ([[[1], []], None, [[2, 3]]], [1, 2, 3], [[1, 0, 2], [ 2, None, 1], [3]]),
+            ([[[1], []], [[2, 3]], None], [1, 2, 3], [[1, 0, 2], [2, 1, None], [3]]),
+        ]
+
+        for v, expected_data, expected_shapes in test_cases:
+            data, shapes = data_shapes(v)
+            self.assertEqual(data, expected_data)
+            self.assertEqual(shapes, expected_shapes)
+
+        v = [1]
+        for i in range(127):
+            v = [v]
+        data, shapes = data_shapes(v)
+        self.assertEqual(data, [1])
+        self.assertEqual(shapes, [[1]] * 128)
+
+        # Exceptions:
+        v = [1, []]
+        self.assertRaises(ValueError, data_shapes, v)
+
+        v = [[], 1]
+        self.assertRaises(ValueError, data_shapes, v)
+
+        v = [[[1,2]], [3, 4]]
+        self.assertRaises(ValueError, data_shapes, v)
+
+        v = [[1, 2], [[3, 4]]]
+        self.assertRaises(ValueError, data_shapes, v)
+
+        v = [1]
+        for i in range(128):
+            v = [v]
+        self.assertRaises(ValueError, data_shapes, v)
+
+    def test_fixed_dimension(self):
+        d = [(None, 10), (None, 20), ("x", 30)]
+        typeof_d = "3 * (?string, int64)"
+
+        test_cases = [
+          ((), "()"),
+          (((),), "(())"),
+          (((), ()), "((), ())"),
+          ((((),), ()), "((()), ())"),
+          ((((),), ((), ())), "((()), ((), ()))"),
+          ((1, 2, 3), "(int64, int64, int64)"),
+          ((1.0, 2, "str"), "(float64, int64, string)"),
+          ((1.0, 2, ("str", b"bytes", d)),
+           "(float64, int64, (string, bytes, %s))" % typeof_d)
+        ]
+
+        for v, t in test_cases:
+            x = xnd(v)
+            self.assertEqual(x.type, ndt(t))
+            self.assertEqual(x.value, v)
+
     def test_tuple(self):
         d = R['a': (2.0, b"bytes"), 'b': ("str", float('inf'))]
         typeof_d = "{a: (float64, bytes), b: (string, float64)}"
@@ -2492,6 +3287,25 @@ class TestTypeInference(XndTestCase):
             self.assertEqual(x.type, ndt(t))
             self.assertEqual(x.value, v)
 
+    def test_bool(self):
+        t = [True, None, False]
+        typeof_t = "3 * ?bool"
+
+        test_cases = [
+          ([0], "1 * int64"),
+          ([0, 1], "2 * int64"),
+          ([[0], [1]], "2 * 1 * int64"),
+
+          (t, typeof_t),
+          ([t] * 2, "2 * %s" % typeof_t),
+          ([[t] * 2] * 10, "10 * 2 * %s" % typeof_t)
+        ]
+
+        for v, t in test_cases:
+            x = xnd(v)
+            self.assertEqual(x.type, ndt(t))
+            self.assertEqual(x.value, v)
+
     def test_float64(self):
         d = R['a': 2.221e100, 'b': float('inf')]
         typeof_d = "{a: float64, b: float64}"
@@ -2760,21 +3574,12 @@ class TestBuffer(XndTestCase):
         x = np.array([(1000, 400.25, 'abc'), (-23, -1e10, 'cba')],
                      dtype=[('x', 'i4'), ('y', 'f4'), ('z', 'S3')])
         y = xnd.from_buffer(x)
+        check_copy_contiguous(self, y)
 
         for i in range(2):
             for k in ['x', 'y', 'z']:
                 self.assertEqual(y[i][k], x[i][k])
 
-    @unittest.skipIf(np is None, "numpy not found")
-    def test_unsafe_from_buffer(self):
-        x = np.array([[[0,1,2],
-                       [3,4,5]],
-                     [[6,7,8],
-                      [9,10,11]]], dtype="int64")
-
-        y = xnd.unsafe_from_data(obj=x, type="12 * int64")
-        np.testing.assert_equal(y, x.reshape(12))
-
     @unittest.skipIf(np is None, "numpy not found")
     def test_endian(self):
         standard = [
@@ -2783,10 +3588,11 @@ class TestBuffer(XndTestCase):
             'h', 'i', 'l', 'q',
             'H', 'I', 'L', 'Q',
             'f', 'd',
+            'F', 'D',
         ]
 
         if HAVE_PYTHON_36:
-            standard += 'e'
+            standard += ['e']
 
         modifiers = ['', '<', '>']
 
@@ -2802,6 +3608,7 @@ class TestBuffer(XndTestCase):
         x = np.array([(1000, 400.25, 'abc'), (-23, -1e10, 'cba')],
                      dtype=[('x', '<i4'), ('y', '>f4'), ('z', 'S3')])
         y = xnd.from_buffer(x)
+        check_copy_contiguous(self, y)
 
         for i in range(2):
             for k in ['x', 'y', 'z']:
@@ -2816,6 +3623,61 @@ class TestBuffer(XndTestCase):
         y = xnd.from_buffer(x)
         y[:] = [1000, 2000, 3000]
         self.assertEqual(x.tolist(), [1000, 2000, 3000])
+        check_copy_contiguous(self, y)
+
+    @unittest.skipIf(np is None, "numpy not found")
+    def test_complex(self):
+        x = xnd([1, 2, 3], dtype="complex64")
+        y = np.array(x)
+        self.assertEqual(memoryview(y).format, "Zf")
+
+        x = xnd([1, 2, 3], dtype="complex128")
+        y = np.array(x)
+        self.assertEqual(memoryview(y).format, "Zd")
+
+        x = np.array([1, 2, 3], dtype="complex64")
+        y = xnd.from_buffer(x)
+        self.assertEqual(memoryview(y).format, "=Zf")
+
+        x = np.array([1, 2, 3], dtype="complex128")
+        y = xnd.from_buffer(x)
+        self.assertEqual(memoryview(y).format, "=Zd")
+
+    @unittest.skipIf(np is None, "numpy not found")
+    def test_from_buffer_and_type(self):
+        x = np.array([[[0,1,2],
+                       [3,4,5]],
+                     [[6,7,8],
+                      [9,10,11]]], dtype="float32")
+
+        b = memoryview(x).cast("B")
+        t = ndt("2 * 2 * 3 * float32")
+        ans = xnd.from_buffer_and_type(b, t)
+        np.testing.assert_equal(ans, x)
+
+        t = ndt("2 * 2 * 4 * float32")
+        self.assertRaises(ValueError, xnd.from_buffer_and_type, b, t)
+
+        b = b"12345678"
+
+        t = ndt("3 * 3 * int8")
+        self.assertRaises(ValueError, xnd.from_buffer_and_type, b, t)
+
+        x = xnd.empty("2 * 2 * 2 * int8")
+        y = x[::-1]
+        self.assertRaises(ValueError, xnd.from_buffer_and_type, b, y.type)
+
+
+class TestReshape(XndTestCase):
+
+    def test_reshape_api(self):
+        x = xnd([[1,2,3], [4,5,6]], type="!2 * 3 * float32")
+        self.assertRaises(ValueError, x.reshape, 2**32, 2**32)
+
+    def test_reshape_fortran(self):
+        x = xnd([[1,2,3], [4,5,6]], type="!2 * 3 * float32")
+        y = x.reshape(3,2,order='F')
+        self.assertEqual(y, [[1,5], [4,3], [2,6]])
 
 
 class TestSplit(XndTestCase):
@@ -2847,6 +3709,69 @@ class TestSplit(XndTestCase):
                     self.assertEqual(a, b)
 
 
+class TestTranspose(XndTestCase):
+
+    def test_api(self):
+
+        x = xnd([])
+        y = x.transpose()
+        self.assertEqual(y, x)
+        y = x.transpose(permute=[0])
+        self.assertEqual(y, x)
+        self.assertRaises(ValueError, x.transpose, permute=[])
+        self.assertRaises(ValueError, x.transpose, permute=[0, 0])
+        self.assertRaises(ValueError, x.transpose, permute=[0, 1])
+
+        x = xnd([1, 2, 3])
+        y = x.transpose()
+        self.assertEqual(y, x)
+        y = x.transpose(permute=[0])
+        self.assertEqual(y, x)
+        self.assertRaises(ValueError, x.transpose, permute=[-1])
+        self.assertRaises(ValueError, x.transpose, permute=[2])
+        self.assertRaises(ValueError, x.transpose, permute=[0, 1])
+
+        x = xnd([[1], [2, 3]])
+        self.assertRaises(TypeError, x.transpose)
+
+        x = xnd([[1, 2, 3], [4, 5, 6]])
+        y = xnd([[1, 4], [2, 5], [3, 6]])
+
+        z = x.transpose()
+        self.assertEqual(z, y)
+
+        z = x.transpose([0, 1])
+        self.assertEqual(z, x)
+
+        z = x.transpose([1, 0])
+        self.assertEqual(z, y)
+
+        self.assertRaises(ValueError, x.transpose, permute=[1, 1])
+        self.assertRaises(ValueError, x.transpose, permute=[10, 1])
+
+    def test_nd(self):
+
+        lst = [[[0, 1, 3, 3],
+                [4, 5, 6, 7],
+                [8, 9, 10, 11]],
+               [[12, 13, 14, 15],
+                [16, 17, 18, 19],
+                [20, 21, 22, 23]]]
+
+        x = xnd(lst)
+
+        ans = [x[:, 0, :].value,
+               x[:, 1, :].value,
+               x[:, 2, :].value]
+        self.assertEqual(x.transpose(permute=(1, 0, 2)), ans)
+
+        ans = [x[:, :, 0].value,
+               x[:, :, 1].value,
+               x[:, :, 2].value,
+               x[:, :, 3].value]
+        self.assertEqual(x.transpose(permute=(2, 0, 1)), ans)
+
+
 class TestView(XndTestCase):
 
     def test_view_subscript(self):
@@ -2863,13 +3788,28 @@ class TestView(XndTestCase):
         self.assertEqual(x, xnd([1.1, 2.2, 3.3]))
 
 
+class TestCopy(XndTestCase):
+
+    def test_copy_contiguous(self):
+        x = xnd([[1,2,3], [4,5,6]], dtype="int8")
+        y = x.copy_contiguous()
+        self.assertEqual(x, y)
+
+        y = x.copy_contiguous(dtype="int64")
+        self.assertEqual(x, y)
+
+        x = xnd([1, 2, 2**63-1], dtype="int64")
+        self.assertRaises(ValueError, x.copy_contiguous, dtype="int8")
+
+
 class TestSpec(XndTestCase):
 
-    def __init__(self, *, constr,
+    def __init__(self, *, constr, ndarray,
                  values, value_generator,
                  indices_generator, indices_generator_args):
         super().__init__()
         self.constr = constr
+        self.ndarray = ndarray
         self.values = values
         self.value_generator = value_generator
         self.indices_generator = indices_generator
@@ -2880,7 +3820,11 @@ class TestSpec(XndTestCase):
         """Dump an error as a Python script for debugging."""
 
         sys.stderr.write("\n\nfrom xnd import *\n")
-        sys.stderr.write("from test_xnd import NDArray\n")
+        if self.ndarray == NDArray:
+            sys.stderr.write("from test_xnd import NDArray\n")
+        else:
+            sys.stderr.write("import numpy as np\n")
+            sys.stderr.write("NDArray = np.array\n")
         sys.stderr.write("lst = %s\n\n" % value)
         sys.stderr.write("x0 = xnd(lst)\n")
         sys.stderr.write("y0 = NDArray(lst)\n" % value)
@@ -2891,6 +3835,84 @@ class TestSpec(XndTestCase):
 
         sys.stderr.write("\n")
 
+    def run_reshape(self, nd, d):
+        if not isinstance(nd, xnd) or not isinstance(d, np.ndarray):
+            return
+
+        s = randshape(d.shape)
+
+        x = nd_exception = None
+        try:
+            x = nd.reshape(*s)
+        except Exception as e:
+            nd_exception =  e
+
+        y = def_exception = None
+        try:
+            y = d.view()
+            y.shape = s
+        except Exception as e:
+            def_exception =  e
+
+        if nd_exception or def_exception:
+            if nd_exception.__class__ is ValueError and \
+               def_exception.__class__ is AttributeError:
+                   return
+            self.assertIs(nd_exception.__class__, def_exception.__class__,
+                          "shape: %s nd: %s d: %s x: %s y: %s" % (s, nd, d, x, y))
+        else:
+            self.assertEqual(x.value, y.tolist(),
+                             "shape: %s nd: %s d: %s x: %s y: %s" % (s, nd, d, x, y))
+
+    def run_transpose(self, nd, d):
+        if not isinstance(nd, xnd) or not isinstance(d, np.ndarray):
+            return
+
+        x = nd.transpose()
+        y = d.transpose()
+
+        self.assertEqual(x.value, y.tolist(), "nd: %s d: %s x: %s y: %s" % (nd, d, x, y))
+
+        p = random.shuffle(list(range(y.ndim)))
+        x = nd.transpose(permute=p)
+        y = np.transpose(d, axes=p)
+
+        self.assertEqual(x.value, y.tolist())
+
+    def run_from_buffer(self, nd, d):
+        if not isinstance(nd, xnd) or not isinstance(d, np.ndarray):
+            return
+
+        x = xnd.from_buffer(d)
+        y = np.array(x, copy=False)
+
+        self.assertEqual(x.value, d.tolist())
+        self.assertEqual(x.value, y.tolist())
+
+    def run_tobytes(self, nd, d):
+        if not isinstance(nd, xnd) or not isinstance(d, np.ndarray):
+            return
+
+        x = nd.tobytes()
+        y = d.tobytes()
+
+        self.assertEqual(x, y)
+
+    def run_serialize(self, x):
+        if not isinstance(x, xnd):
+            return
+
+        try:
+            b = x.serialize()
+        except NotImplementedError:
+            return
+        try:
+            y = x.deserialize(b)
+        except NotImplementedError:
+            return
+
+        self.assertEqual(x, y)
+
     def run_single(self, nd, d, indices):
         """Run a single test case."""
 
@@ -2900,7 +3922,7 @@ class TestSpec(XndTestCase):
         try:
             nd_result = nd[indices]
         except Exception as e:
-            nd_exception =  e
+            nd_exception = e
 
         def_exception = None
         try:
@@ -2919,12 +3941,24 @@ class TestSpec(XndTestCase):
 
         if isinstance(nd_result, xnd):
             nd_value = nd_result.value
+            check_copy_contiguous(self, nd_result)
         elif np is not None and isinstance(nd_result, np.ndarray):
             nd_value = nd_result.tolist()
         else:
             nd_value = nd_result
 
-        self.assertEqual(nd_value, def_result)
+        if np is not None and isinstance(def_result, np.ndarray):
+            def_value = def_result.tolist()
+        else:
+            def_value = def_result
+
+        self.assertEqual(nd_value, def_value)
+        if np is not None:
+            self.run_reshape(nd_result, def_result)
+            self.run_transpose(nd_result, def_result)
+            self.run_from_buffer(nd_result, def_result)
+            self.run_tobytes(nd_result, def_result)
+
         return nd_result, def_result
 
     def run(self):
@@ -2943,12 +3977,14 @@ class TestSpec(XndTestCase):
                     self.log_err(value, depth)
                     raise e
 
+                self.run_serialize(next_nd)
+
                 if isinstance(next_d, list): # possibly None or scalar
                     check(next_nd, next_d, value, depth+1)
 
         for value in self.values:
             nd = self.constr(value)
-            d = NDArray(value)
+            d = self.ndarray(value, dtype="int64")
             check(nd, d, value, 0)
             check_buffer(nd)
 
@@ -2957,7 +3993,7 @@ class TestSpec(XndTestCase):
                 for max_shape in range(1, 8):
                     for value in self.value_generator(max_ndim, min_shape, max_shape):
                         nd = self.constr(value)
-                        d = NDArray(value)
+                        d = self.ndarray(value, dtype="int64")
                         check(nd, d, value, 0)
                         check_buffer(nd)
 
@@ -2969,6 +4005,7 @@ class LongIndexSliceTest(XndTestCase):
         skip_if(SKIP_LONG, "use --long argument to enable these tests")
 
         t = TestSpec(constr=xnd,
+                     ndarray=NDArray,
                      values=SUBSCRIPT_FIXED_TEST_CASES,
                      value_generator=gen_fixed,
                      indices_generator=genindices,
@@ -2976,6 +4013,7 @@ class LongIndexSliceTest(XndTestCase):
         t.run()
 
         t = TestSpec(constr=xnd,
+                     ndarray=NDArray,
                      values=SUBSCRIPT_VAR_TEST_CASES,
                      value_generator=gen_var,
                      indices_generator=genindices,
@@ -2987,6 +4025,7 @@ class LongIndexSliceTest(XndTestCase):
         skip_if(SKIP_LONG, "use --long argument to enable these tests")
 
         t = TestSpec(constr=xnd,
+                     ndarray=NDArray,
                      values=SUBSCRIPT_FIXED_TEST_CASES,
                      value_generator=gen_fixed,
                      indices_generator=randslices,
@@ -2994,6 +4033,7 @@ class LongIndexSliceTest(XndTestCase):
         t.run()
 
         t = TestSpec(constr=xnd,
+                     ndarray=NDArray,
                      values=SUBSCRIPT_VAR_TEST_CASES,
                      value_generator=gen_var,
                      indices_generator=randslices,
@@ -3005,6 +4045,7 @@ class LongIndexSliceTest(XndTestCase):
         skip_if(SKIP_LONG, "use --long argument to enable these tests")
 
         t = TestSpec(constr=xnd,
+                     ndarray=NDArray,
                      values=SUBSCRIPT_FIXED_TEST_CASES,
                      value_generator=gen_fixed,
                      indices_generator=gen_indices_or_slices,
@@ -3013,6 +4054,7 @@ class LongIndexSliceTest(XndTestCase):
 
 
         t = TestSpec(constr=xnd,
+                     ndarray=NDArray,
                      values=SUBSCRIPT_VAR_TEST_CASES,
                      value_generator=gen_var,
                      indices_generator=gen_indices_or_slices,
@@ -3024,6 +4066,7 @@ class LongIndexSliceTest(XndTestCase):
         skip_if(SKIP_LONG, "use --long argument to enable these tests")
 
         t = TestSpec(constr=xnd,
+                     ndarray=NDArray,
                      values=SUBSCRIPT_FIXED_TEST_CASES,
                      value_generator=gen_fixed,
                      indices_generator=mixed_indices,
@@ -3034,19 +4077,20 @@ class LongIndexSliceTest(XndTestCase):
         # Multidimensional indexing and slicing, mixed
         skip_if(SKIP_LONG, "use --long argument to enable these tests")
 
-        x = xnd([[1], [2, 3], [4, 5, 6]])
-
-        indices = (0, slice(0,1,1))
-        self.assertRaises(IndexError, x.__getitem__, indices)
-
-        indices = (slice(0,1,1), 0)
-        self.assertRaises(IndexError, x.__getitem__, indices)
+        t = TestSpec(constr=xnd,
+                     ndarray=NDArray,
+                     values=SUBSCRIPT_VAR_TEST_CASES,
+                     value_generator=gen_var,
+                     indices_generator=mixed_indices,
+                     indices_generator_args=(5,))
+        t.run()
 
     def test_slices_brute_force(self):
         # Test all possible slices for the given ndim and shape
         skip_if(SKIP_BRUTE_FORCE, "use --all argument to enable these tests")
 
         t = TestSpec(constr=xnd,
+                     ndarray=NDArray,
                      values=SUBSCRIPT_FIXED_TEST_CASES,
                      value_generator=gen_fixed,
                      indices_generator=genslices_ndim,
@@ -3054,6 +4098,7 @@ class LongIndexSliceTest(XndTestCase):
         t.run()
 
         t = TestSpec(constr=xnd,
+                     ndarray=NDArray,
                      values=SUBSCRIPT_VAR_TEST_CASES,
                      value_generator=gen_var,
                      indices_generator=genslices_ndim,
@@ -3066,6 +4111,31 @@ class LongIndexSliceTest(XndTestCase):
         skip_if(SKIP_LONG, "use --long argument to enable these tests")
 
         t = TestSpec(constr=np.array,
+                     ndarray=NDArray,
+                     values=SUBSCRIPT_FIXED_TEST_CASES,
+                     value_generator=gen_fixed,
+                     indices_generator=mixed_indices,
+                     indices_generator_args=(3,))
+        t.run()
+
+    @unittest.skipIf(np is None, "numpy not found")
+    def test_transpose_and_reshape(self):
+        skip_if(SKIP_LONG, "use --long argument to enable these tests")
+
+        t = TestSpec(constr=xnd,
+                     ndarray=np.array,
+                     values=SUBSCRIPT_FIXED_TEST_CASES,
+                     value_generator=gen_fixed,
+                     indices_generator=mixed_indices,
+                     indices_generator_args=(3,))
+        t.run()
+
+    @unittest.skipIf(np is None, "numpy not found")
+    def test_from_buffer(self):
+        skip_if(SKIP_LONG, "use --long argument to enable these tests")
+
+        t = TestSpec(constr=xnd,
+                     ndarray=np.array,
                      values=SUBSCRIPT_FIXED_TEST_CASES,
                      value_generator=gen_fixed,
                      indices_generator=mixed_indices,
@@ -3085,6 +4155,8 @@ ALL_TESTS = [
   TestEllipsisDim,
   TestTuple,
   TestRecord,
+  TestArray,
+  TestUnion,
   TestRef,
   TestConstr,
   TestNominal,
@@ -3114,8 +4186,11 @@ ALL_TESTS = [
   TestAPI,
   TestRepr,
   TestBuffer,
+  TestReshape,
   TestSplit,
+  TestTranspose,
   TestView,
+  TestCopy,
   LongIndexSliceTest,
 ]