Fix tests on big endian machines (#427)

* Force test arrays to be little-endian.

These are saved on disk as little-endian and need to be compared as
such.

* Add explicit byteorder on hexdigest tests.

Fixes #425.

Author: QuLogic

zarr/tests/test_core.py

@@ -47,7 +47,7 @@ def test_array_init(self):
 
         # normal initialization
         store = dict()
-        init_array(store, shape=100, chunks=10)
+        init_array(store, shape=100, chunks=10, dtype='<f8')
         a = Array(store)
         assert isinstance(a, Array)
         assert (100,) == a.shape
@@ -60,7 +60,7 @@ def test_array_init(self):
 
         # initialize at path
         store = dict()
-        init_array(store, shape=100, chunks=10, path='foo/bar')
+        init_array(store, shape=100, chunks=10, path='foo/bar', dtype='<f8')
         a = Array(store, path='foo/bar')
         assert isinstance(a, Array)
         assert (100,) == a.shape
@@ -503,24 +503,24 @@ def test_setitem_data_not_shared(self):
 
     def test_hexdigest(self):
         # Check basic 1-D array
-        z = self.create_array(shape=(1050,), chunks=100, dtype='i4')
+        z = self.create_array(shape=(1050,), chunks=100, dtype='<i4')
         assert '063b02ff8d9d3bab6da932ad5828b506ef0a6578' == z.hexdigest()
 
         # Check basic 1-D array with different type
-        z = self.create_array(shape=(1050,), chunks=100, dtype='f4')
+        z = self.create_array(shape=(1050,), chunks=100, dtype='<f4')
         assert 'f97b84dc9ffac807415f750100108764e837bb82' == z.hexdigest()
 
         # Check basic 2-D array
-        z = self.create_array(shape=(20, 35,), chunks=10, dtype='i4')
+        z = self.create_array(shape=(20, 35,), chunks=10, dtype='<i4')
         assert '4f797d7bdad0fa1c9fa8c80832efb891a68de104' == z.hexdigest()
 
         # Check basic 1-D array with some data
-        z = self.create_array(shape=(1050,), chunks=100, dtype='i4')
+        z = self.create_array(shape=(1050,), chunks=100, dtype='<i4')
         z[200:400] = np.arange(200, 400, dtype='i4')
         assert '14470724dca6c1837edddedc490571b6a7f270bc' == z.hexdigest()
 
         # Check basic 1-D array with attributes
-        z = self.create_array(shape=(1050,), chunks=100, dtype='i4')
+        z = self.create_array(shape=(1050,), chunks=100, dtype='<i4')
         z.attrs['foo'] = 'bar'
         assert '2a1046dd99b914459b3e86be9dde05027a07d209' == z.hexdigest()
 
@@ -1293,24 +1293,24 @@ def create_array(read_only=False, **kwargs):
 
     def test_hexdigest(self):
         # Check basic 1-D array
-        z = self.create_array(shape=(1050,), chunks=100, dtype='i4')
+        z = self.create_array(shape=(1050,), chunks=100, dtype='<i4')
         assert 'f710da18d45d38d4aaf2afd7fb822fdd73d02957' == z.hexdigest()
 
         # Check basic 1-D array with different type
-        z = self.create_array(shape=(1050,), chunks=100, dtype='f4')
+        z = self.create_array(shape=(1050,), chunks=100, dtype='<f4')
         assert '1437428e69754b1e1a38bd7fc9e43669577620db' == z.hexdigest()
 
         # Check basic 2-D array
-        z = self.create_array(shape=(20, 35,), chunks=10, dtype='i4')
+        z = self.create_array(shape=(20, 35,), chunks=10, dtype='<i4')
         assert 'dde44c72cc530bd6aae39b629eb15a2da627e5f9' == z.hexdigest()
 
         # Check basic 1-D array with some data
-        z = self.create_array(shape=(1050,), chunks=100, dtype='i4')
+        z = self.create_array(shape=(1050,), chunks=100, dtype='<i4')
         z[200:400] = np.arange(200, 400, dtype='i4')
         assert '4c0a76fb1222498e09dcd92f7f9221d6cea8b40e' == z.hexdigest()
 
         # Check basic 1-D array with attributes
-        z = self.create_array(shape=(1050,), chunks=100, dtype='i4')
+        z = self.create_array(shape=(1050,), chunks=100, dtype='<i4')
         z.attrs['foo'] = 'bar'
         assert '05b0663ffe1785f38d3a459dec17e57a18f254af' == z.hexdigest()
 
@@ -1348,24 +1348,24 @@ def create_array(read_only=False, **kwargs):
 
     def test_hexdigest(self):
         # Check basic 1-D array
-        z = self.create_array(shape=(1050,), chunks=100, dtype='i4')
+        z = self.create_array(shape=(1050,), chunks=100, dtype='<i4')
         assert 'f710da18d45d38d4aaf2afd7fb822fdd73d02957' == z.hexdigest()
 
         # Check basic 1-D array with different type
-        z = self.create_array(shape=(1050,), chunks=100, dtype='f4')
+        z = self.create_array(shape=(1050,), chunks=100, dtype='<f4')
         assert '1437428e69754b1e1a38bd7fc9e43669577620db' == z.hexdigest()
 
         # Check basic 2-D array
-        z = self.create_array(shape=(20, 35,), chunks=10, dtype='i4')
+        z = self.create_array(shape=(20, 35,), chunks=10, dtype='<i4')
         assert 'dde44c72cc530bd6aae39b629eb15a2da627e5f9' == z.hexdigest()
 
         # Check basic 1-D array with some data
-        z = self.create_array(shape=(1050,), chunks=100, dtype='i4')
+        z = self.create_array(shape=(1050,), chunks=100, dtype='<i4')
         z[200:400] = np.arange(200, 400, dtype='i4')
         assert '4c0a76fb1222498e09dcd92f7f9221d6cea8b40e' == z.hexdigest()
 
         # Check basic 1-D array with attributes
-        z = self.create_array(shape=(1050,), chunks=100, dtype='i4')
+        z = self.create_array(shape=(1050,), chunks=100, dtype='<i4')
         z.attrs['foo'] = 'bar'
         assert '05b0663ffe1785f38d3a459dec17e57a18f254af' == z.hexdigest()
 
@@ -1704,24 +1704,24 @@ def test_compressors(self):
 
     def test_hexdigest(self):
         # Check basic 1-D array
-        z = self.create_array(shape=(1050,), chunks=100, dtype='i4')
+        z = self.create_array(shape=(1050,), chunks=100, dtype='<i4')
         assert 'c6b83adfad999fbd865057531d749d87cf138f58' == z.hexdigest()
 
         # Check basic 1-D array with different type
-        z = self.create_array(shape=(1050,), chunks=100, dtype='f4')
+        z = self.create_array(shape=(1050,), chunks=100, dtype='<f4')
         assert 'a3d6d187536ecc3a9dd6897df55d258e2f52f9c5' == z.hexdigest()
 
         # Check basic 2-D array
-        z = self.create_array(shape=(20, 35,), chunks=10, dtype='i4')
+        z = self.create_array(shape=(20, 35,), chunks=10, dtype='<i4')
         assert '189690c5701d33a41cd7ce9aa0ac8dac49a69c51' == z.hexdigest()
 
         # Check basic 1-D array with some data
-        z = self.create_array(shape=(1050,), chunks=100, dtype='i4')
+        z = self.create_array(shape=(1050,), chunks=100, dtype='<i4')
         z[200:400] = np.arange(200, 400, dtype='i4')
         assert 'b63f031031dcd5248785616edcb2d6fe68203c28' == z.hexdigest()
 
         # Check basic 1-D array with attributes
-        z = self.create_array(shape=(1050,), chunks=100, dtype='i4')
+        z = self.create_array(shape=(1050,), chunks=100, dtype='<i4')
         z.attrs['foo'] = 'bar'
         assert '0cfc673215a8292a87f3c505e2402ce75243c601' == z.hexdigest()
 
@@ -1854,24 +1854,24 @@ def create_array(self, read_only=False, **kwargs):
 
     def test_hexdigest(self):
         # Check basic 1-D array
-        z = self.create_array(shape=(1050,), chunks=100, dtype='i4')
+        z = self.create_array(shape=(1050,), chunks=100, dtype='<i4')
         assert 'd3da3d485de4a5fcc6d91f9dfc6a7cba9720c561' == z.hexdigest()
 
         # Check basic 1-D array with different type
-        z = self.create_array(shape=(1050,), chunks=100, dtype='f4')
+        z = self.create_array(shape=(1050,), chunks=100, dtype='<f4')
         assert '443b8dee512e42946cb63ff01d28e9bee8105a5f' == z.hexdigest()
 
         # Check basic 2-D array
-        z = self.create_array(shape=(20, 35,), chunks=10, dtype='i4')
+        z = self.create_array(shape=(20, 35,), chunks=10, dtype='<i4')
         assert 'de841ca276042993da53985de1e7769f5d0fc54d' == z.hexdigest()
 
         # Check basic 1-D array with some data
-        z = self.create_array(shape=(1050,), chunks=100, dtype='i4')
+        z = self.create_array(shape=(1050,), chunks=100, dtype='<i4')
         z[200:400] = np.arange(200, 400, dtype='i4')
         assert '42b6ae0d50ec361628736ab7e68fe5fefca22136' == z.hexdigest()
 
         # Check basic 1-D array with attributes
-        z = self.create_array(shape=(1050,), chunks=100, dtype='i4')
+        z = self.create_array(shape=(1050,), chunks=100, dtype='<i4')
         z.attrs['foo'] = 'bar'
         assert 'a0535f31c130f5e5ac66ba0713d1c1ceaebd089b' == z.hexdigest()
 
@@ -1890,24 +1890,24 @@ def create_array(self, read_only=False, **kwargs):
 
     def test_hexdigest(self):
         # Check basic 1-D array
-        z = self.create_array(shape=(1050,), chunks=100, dtype='i4')
+        z = self.create_array(shape=(1050,), chunks=100, dtype='<i4')
         assert '33141032439fb1df5e24ad9891a7d845b6c668c8' == z.hexdigest()
 
         # Check basic 1-D array with different type
-        z = self.create_array(shape=(1050,), chunks=100, dtype='f4')
+        z = self.create_array(shape=(1050,), chunks=100, dtype='<f4')
         assert '44d719da065c88a412d609a5500ff41e07b331d6' == z.hexdigest()
 
         # Check basic 2-D array
-        z = self.create_array(shape=(20, 35,), chunks=10, dtype='i4')
+        z = self.create_array(shape=(20, 35,), chunks=10, dtype='<i4')
         assert 'f57a9a73a4004490fe1b871688651b8a298a5db7' == z.hexdigest()
 
         # Check basic 1-D array with some data
-        z = self.create_array(shape=(1050,), chunks=100, dtype='i4')
+        z = self.create_array(shape=(1050,), chunks=100, dtype='<i4')
         z[200:400] = np.arange(200, 400, dtype='i4')
         assert '1e1bcaac63e4ef3c4a68f11672537131c627f168' == z.hexdigest()
 
         # Check basic 1-D array with attributes
-        z = self.create_array(shape=(1050,), chunks=100, dtype='i4')
+        z = self.create_array(shape=(1050,), chunks=100, dtype='<i4')
         z.attrs['foo'] = 'bar'
         assert '86d7b9bf22dccbeaa22f340f38be506b55e76ff2' == z.hexdigest()
 
@@ -1926,24 +1926,24 @@ def create_array(self, read_only=False, **kwargs):
 
     def test_hexdigest(self):
         # Check basic 1-D array
-        z = self.create_array(shape=(1050,), chunks=100, dtype='i4')
+        z = self.create_array(shape=(1050,), chunks=100, dtype='<i4')
         assert '7ff2ae8511eac915fad311647c168ccfe943e788' == z.hexdigest()
 
         # Check basic 1-D array with different type
-        z = self.create_array(shape=(1050,), chunks=100, dtype='f4')
+        z = self.create_array(shape=(1050,), chunks=100, dtype='<f4')
         assert '962705c861863495e9ccb7be7735907aa15e85b5' == z.hexdigest()
 
         # Check basic 2-D array
-        z = self.create_array(shape=(20, 35,), chunks=10, dtype='i4')
+        z = self.create_array(shape=(20, 35,), chunks=10, dtype='<i4')
         assert 'deb675ff91dd26dba11b65aab5f19a1f21a5645b' == z.hexdigest()
 
         # Check basic 1-D array with some data
-        z = self.create_array(shape=(1050,), chunks=100, dtype='i4')
+        z = self.create_array(shape=(1050,), chunks=100, dtype='<i4')
         z[200:400] = np.arange(200, 400, dtype='i4')
         assert '90e30bdab745a9641cd0eb605356f531bc8ec1c3' == z.hexdigest()
 
         # Check basic 1-D array with attributes
-        z = self.create_array(shape=(1050,), chunks=100, dtype='i4')
+        z = self.create_array(shape=(1050,), chunks=100, dtype='<i4')
         z.attrs['foo'] = 'bar'
         assert '95d40c391f167db8b1290e3c39d9bf741edacdf6' == z.hexdigest()
 
@@ -1969,24 +1969,24 @@ def create_array(self, read_only=False, **kwargs):
 
     def test_hexdigest(self):
         # Check basic 1-D array
-        z = self.create_array(shape=(1050,), chunks=100, dtype='i4')
+        z = self.create_array(shape=(1050,), chunks=100, dtype='<i4')
         assert '93ecaa530a1162a9d48a3c1dcee4586ccfc59bae' == z.hexdigest()
 
         # Check basic 1-D array with different type
-        z = self.create_array(shape=(1050,), chunks=100, dtype='f4')
+        z = self.create_array(shape=(1050,), chunks=100, dtype='<f4')
         assert '04a9755a0cd638683531b7816c7fa4fbb6f577f2' == z.hexdigest()
 
         # Check basic 2-D array
-        z = self.create_array(shape=(20, 35,), chunks=10, dtype='i4')
+        z = self.create_array(shape=(20, 35,), chunks=10, dtype='<i4')
         assert 'b93b163a21e8500519250a6defb821d03eb5d9e0' == z.hexdigest()
 
         # Check basic 1-D array with some data
-        z = self.create_array(shape=(1050,), chunks=100, dtype='i4')
+        z = self.create_array(shape=(1050,), chunks=100, dtype='<i4')
         z[200:400] = np.arange(200, 400, dtype='i4')
         assert 'cde499f3dc945b4e97197ff8e3cf8188a1262c35' == z.hexdigest()
 
         # Check basic 1-D array with attributes
-        z = self.create_array(shape=(1050,), chunks=100, dtype='i4')
+        z = self.create_array(shape=(1050,), chunks=100, dtype='<i4')
         z.attrs['foo'] = 'bar'
         assert 'e2cf3afbf66ad0e28a2b6b68b1b07817c69aaee2' == z.hexdigest()
 
@@ -2012,24 +2012,24 @@ def create_array(read_only=False, **kwargs):
 
     def test_hexdigest(self):
         # Check basic 1-D array
-        z = self.create_array(shape=(1050,), chunks=100, dtype='i4')
+        z = self.create_array(shape=(1050,), chunks=100, dtype='<i4')
         assert 'b80367c5599d47110d42bd8886240c2f46620dba' == z.hexdigest()
 
         # Check basic 1-D array with different type
-        z = self.create_array(shape=(1050,), chunks=100, dtype='f4')
+        z = self.create_array(shape=(1050,), chunks=100, dtype='<f4')
         assert '95a7b2471225e73199c9716d21e8d3dd6e5f6f2a' == z.hexdigest()
 
         # Check basic 2-D array
-        z = self.create_array(shape=(20, 35,), chunks=10, dtype='i4')
+        z = self.create_array(shape=(20, 35,), chunks=10, dtype='<i4')
         assert '9abf3ad54413ab11855d88a5e0087cd416657e02' == z.hexdigest()
 
         # Check basic 1-D array with some data
-        z = self.create_array(shape=(1050,), chunks=100, dtype='i4')
+        z = self.create_array(shape=(1050,), chunks=100, dtype='<i4')
         z[200:400] = np.arange(200, 400, dtype='i4')
         assert 'c649ad229bc5720258b934ea958570c2f354c2eb' == z.hexdigest()
 
         # Check basic 1-D array with attributes
-        z = self.create_array(shape=(1050,), chunks=100, dtype='i4')
+        z = self.create_array(shape=(1050,), chunks=100, dtype='<i4')
         z.attrs['foo'] = 'bar'
         assert '62fc9236d78af18a5ec26c12eea1d33bce52501e' == z.hexdigest()
 

zarr/tests/test_meta.py

@@ -30,7 +30,7 @@ def test_encode_decode_array_1():
     meta = dict(
         shape=(100,),
         chunks=(10,),
-        dtype=np.dtype('f8'),
+        dtype=np.dtype('<f8'),
         compressor=Zlib(1).get_config(),
         fill_value=None,
         filters=None,
@@ -67,9 +67,9 @@ def test_encode_decode_array_1():
 def test_encode_decode_array_2():
 
     # some variations
-    df = Delta(astype='u2', dtype='V14')
+    df = Delta(astype='<u2', dtype='V14')
     compressor = Blosc(cname='lz4', clevel=3, shuffle=2)
-    dtype = np.dtype([('a', 'i4'), ('b', 'S10')])
+    dtype = np.dtype([('a', '<i4'), ('b', 'S10')])
     fill_value = np.zeros((), dtype=dtype)[()]
     meta = dict(
         shape=(100, 100),
@@ -229,7 +229,7 @@ def test_encode_decode_array_dtype_shape():
     meta = dict(
         shape=(100,),
         chunks=(10,),
-        dtype=np.dtype('(10, 10)f8'),
+        dtype=np.dtype('(10, 10)<f8'),
         compressor=Zlib(1).get_config(),
         fill_value=None,
         filters=None,
@@ -270,7 +270,7 @@ def test_encode_decode_array_structured():
     meta = dict(
         shape=(100,),
         chunks=(10,),
-        dtype=np.dtype('i8, (10, 10)f8, (5, 10, 15)u1'),
+        dtype=np.dtype('<i8, (10, 10)<f8, (5, 10, 15)u1'),
         compressor=Zlib(1).get_config(),
         fill_value=None,
         filters=None,
@@ -319,7 +319,7 @@ def test_encode_decode_fill_values_nan():
         meta = dict(
             shape=(100,),
             chunks=(10,),
-            dtype=np.dtype('f8'),
+            dtype=np.dtype('<f8'),
             compressor=Zlib(1).get_config(),
             fill_value=v,
             filters=None,

zarr/tests/test_storage.py

@@ -1444,33 +1444,33 @@ def test_format_compatibility():
     np.random.seed(42)
 
     arrays_chunks = [
-        (np.arange(1111, dtype='i1'), 100),
-        (np.arange(1111, dtype='i2'), 100),
-        (np.arange(1111, dtype='i4'), 100),
-        (np.arange(1111, dtype='i8'), 1000),
-        (np.random.randint(0, 200, size=2222, dtype='u1'), 100),
-        (np.random.randint(0, 2000, size=2222, dtype='u2'), 100),
-        (np.random.randint(0, 2000, size=2222, dtype='u4'), 100),
-        (np.random.randint(0, 2000, size=2222, dtype='u8'), 100),
-        (np.linspace(0, 1, 3333, dtype='f2'), 100),
-        (np.linspace(0, 1, 3333, dtype='f4'), 100),
-        (np.linspace(0, 1, 3333, dtype='f8'), 100),
-        (np.random.normal(loc=0, scale=1, size=4444).astype('f2'), 100),
-        (np.random.normal(loc=0, scale=1, size=4444).astype('f4'), 100),
-        (np.random.normal(loc=0, scale=1, size=4444).astype('f8'), 100),
+        (np.arange(1111, dtype='<i1'), 100),
+        (np.arange(1111, dtype='<i2'), 100),
+        (np.arange(1111, dtype='<i4'), 100),
+        (np.arange(1111, dtype='<i8'), 1000),
+        (np.random.randint(0, 200, size=2222, dtype='u1').astype('<u1'), 100),
+        (np.random.randint(0, 2000, size=2222, dtype='u2').astype('<u2'), 100),
+        (np.random.randint(0, 2000, size=2222, dtype='u4').astype('<u4'), 100),
+        (np.random.randint(0, 2000, size=2222, dtype='u8').astype('<u8'), 100),
+        (np.linspace(0, 1, 3333, dtype='<f2'), 100),
+        (np.linspace(0, 1, 3333, dtype='<f4'), 100),
+        (np.linspace(0, 1, 3333, dtype='<f8'), 100),
+        (np.random.normal(loc=0, scale=1, size=4444).astype('<f2'), 100),
+        (np.random.normal(loc=0, scale=1, size=4444).astype('<f4'), 100),
+        (np.random.normal(loc=0, scale=1, size=4444).astype('<f8'), 100),
         (np.random.choice([b'A', b'C', b'G', b'T'],
                           size=5555, replace=True).astype('S'), 100),
         (np.random.choice(['foo', 'bar', 'baz', 'quux'],
-                          size=5555, replace=True).astype('U'), 100),
+                          size=5555, replace=True).astype('<U'), 100),
         (np.random.choice([0, 1/3, 1/7, 1/9, np.nan],
-                          size=5555, replace=True).astype('f8'), 100),
+                          size=5555, replace=True).astype('<f8'), 100),
         (np.random.randint(0, 2, size=5555, dtype=bool), 100),
-        (np.arange(20000, dtype='i4').reshape(2000, 10, order='C'), (100, 3)),
-        (np.arange(20000, dtype='i4').reshape(200, 100, order='F'), (100, 30)),
-        (np.arange(20000, dtype='i4').reshape(200, 10, 10, order='C'), (100, 3, 3)),
-        (np.arange(20000, dtype='i4').reshape(20, 100, 10, order='F'), (10, 30, 3)),
-        (np.arange(20000, dtype='i4').reshape(20, 10, 10, 10, order='C'), (10, 3, 3, 3)),
-        (np.arange(20000, dtype='i4').reshape(20, 10, 10, 10, order='F'), (10, 3, 3, 3)),
+        (np.arange(20000, dtype='<i4').reshape(2000, 10, order='C'), (100, 3)),
+        (np.arange(20000, dtype='<i4').reshape(200, 100, order='F'), (100, 30)),
+        (np.arange(20000, dtype='<i4').reshape(200, 10, 10, order='C'), (100, 3, 3)),
+        (np.arange(20000, dtype='<i4').reshape(20, 100, 10, order='F'), (10, 30, 3)),
+        (np.arange(20000, dtype='<i4').reshape(20, 10, 10, 10, order='C'), (10, 3, 3, 3)),
+        (np.arange(20000, dtype='<i4').reshape(20, 10, 10, 10, order='F'), (10, 3, 3, 3)),
     ]
 
     compressors = [