Test that __getitem__ and __setitem__ performance is O(selected number of chunks) and not O(total number of chunks). Note: resize() is, by ne

Test that third-party compression filters from hdf5plugin or pytables such as Blosc validate correctly.

changes() changes chunk dtype upon first access.

Check that that, when writing to a h5py.string_dtype dataset, strings and bytes can be used interchangeably.

Check that we correctly handle chunk reuse verification for multi-dimensional Datasets.

Check that chunks are correctly verified when reused, even with nans.

Check that that strings can be reused and verified.

Test IndexChunkMapper.chunks_indexer and IndexChunkMapper.whole_chunks_idxidx

Test that chunks_indexer() and whole_chunks_indexer() return a slice if possible.

Test that `create_dataset("a/b/x", chunks=(2,))` does not discard the chunks= parameter

A chunk that is non-contiguous in the slab (trimmed on a non-leading axis) is hashed as if C-contiguous.

commit() on one CoW sibling does not affect the other.

When a chunk matches both a base and (the same value on) another staged chunk, the base slab wins (lowest slab index).

commit() consolidates staged slabs into one new base slab, preserving data.

The hash table of the base slab created by a previous commit() is used to deduplicate later staged chunks.

Edge chunks are hashed on their visible area only and deduplicate normally.

A staged chunk identical to an existing base (raw_data) chunk becomes a reference to it and is not rewritten.

Identical staged chunks are stored once in the new base slab.

Committing a dataset with staged changes doesn't swap the buffer dtype.

commit() trims the edge chunks, so that it never writes to disk the uninitialised padding beyond the edge of a staged chunk

When two identical chunks exist on the base slabs, the first one encountered wins and the other contributes no deduplication candidate.

The ``empty`` callback replicates numpy.empty and receives the new slab shape.

The empty callback may return a non-ndarray MutableArrayProtocol. This is important for the InMemoryDataset wrapper, which uses a callback that

An all-zero row in a base hash table means 'hash unknown': the chunk doesn't contribute a deduplication candidate.

commit() works for multidimensional arrays with edge chunks.

commit() on an array without staged chunks has nothing to write, so it does not append a new base slab.

All base-slab hashes are considered, even of chunks no longer referenced by the virtual array (e.g. deleted versions ago but still in raw_data).

commit() on a size-0 array is a well-behaved no-op-ish operation.

A staged chunk that was dropped by resize(), while other chunks on its slab remain in use, is not committed.

A version that only re-stages chunks identical to ones already in raw_data appends no new base slab and leaves the on-disk hash table untouched.

The on-disk hash table records the *trimmed* (start, stop) of a rewritten edge chunk - start still lands on a full-chunk boundary, but stop is the

An InMemorySparseDataset (no base slabs) can nonetheless have raw_data after DatasetWrapper hot-swapped it from a InMemoryDataset.

Modifying a dataset carried over from a previous version goes through commit_staged_changes (an InMemoryDataset, i.e. one base slab on entry), not

Staged chunks are deduplicated onto the correct raw_data offset even when the records of the on-disk hash table are not in chunk order, which is t

A commit that crashes halfway through leaves raw_data - and possibly the hash table too - enlarged, with garbage past the last recorded chunk. Nei

An InMemorySparseDataset (no base slabs) can nonetheless have raw_data, either because it was deleted and then created anew or because it was crea

A brand new (sparse) dataset has no base slab on entry (n_base_slabs == 0). Partially filling it, edge chunk included, commits the right chunks.

commit() when a staged slab was entirely dropped by resize()

The callback's returned array is where the chunks actually land (mirrors the InMemoryDataset wrapper writing into a raw_data view).

Check that InMemoryGroup propagates the '_committed' state to child instances.

Test .compression and .compression_opts properties. Also test that compression and compression_opts parameters are preserved when calling crea

When DatasetWrapper hot-swaps a InMemoryDataset with a InMemoryArrayDataset after a full-array update, don't revert to object dtype.

create_dataset() in versioned_hdf5 has a lot less kwargs than the same function in h5py. Test that the extra args are accepted, but ignored wi

Check that creating an empty multidimensional virtual dataset writes no raw data. See https://github.com/deshaw/versioned-hdf5/issues/430 for con

Check that creating an empty virtual dataset writes no raw data. Also check that the empty virtual dataset is formed correctly. See https://g

Check that creating a virtual dataset from chunks of real datasets works.

_data_v4_to_sc_hash_table() indexes the digests by chunk index, whatever order the records happen to be in on disk. VersionedHDF5File.rebuild_hash

Test that a file with no data version identifier logs a message when opened.

Test that a file with valid data version id opens without a log message.

DatasetWrapper.resize() hot-swaps a InMemoryArrayDataset for a InMemorySparseDataset when enlarging. Test that this doesn't flip the buffer dt

DatasetWrapper.__setitem__() hot-swaps a InMemoryDataset for a InMemoryArrayDataset when the whole dataset is updated. Test that this doesn't

Test that deleting an empty dataset executes successfully.

Test that delete_versions + h5repack works correctly for variable length string dtypes. When calling delete_versions, the dataset must be rec

Test that if you shrink a dataset so that an edge chunk contains the same data of the previous edge chunk on disk, but trimmed to the new size, th

Delete versions after various types of changes to each versions See Also -------- https://github.com/deshaw/versioned-hdf5/issues/411

delete_versions() shuffles the chunks of raw_data around. A version that was read through the same VersionedHDF5File handle beforehand must not ke