System.FS.Sim.MockFS

Return True iff the handle is open.

Throws an exception if the handle is unknown.

Number of open handles

Renders the MockFS in a human-readable fashion.

Mock implementation of hClose

Get file size

NOTE: In the mock implementation this is thread safe, because there can be only one writer, so concurrent threads cannot change the size of the file.

Get bytes from handle

NOTE: Unlike real I/O, we disallow hGetSome on a handle in append mode.

Thread safe version of hGetSome, which doesn't modify or read the file offset.

Mock implementation of hIsOpen

Mock implementation of hOpen.

NOTE: Differences from Posix:

• We do not support opening directories.

• We do not support more than one concurrent writer (we do however allow a writer and multiple concurrent readers)

• We do not support create file on ReadMode.

Mock implementation of hSeek

NOTE: This is more restricted than the IO version, because seek has some odd properties:

• We do not allow seeking at all on files in append mode

• We do not allow seeking past the end of the file (this means that when using IO.SeekFromEnd, the only valid offset is 0)

• We do not return the new file offset

Truncate a file

NOTE: Differences from Posix:

• Although this corresponds to Posix ftruncate, this can only be used to make files smaller, not larger.

• We only support this in append mode. The reason is that Posix ftruncate does not modify the file offset, and adds padding with zeroes on subsequent writes. This is however not behaviour we want to emulate. In append mode however the Posix file offset is not used (and we don't even record it at all), appends always happen at the end of the file.

Check if directory exists

It seems real I/O maps what would be "inapproriate device" errors to False.

Check if file exists

See comments for doesDirectoryExist.

Remove a directory and its contents

Same limitations as removeFile.

Remove a file

The behaviour of unlink is to remove the file after all open file handles that refer to it are closed. The open file handles referring to the file can still be used to write/read to/from, while at the same time, the file is invisible for all other operations.

We do not implement this behaviour and consider this a limitation of the mock file system, and throw an error when removing a file that still has open file handles to it.

In the state machine tests, removing the root directory may cause the IO implementation to throw an FsInsufficientPermissions error, depending on the permissions of the temporary directory used to run the tests in. In theory it should throw a FsResourceInappropriateType error. To avoid this mismatch during testing, we also consider removing the root folder a limitation of the mock file system.

We store the files as an FsTree of the file contents

A mock handle to a file on disk.

This is only meaningful when interpreted against a MockFS.