mirror of
https://github.com/eledio-devices/thirdparty-littlefs.git
synced 2025-11-01 00:38:29 +01:00
Compare commits
1 Commits
fix-max-nu
...
fix-read-h
| Author | SHA1 | Date | |
|---|---|---|---|
|
c64bf1a17b |
59
.travis.yml
59
.travis.yml
@@ -23,20 +23,8 @@ script:
|
||||
- make test QUIET=1 CFLAGS+="-DLFS_BLOCK_COUNT=1023 -DLFS_LOOKAHEAD_SIZE=256"
|
||||
|
||||
- make clean test QUIET=1 CFLAGS+="-DLFS_INLINE_MAX=0"
|
||||
- make clean test QUIET=1 CFLAGS+="-DLFS_EMUBD_ERASE_VALUE=0xff"
|
||||
- make clean test QUIET=1 CFLAGS+="-DLFS_NO_INTRINSICS"
|
||||
|
||||
# additional configurations that don't support all tests (this should be
|
||||
# fixed but at the moment it is what it is)
|
||||
- make test_files QUIET=1
|
||||
CFLAGS+="-DLFS_READ_SIZE=1 -DLFS_BLOCK_SIZE=4096"
|
||||
- make test_files QUIET=1
|
||||
CFLAGS+="-DLFS_READ_SIZE=\(2*1024\) -DLFS_BLOCK_SIZE=\(64*1024\)"
|
||||
- make test_files QUIET=1
|
||||
CFLAGS+="-DLFS_READ_SIZE=\(8*1024\) -DLFS_BLOCK_SIZE=\(64*1024\)"
|
||||
- make test_files QUIET=1
|
||||
CFLAGS+="-DLFS_READ_SIZE=11 -DLFS_BLOCK_SIZE=704"
|
||||
|
||||
# compile and find the code size with the smallest configuration
|
||||
- make clean size
|
||||
OBJ="$(ls lfs*.o | tr '\n' ' ')"
|
||||
@@ -78,10 +66,7 @@ jobs:
|
||||
- CC="arm-linux-gnueabi-gcc --static -mthumb"
|
||||
- EXEC="qemu-arm"
|
||||
install:
|
||||
- sudo apt-get install
|
||||
gcc-arm-linux-gnueabi
|
||||
libc6-dev-armel-cross
|
||||
qemu-user
|
||||
- sudo apt-get install gcc-arm-linux-gnueabi qemu-user
|
||||
- arm-linux-gnueabi-gcc --version
|
||||
- qemu-arm -version
|
||||
|
||||
@@ -93,10 +78,7 @@ jobs:
|
||||
- CC="powerpc-linux-gnu-gcc --static"
|
||||
- EXEC="qemu-ppc"
|
||||
install:
|
||||
- sudo apt-get install
|
||||
gcc-powerpc-linux-gnu
|
||||
libc6-dev-powerpc-cross
|
||||
qemu-user
|
||||
- sudo apt-get install gcc-powerpc-linux-gnu qemu-user
|
||||
- powerpc-linux-gnu-gcc --version
|
||||
- qemu-ppc -version
|
||||
|
||||
@@ -108,10 +90,9 @@ jobs:
|
||||
- CC="mips-linux-gnu-gcc --static"
|
||||
- EXEC="qemu-mips"
|
||||
install:
|
||||
- sudo apt-get install
|
||||
gcc-mips-linux-gnu
|
||||
libc6-dev-mips-cross
|
||||
qemu-user
|
||||
- sudo add-apt-repository -y "deb http://archive.ubuntu.com/ubuntu/ xenial main universe"
|
||||
- sudo apt-get -qq update
|
||||
- sudo apt-get install gcc-mips-linux-gnu qemu-user
|
||||
- mips-linux-gnu-gcc --version
|
||||
- qemu-mips -version
|
||||
|
||||
@@ -123,7 +104,7 @@ jobs:
|
||||
if: branch !~ -prefix$
|
||||
install:
|
||||
- sudo apt-get install libfuse-dev
|
||||
- git clone --depth 1 https://github.com/geky/littlefs-fuse -b v2
|
||||
- git clone --depth 1 https://github.com/geky/littlefs-fuse -b v2-alpha
|
||||
- fusermount -V
|
||||
- gcc --version
|
||||
before_script:
|
||||
@@ -158,7 +139,7 @@ jobs:
|
||||
if: branch !~ -prefix$
|
||||
install:
|
||||
- sudo apt-get install libfuse-dev
|
||||
- git clone --depth 1 https://github.com/geky/littlefs-fuse -b v2 v2
|
||||
- git clone --depth 1 https://github.com/geky/littlefs-fuse -b v2-alpha v2
|
||||
- git clone --depth 1 https://github.com/geky/littlefs-fuse -b v1 v1
|
||||
- fusermount -V
|
||||
- gcc --version
|
||||
@@ -248,30 +229,34 @@ jobs:
|
||||
-m "Generated v$LFS_VERSION_MAJOR prefixes")
|
||||
git reset --hard
|
||||
# Update major version branches (vN and vN-prefix)
|
||||
git push --atomic https://$GEKY_BOT_RELEASES@github.com/$TRAVIS_REPO_SLUG.git \
|
||||
git push https://$GEKY_BOT_RELEASES@github.com/$TRAVIS_REPO_SLUG.git \
|
||||
v$LFS_VERSION_MAJOR \
|
||||
v$LFS_VERSION_MAJOR-prefix
|
||||
# Create patch version tag (vN.N.N)
|
||||
curl -f -u "$GEKY_BOT_RELEASES" -X POST \
|
||||
https://api.github.com/repos/$TRAVIS_REPO_SLUG/git/refs \
|
||||
-d "{
|
||||
\"ref\": \"refs/tags/$LFS_VERSION\",
|
||||
\"sha\": \"$TRAVIS_COMMIT\"
|
||||
}"
|
||||
# Create minor release?
|
||||
[[ "$LFS_VERSION" == *.0 ]] || exit 0
|
||||
# Build release notes
|
||||
PREV=$(git tag --sort=-v:refname -l "v*" | head -1)
|
||||
PREV=$(git tag --sort=-v:refname -l "v*.0" | head -1)
|
||||
if [ ! -z "$PREV" ]
|
||||
then
|
||||
echo "PREV $PREV"
|
||||
CHANGES=$(git log --oneline $PREV.. --grep='^Merge' --invert-grep)
|
||||
CHANGES=$'### Changes\n\n'$( \
|
||||
git log --oneline $PREV.. --grep='^Merge' --invert-grep)
|
||||
printf "CHANGES\n%s\n\n" "$CHANGES"
|
||||
fi
|
||||
case ${GEKY_BOT_DRAFT:-minor} in
|
||||
true) DRAFT=true ;;
|
||||
minor) DRAFT=$(jq -R 'endswith(".0")' <<< "$LFS_VERSION") ;;
|
||||
false) DRAFT=false ;;
|
||||
esac
|
||||
# Create the release and patch version tag (vN.N.N)
|
||||
# Create the release
|
||||
curl -f -u "$GEKY_BOT_RELEASES" -X POST \
|
||||
https://api.github.com/repos/$TRAVIS_REPO_SLUG/releases \
|
||||
-d "{
|
||||
\"tag_name\": \"$LFS_VERSION\",
|
||||
\"name\": \"${LFS_VERSION%.0}\",
|
||||
\"target_commitish\": \"$TRAVIS_COMMIT\",
|
||||
\"draft\": $DRAFT,
|
||||
\"draft\": true,
|
||||
\"body\": $(jq -sR '.' <<< "$CHANGES")
|
||||
}" #"
|
||||
SCRIPT
|
||||
|
||||
54
DESIGN.md
54
DESIGN.md
@@ -254,7 +254,7 @@ have weaknesses that limit their usefulness. But if we merge the two they can
|
||||
mutually solve each other's limitations.
|
||||
|
||||
This is the idea behind littlefs. At the sub-block level, littlefs is built
|
||||
out of small, two block logs that provide atomic updates to metadata anywhere
|
||||
out of small, two blocks logs that provide atomic updates to metadata anywhere
|
||||
on the filesystem. At the super-block level, littlefs is a CObW tree of blocks
|
||||
that can be evicted on demand.
|
||||
|
||||
@@ -676,7 +676,7 @@ block, this cost is fairly reasonable.
|
||||
---
|
||||
|
||||
This is a new data structure, so we still have several questions. What is the
|
||||
storage overhead? Can the number of pointers exceed the size of a block? How do
|
||||
storage overage? Can the number of pointers exceed the size of a block? How do
|
||||
we store a CTZ skip-list in our metadata pairs?
|
||||
|
||||
To find the storage overhead, we can look at the data structure as multiple
|
||||
@@ -742,8 +742,8 @@ where:
|
||||
2. popcount(![x]) = the number of bits that are 1 in ![x]
|
||||
|
||||
Initial tests of this surprising property seem to hold. As ![n] approaches
|
||||
infinity, we end up with an average overhead of 2 pointers, which matches our
|
||||
assumption from earlier. During iteration, the popcount function seems to
|
||||
infinity, we end up with an average overhead of 2 pointers, which matches what
|
||||
our assumption from earlier. During iteration, the popcount function seems to
|
||||
handle deviations from this average. Of course, just to make sure I wrote a
|
||||
quick script that verified this property for all 32-bit integers.
|
||||
|
||||
@@ -767,7 +767,7 @@ overflow, but we can avoid this by rearranging the equation a bit:
|
||||
|
||||
![off = N - (B-2w/8)n - (w/8)popcount(n)][ctz-formula7]
|
||||
|
||||
Our solution requires quite a bit of math, but computers are very good at math.
|
||||
Our solution requires quite a bit of math, but computer are very good at math.
|
||||
Now we can find both our block index and offset from a size in _O(1)_, letting
|
||||
us store CTZ skip-lists with only a pointer and size.
|
||||
|
||||
@@ -850,7 +850,7 @@ nearly every write to the filesystem.
|
||||
|
||||
Normally, block allocation involves some sort of free list or bitmap stored on
|
||||
the filesystem that is updated with free blocks. However, with power
|
||||
resilience, keeping these structures consistent becomes difficult. It doesn't
|
||||
resilience, keeping these structure consistent becomes difficult. It doesn't
|
||||
help that any mistake in updating these structures can result in lost blocks
|
||||
that are impossible to recover.
|
||||
|
||||
@@ -894,9 +894,9 @@ high-risk error conditions.
|
||||
---
|
||||
|
||||
Our block allocator needs to find free blocks efficiently. You could traverse
|
||||
through every block on storage and check each one against our filesystem tree;
|
||||
however, the runtime would be abhorrent. We need to somehow collect multiple
|
||||
blocks per traversal.
|
||||
through every block on storage and check each one against our filesystem tree,
|
||||
however the runtime would be abhorrent. We need to somehow collect multiple
|
||||
blocks each traversal.
|
||||
|
||||
Looking at existing designs, some larger filesystems that use a similar "drop
|
||||
it on the floor" strategy store a bitmap of the entire storage in [RAM]. This
|
||||
@@ -920,8 +920,8 @@ a brute force traversal. Instead of a bitmap the size of storage, we keep track
|
||||
of a small, fixed-size bitmap called the lookahead buffer. During block
|
||||
allocation, we take blocks from the lookahead buffer. If the lookahead buffer
|
||||
is empty, we scan the filesystem for more free blocks, populating our lookahead
|
||||
buffer. In each scan we use an increasing offset, circling the storage as
|
||||
blocks are allocated.
|
||||
buffer. Each scan we use an increasing offset, circling the storage as blocks
|
||||
are allocated.
|
||||
|
||||
Here's what it might look like to allocate 4 blocks on a decently busy
|
||||
filesystem with a 32 bit lookahead and a total of 128 blocks (512 KiB
|
||||
@@ -950,7 +950,7 @@ alloc = 112 lookahead: ffff8000
|
||||
```
|
||||
|
||||
This lookahead approach has a runtime complexity of _O(n²)_ to completely
|
||||
scan storage; however, bitmaps are surprisingly compact, and in practice only
|
||||
scan storage, however, bitmaps are surprisingly compact, and in practice only
|
||||
one or two passes are usually needed to find free blocks. Additionally, the
|
||||
performance of the allocator can be optimized by adjusting the block size or
|
||||
size of the lookahead buffer, trading either write granularity or RAM for
|
||||
@@ -1173,9 +1173,9 @@ We may find that the new block is also bad, but hopefully after repeating this
|
||||
cycle we'll eventually find a new block where a write succeeds. If we don't,
|
||||
that means that all blocks in our storage are bad, and we've reached the end of
|
||||
our device's usable life. At this point, littlefs will return an "out of space"
|
||||
error. This is technically true, as there are no more good blocks, but as an
|
||||
added benefit it also matches the error condition expected by users of
|
||||
dynamically sized data.
|
||||
error, which is technically true, there are no more good blocks, but as an
|
||||
added benefit also matches the error condition expected by users of dynamically
|
||||
sized data.
|
||||
|
||||
---
|
||||
|
||||
@@ -1187,7 +1187,7 @@ original data even after it has been corrupted. One such mechanism for this is
|
||||
ECC is an extension to the idea of a checksum. Where a checksum such as CRC can
|
||||
detect that an error has occurred in the data, ECC can detect and actually
|
||||
correct some amount of errors. However, there is a limit to how many errors ECC
|
||||
can detect: the [Hamming bound][wikipedia-hamming-bound]. As the number of
|
||||
can detect, call the [Hamming bound][wikipedia-hamming-bound]. As the number of
|
||||
errors approaches the Hamming bound, we may still be able to detect errors, but
|
||||
can no longer fix the data. If we've reached this point the block is
|
||||
unrecoverable.
|
||||
@@ -1202,7 +1202,7 @@ chip itself.
|
||||
In littlefs, ECC is entirely optional. Read errors can instead be prevented
|
||||
proactively by wear leveling. But it's important to note that ECC can be used
|
||||
at the block device level to modestly extend the life of a device. littlefs
|
||||
respects any errors reported by the block device, allowing a block device to
|
||||
respects any errors reported by the block device, allow a block device to
|
||||
provide additional aggressive error detection.
|
||||
|
||||
---
|
||||
@@ -1231,7 +1231,7 @@ Generally, wear leveling algorithms fall into one of two categories:
|
||||
we need to consider all blocks, including blocks that already contain data.
|
||||
|
||||
As a tradeoff for code size and complexity, littlefs (currently) only provides
|
||||
dynamic wear leveling. This is a best effort solution. Wear is not distributed
|
||||
dynamic wear leveling. This is a best efforts solution. Wear is not distributed
|
||||
perfectly, but it is distributed among the free blocks and greatly extends the
|
||||
life of a device.
|
||||
|
||||
@@ -1378,7 +1378,7 @@ We can make several improvements. First, instead of giving each file its own
|
||||
metadata pair, we can store multiple files in a single metadata pair. One way
|
||||
to do this is to directly associate a directory with a metadata pair (or a
|
||||
linked list of metadata pairs). This makes it easy for multiple files to share
|
||||
the directory's metadata pair for logging and reduces the collective storage
|
||||
the directory's metadata pair for logging and reduce the collective storage
|
||||
overhead.
|
||||
|
||||
The strict binding of metadata pairs and directories also gives users
|
||||
@@ -1816,12 +1816,12 @@ while manipulating the directory tree (foreshadowing!).
|
||||
|
||||
## The move problem
|
||||
|
||||
We have one last challenge: the move problem. Phrasing the problem is simple:
|
||||
We have one last challenge. The move problem. Phrasing the problem is simple:
|
||||
|
||||
How do you atomically move a file between two directories?
|
||||
|
||||
In littlefs we can atomically commit to directories, but we can't create
|
||||
an atomic commit that spans multiple directories. The filesystem must go
|
||||
an atomic commit that span multiple directories. The filesystem must go
|
||||
through a minimum of two distinct states to complete a move.
|
||||
|
||||
To make matters worse, file moves are a common form of synchronization for
|
||||
@@ -1831,13 +1831,13 @@ atomic moves right.
|
||||
So what can we do?
|
||||
|
||||
- We definitely can't just let power-loss result in duplicated or lost files.
|
||||
This could easily break users' code and would only reveal itself in extreme
|
||||
This could easily break user's code and would only reveal itself in extreme
|
||||
cases. We were only able to be lazy about the threaded linked-list because
|
||||
it isn't user facing and we can handle the corner cases internally.
|
||||
|
||||
- Some filesystems propagate COW operations up the tree until a common parent
|
||||
is found. Unfortunately this interacts poorly with our threaded tree and
|
||||
brings back the issue of upward propagation of wear.
|
||||
- Some filesystems propagate COW operations up the tree until finding a common
|
||||
parent. Unfortunately this interacts poorly with our threaded tree and brings
|
||||
back the issue of upward propagation of wear.
|
||||
|
||||
- In a previous version of littlefs we tried to solve this problem by going
|
||||
back and forth between the source and destination, marking and unmarking the
|
||||
@@ -1852,7 +1852,7 @@ introduction of a mechanism called "global state".
|
||||
---
|
||||
|
||||
Global state is a small set of state that can be updated from _any_ metadata
|
||||
pair. Combining global state with metadata pairs' ability to update multiple
|
||||
pair. Combining global state with metadata pair's ability to update multiple
|
||||
entries in one commit gives us a powerful tool for crafting complex atomic
|
||||
operations.
|
||||
|
||||
@@ -1910,7 +1910,7 @@ the filesystem is mounted.
|
||||
|
||||
You may have noticed that global state is very expensive. We keep a copy in
|
||||
RAM and a delta in an unbounded number of metadata pairs. Even if we reset
|
||||
the global state to its initial value, we can't easily clean up the deltas on
|
||||
the global state to its initial value we can't easily clean up the deltas on
|
||||
disk. For this reason, it's very important that we keep the size of global
|
||||
state bounded and extremely small. But, even with a strict budget, global
|
||||
state is incredibly valuable.
|
||||
|
||||
24
Makefile
24
Makefile
@@ -24,12 +24,9 @@ endif
|
||||
ifdef WORD
|
||||
override CFLAGS += -m$(WORD)
|
||||
endif
|
||||
ifdef TRACE
|
||||
override CFLAGS += -DLFS_YES_TRACE
|
||||
endif
|
||||
override CFLAGS += -I.
|
||||
override CFLAGS += -std=c99 -Wall -pedantic
|
||||
override CFLAGS += -Wextra -Wshadow -Wjump-misses-init -Wundef
|
||||
override CFLAGS += -Wextra -Wshadow -Wjump-misses-init
|
||||
# Remove missing-field-initializers because of GCC bug
|
||||
override CFLAGS += -Wno-missing-field-initializers
|
||||
|
||||
@@ -42,25 +39,14 @@ size: $(OBJ)
|
||||
$(SIZE) -t $^
|
||||
|
||||
.SUFFIXES:
|
||||
test: \
|
||||
test_format \
|
||||
test_dirs \
|
||||
test_files \
|
||||
test_seek \
|
||||
test_truncate \
|
||||
test_entries \
|
||||
test_interspersed \
|
||||
test_alloc \
|
||||
test_paths \
|
||||
test_attrs \
|
||||
test_move \
|
||||
test_orphan \
|
||||
test_corrupt
|
||||
test: test_format test_dirs test_files test_seek test_truncate \
|
||||
test_entries test_interspersed test_alloc test_paths test_attrs \
|
||||
test_move test_orphan test_corrupt
|
||||
@rm test.c
|
||||
test_%: tests/test_%.sh
|
||||
|
||||
ifdef QUIET
|
||||
@./$< | sed -nu '/^[-=]/p'
|
||||
@./$< | sed -n '/^[-=]/p'
|
||||
else
|
||||
./$<
|
||||
endif
|
||||
|
||||
@@ -11,6 +11,7 @@
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <limits.h>
|
||||
#include <dirent.h>
|
||||
#include <sys/stat.h>
|
||||
#include <unistd.h>
|
||||
#include <assert.h>
|
||||
@@ -54,15 +55,6 @@ static inline void lfs_emubd_fromle32(lfs_emubd_t *emu) {
|
||||
|
||||
// Block device emulated on existing filesystem
|
||||
int lfs_emubd_create(const struct lfs_config *cfg, const char *path) {
|
||||
LFS_TRACE("lfs_emubd_create(%p {.context=%p, "
|
||||
".read=%p, .prog=%p, .erase=%p, .sync=%p, "
|
||||
".read_size=%"PRIu32", .prog_size=%"PRIu32", "
|
||||
".block_size=%"PRIu32", .block_count=%"PRIu32"}, \"%s\")",
|
||||
(void*)cfg, cfg->context,
|
||||
(void*)(uintptr_t)cfg->read, (void*)(uintptr_t)cfg->prog,
|
||||
(void*)(uintptr_t)cfg->erase, (void*)(uintptr_t)cfg->sync,
|
||||
cfg->read_size, cfg->prog_size, cfg->block_size, cfg->block_count,
|
||||
path);
|
||||
lfs_emubd_t *emu = cfg->context;
|
||||
emu->cfg.read_size = cfg->read_size;
|
||||
emu->cfg.prog_size = cfg->prog_size;
|
||||
@@ -73,9 +65,7 @@ int lfs_emubd_create(const struct lfs_config *cfg, const char *path) {
|
||||
size_t pathlen = strlen(path);
|
||||
emu->path = malloc(pathlen + 1 + LFS_NAME_MAX + 1);
|
||||
if (!emu->path) {
|
||||
int err = -ENOMEM;
|
||||
LFS_TRACE("lfs_emubd_create -> %"PRId32, err);
|
||||
return err;
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
strcpy(emu->path, path);
|
||||
@@ -86,31 +76,24 @@ int lfs_emubd_create(const struct lfs_config *cfg, const char *path) {
|
||||
// Create directory if it doesn't exist
|
||||
int err = mkdir(path, 0777);
|
||||
if (err && errno != EEXIST) {
|
||||
err = -errno;
|
||||
LFS_TRACE("lfs_emubd_create -> %"PRId32, err);
|
||||
return err;
|
||||
return -errno;
|
||||
}
|
||||
|
||||
// Load stats to continue incrementing
|
||||
snprintf(emu->child, LFS_NAME_MAX, ".stats");
|
||||
FILE *f = fopen(emu->path, "r");
|
||||
if (!f) {
|
||||
memset(&emu->stats, LFS_EMUBD_ERASE_VALUE, sizeof(emu->stats));
|
||||
memset(&emu->stats, 0, sizeof(emu->stats));
|
||||
} else {
|
||||
size_t res = fread(&emu->stats, sizeof(emu->stats), 1, f);
|
||||
lfs_emubd_fromle32(emu);
|
||||
if (res < 1) {
|
||||
err = -errno;
|
||||
LFS_TRACE("lfs_emubd_create -> %"PRId32, err);
|
||||
fclose(f);
|
||||
return err;
|
||||
return -errno;
|
||||
}
|
||||
|
||||
err = fclose(f);
|
||||
if (err) {
|
||||
err = -errno;
|
||||
LFS_TRACE("lfs_emubd_create -> %"PRId32, err);
|
||||
return err;
|
||||
return -errno;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -123,37 +106,27 @@ int lfs_emubd_create(const struct lfs_config *cfg, const char *path) {
|
||||
size_t res = fread(&emu->history, sizeof(emu->history), 1, f);
|
||||
lfs_emubd_fromle32(emu);
|
||||
if (res < 1) {
|
||||
err = -errno;
|
||||
LFS_TRACE("lfs_emubd_create -> %"PRId32, err);
|
||||
fclose(f);
|
||||
return err;
|
||||
return -errno;
|
||||
}
|
||||
|
||||
err = fclose(f);
|
||||
if (err) {
|
||||
err = -errno;
|
||||
LFS_TRACE("lfs_emubd_create -> %"PRId32, err);
|
||||
return err;
|
||||
return -errno;
|
||||
}
|
||||
}
|
||||
|
||||
LFS_TRACE("lfs_emubd_create -> %"PRId32, 0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
void lfs_emubd_destroy(const struct lfs_config *cfg) {
|
||||
LFS_TRACE("lfs_emubd_destroy(%p)", (void*)cfg);
|
||||
lfs_emubd_sync(cfg);
|
||||
|
||||
lfs_emubd_t *emu = cfg->context;
|
||||
free(emu->path);
|
||||
LFS_TRACE("lfs_emubd_destroy -> %s", "void");
|
||||
}
|
||||
|
||||
int lfs_emubd_read(const struct lfs_config *cfg, lfs_block_t block,
|
||||
lfs_off_t off, void *buffer, lfs_size_t size) {
|
||||
LFS_TRACE("lfs_emubd_read(%p, 0x%"PRIx32", %"PRIu32", %p, %"PRIu32")",
|
||||
(void*)cfg, block, off, buffer, size);
|
||||
lfs_emubd_t *emu = cfg->context;
|
||||
uint8_t *data = buffer;
|
||||
|
||||
@@ -170,45 +143,32 @@ int lfs_emubd_read(const struct lfs_config *cfg, lfs_block_t block,
|
||||
|
||||
FILE *f = fopen(emu->path, "rb");
|
||||
if (!f && errno != ENOENT) {
|
||||
int err = -errno;
|
||||
LFS_TRACE("lfs_emubd_read -> %d", err);
|
||||
return err;
|
||||
return -errno;
|
||||
}
|
||||
|
||||
if (f) {
|
||||
int err = fseek(f, off, SEEK_SET);
|
||||
if (err) {
|
||||
err = -errno;
|
||||
LFS_TRACE("lfs_emubd_read -> %d", err);
|
||||
fclose(f);
|
||||
return err;
|
||||
return -errno;
|
||||
}
|
||||
|
||||
size_t res = fread(data, 1, size, f);
|
||||
if (res < size && !feof(f)) {
|
||||
err = -errno;
|
||||
LFS_TRACE("lfs_emubd_read -> %d", err);
|
||||
fclose(f);
|
||||
return err;
|
||||
return -errno;
|
||||
}
|
||||
|
||||
err = fclose(f);
|
||||
if (err) {
|
||||
err = -errno;
|
||||
LFS_TRACE("lfs_emubd_read -> %d", err);
|
||||
return err;
|
||||
return -errno;
|
||||
}
|
||||
}
|
||||
|
||||
emu->stats.read_count += size;
|
||||
LFS_TRACE("lfs_emubd_read -> %d", 0);
|
||||
emu->stats.read_count += 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int lfs_emubd_prog(const struct lfs_config *cfg, lfs_block_t block,
|
||||
lfs_off_t off, const void *buffer, lfs_size_t size) {
|
||||
LFS_TRACE("lfs_emubd_prog(%p, 0x%"PRIx32", %"PRIu32", %p, %"PRIu32")",
|
||||
(void*)cfg, block, off, buffer, size);
|
||||
lfs_emubd_t *emu = cfg->context;
|
||||
const uint8_t *data = buffer;
|
||||
|
||||
@@ -222,9 +182,7 @@ int lfs_emubd_prog(const struct lfs_config *cfg, lfs_block_t block,
|
||||
|
||||
FILE *f = fopen(emu->path, "r+b");
|
||||
if (!f) {
|
||||
int err = (errno == EACCES) ? 0 : -errno;
|
||||
LFS_TRACE("lfs_emubd_prog -> %d", err);
|
||||
return err;
|
||||
return (errno == EACCES) ? 0 : -errno;
|
||||
}
|
||||
|
||||
// Check that file was erased
|
||||
@@ -232,58 +190,42 @@ int lfs_emubd_prog(const struct lfs_config *cfg, lfs_block_t block,
|
||||
|
||||
int err = fseek(f, off, SEEK_SET);
|
||||
if (err) {
|
||||
err = -errno;
|
||||
LFS_TRACE("lfs_emubd_prog -> %d", err);
|
||||
fclose(f);
|
||||
return err;
|
||||
return -errno;
|
||||
}
|
||||
|
||||
size_t res = fwrite(data, 1, size, f);
|
||||
if (res < size) {
|
||||
err = -errno;
|
||||
LFS_TRACE("lfs_emubd_prog -> %d", err);
|
||||
fclose(f);
|
||||
return err;
|
||||
return -errno;
|
||||
}
|
||||
|
||||
err = fseek(f, off, SEEK_SET);
|
||||
if (err) {
|
||||
err = -errno;
|
||||
LFS_TRACE("lfs_emubd_prog -> %d", err);
|
||||
fclose(f);
|
||||
return err;
|
||||
return -errno;
|
||||
}
|
||||
|
||||
uint8_t dat;
|
||||
res = fread(&dat, 1, 1, f);
|
||||
if (res < 1) {
|
||||
err = -errno;
|
||||
LFS_TRACE("lfs_emubd_prog -> %d", err);
|
||||
fclose(f);
|
||||
return err;
|
||||
return -errno;
|
||||
}
|
||||
|
||||
err = fclose(f);
|
||||
if (err) {
|
||||
err = -errno;
|
||||
LFS_TRACE("lfs_emubd_prog -> %d", err);
|
||||
return err;
|
||||
return -errno;
|
||||
}
|
||||
|
||||
// update history and stats
|
||||
if (block != emu->history.blocks[0]) {
|
||||
memmove(&emu->history.blocks[1], &emu->history.blocks[0],
|
||||
memcpy(&emu->history.blocks[1], &emu->history.blocks[0],
|
||||
sizeof(emu->history) - sizeof(emu->history.blocks[0]));
|
||||
emu->history.blocks[0] = block;
|
||||
}
|
||||
|
||||
emu->stats.prog_count += size;
|
||||
LFS_TRACE("lfs_emubd_prog -> %d", 0);
|
||||
emu->stats.prog_count += 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int lfs_emubd_erase(const struct lfs_config *cfg, lfs_block_t block) {
|
||||
LFS_TRACE("lfs_emubd_erase(%p, 0x%"PRIx32")", (void*)cfg, block);
|
||||
lfs_emubd_t *emu = cfg->context;
|
||||
|
||||
// Check if erase is valid
|
||||
@@ -294,121 +236,89 @@ int lfs_emubd_erase(const struct lfs_config *cfg, lfs_block_t block) {
|
||||
struct stat st;
|
||||
int err = stat(emu->path, &st);
|
||||
if (err && errno != ENOENT) {
|
||||
err = -errno;
|
||||
LFS_TRACE("lfs_emubd_erase -> %d", err);
|
||||
return err;
|
||||
return -errno;
|
||||
}
|
||||
|
||||
if (!err && S_ISREG(st.st_mode) && (S_IWUSR & st.st_mode)) {
|
||||
err = unlink(emu->path);
|
||||
if (err) {
|
||||
err = -errno;
|
||||
LFS_TRACE("lfs_emubd_erase -> %d", err);
|
||||
return err;
|
||||
return -errno;
|
||||
}
|
||||
}
|
||||
|
||||
if (err || (S_ISREG(st.st_mode) && (S_IWUSR & st.st_mode))) {
|
||||
FILE *f = fopen(emu->path, "w");
|
||||
if (!f) {
|
||||
err = -errno;
|
||||
LFS_TRACE("lfs_emubd_erase -> %d", err);
|
||||
return err;
|
||||
return -errno;
|
||||
}
|
||||
|
||||
err = fclose(f);
|
||||
if (err) {
|
||||
err = -errno;
|
||||
LFS_TRACE("lfs_emubd_erase -> %d", err);
|
||||
return err;
|
||||
return -errno;
|
||||
}
|
||||
}
|
||||
|
||||
emu->stats.erase_count += cfg->block_size;
|
||||
LFS_TRACE("lfs_emubd_erase -> %d", 0);
|
||||
emu->stats.erase_count += 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int lfs_emubd_sync(const struct lfs_config *cfg) {
|
||||
LFS_TRACE("lfs_emubd_sync(%p)", (void*)cfg);
|
||||
lfs_emubd_t *emu = cfg->context;
|
||||
|
||||
// Just write out info/stats for later lookup
|
||||
snprintf(emu->child, LFS_NAME_MAX, ".config");
|
||||
FILE *f = fopen(emu->path, "w");
|
||||
if (!f) {
|
||||
int err = -errno;
|
||||
LFS_TRACE("lfs_emubd_sync -> %d", err);
|
||||
return err;
|
||||
return -errno;
|
||||
}
|
||||
|
||||
lfs_emubd_tole32(emu);
|
||||
size_t res = fwrite(&emu->cfg, sizeof(emu->cfg), 1, f);
|
||||
lfs_emubd_fromle32(emu);
|
||||
if (res < 1) {
|
||||
int err = -errno;
|
||||
LFS_TRACE("lfs_emubd_sync -> %d", err);
|
||||
fclose(f);
|
||||
return err;
|
||||
return -errno;
|
||||
}
|
||||
|
||||
int err = fclose(f);
|
||||
if (err) {
|
||||
err = -errno;
|
||||
LFS_TRACE("lfs_emubd_sync -> %d", err);
|
||||
return err;
|
||||
return -errno;
|
||||
}
|
||||
|
||||
snprintf(emu->child, LFS_NAME_MAX, ".stats");
|
||||
f = fopen(emu->path, "w");
|
||||
if (!f) {
|
||||
err = -errno;
|
||||
LFS_TRACE("lfs_emubd_sync -> %d", err);
|
||||
return err;
|
||||
return -errno;
|
||||
}
|
||||
|
||||
lfs_emubd_tole32(emu);
|
||||
res = fwrite(&emu->stats, sizeof(emu->stats), 1, f);
|
||||
lfs_emubd_fromle32(emu);
|
||||
if (res < 1) {
|
||||
err = -errno;
|
||||
LFS_TRACE("lfs_emubd_sync -> %d", err);
|
||||
fclose(f);
|
||||
return err;
|
||||
return -errno;
|
||||
}
|
||||
|
||||
err = fclose(f);
|
||||
if (err) {
|
||||
err = -errno;
|
||||
LFS_TRACE("lfs_emubd_sync -> %d", err);
|
||||
return err;
|
||||
return -errno;
|
||||
}
|
||||
|
||||
snprintf(emu->child, LFS_NAME_MAX, ".history");
|
||||
f = fopen(emu->path, "w");
|
||||
if (!f) {
|
||||
err = -errno;
|
||||
LFS_TRACE("lfs_emubd_sync -> %d", err);
|
||||
return err;
|
||||
return -errno;
|
||||
}
|
||||
|
||||
lfs_emubd_tole32(emu);
|
||||
res = fwrite(&emu->history, sizeof(emu->history), 1, f);
|
||||
lfs_emubd_fromle32(emu);
|
||||
if (res < 1) {
|
||||
err = -errno;
|
||||
LFS_TRACE("lfs_emubd_sync -> %d", err);
|
||||
fclose(f);
|
||||
return err;
|
||||
return -errno;
|
||||
}
|
||||
|
||||
err = fclose(f);
|
||||
if (err) {
|
||||
err = -errno;
|
||||
LFS_TRACE("lfs_emubd_sync -> %d", err);
|
||||
return err;
|
||||
return -errno;
|
||||
}
|
||||
|
||||
LFS_TRACE("lfs_emubd_sync -> %d", 0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -17,8 +17,20 @@ extern "C"
|
||||
|
||||
|
||||
// Config options
|
||||
#ifndef LFS_EMUBD_ERASE_VALUE
|
||||
#define LFS_EMUBD_ERASE_VALUE 0x00
|
||||
#ifndef LFS_EMUBD_READ_SIZE
|
||||
#define LFS_EMUBD_READ_SIZE 1
|
||||
#endif
|
||||
|
||||
#ifndef LFS_EMUBD_PROG_SIZE
|
||||
#define LFS_EMUBD_PROG_SIZE 1
|
||||
#endif
|
||||
|
||||
#ifndef LFS_EMUBD_ERASE_SIZE
|
||||
#define LFS_EMUBD_ERASE_SIZE 512
|
||||
#endif
|
||||
|
||||
#ifndef LFS_EMUBD_TOTAL_SIZE
|
||||
#define LFS_EMUBD_TOTAL_SIZE 524288
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
21
lfs.h
21
lfs.h
@@ -21,7 +21,7 @@ extern "C"
|
||||
// Software library version
|
||||
// Major (top-nibble), incremented on backwards incompatible changes
|
||||
// Minor (bottom-nibble), incremented on feature additions
|
||||
#define LFS_VERSION 0x00020001
|
||||
#define LFS_VERSION 0x00020000
|
||||
#define LFS_VERSION_MAJOR (0xffff & (LFS_VERSION >> 16))
|
||||
#define LFS_VERSION_MINOR (0xffff & (LFS_VERSION >> 0))
|
||||
|
||||
@@ -136,7 +136,6 @@ enum lfs_open_flags {
|
||||
LFS_F_READING = 0x040000, // File has been read since last flush
|
||||
LFS_F_ERRED = 0x080000, // An error occured during write
|
||||
LFS_F_INLINE = 0x100000, // Currently inlined in directory entry
|
||||
LFS_F_OPENED = 0x200000, // File has been opened
|
||||
};
|
||||
|
||||
// File seek flags
|
||||
@@ -191,13 +190,9 @@ struct lfs_config {
|
||||
// Number of erasable blocks on the device.
|
||||
lfs_size_t block_count;
|
||||
|
||||
// Number of erase cycles before littlefs evicts metadata logs and moves
|
||||
// the metadata to another block. Suggested values are in the
|
||||
// range 100-1000, with large values having better performance at the cost
|
||||
// of less consistent wear distribution.
|
||||
//
|
||||
// Set to -1 to disable block-level wear-leveling.
|
||||
int32_t block_cycles;
|
||||
// Number of erase cycles before we should move data to another block.
|
||||
// May be zero, in which case no block-level wear-leveling is performed.
|
||||
uint32_t block_cycles;
|
||||
|
||||
// Size of block caches. Each cache buffers a portion of a block in RAM.
|
||||
// The littlefs needs a read cache, a program cache, and one additional
|
||||
@@ -209,7 +204,7 @@ struct lfs_config {
|
||||
// Size of the lookahead buffer in bytes. A larger lookahead buffer
|
||||
// increases the number of blocks found during an allocation pass. The
|
||||
// lookahead buffer is stored as a compact bitmap, so each byte of RAM
|
||||
// can track 8 blocks. Must be a multiple of 8.
|
||||
// can track 8 blocks. Must be a multiple of 4.
|
||||
lfs_size_t lookahead_size;
|
||||
|
||||
// Optional statically allocated read buffer. Must be cache_size.
|
||||
@@ -221,7 +216,7 @@ struct lfs_config {
|
||||
void *prog_buffer;
|
||||
|
||||
// Optional statically allocated lookahead buffer. Must be lookahead_size
|
||||
// and aligned to a 32-bit boundary. By default lfs_malloc is used to
|
||||
// and aligned to a 64-bit boundary. By default lfs_malloc is used to
|
||||
// allocate this buffer.
|
||||
void *lookahead_buffer;
|
||||
|
||||
@@ -533,7 +528,7 @@ lfs_ssize_t lfs_file_write(lfs_t *lfs, lfs_file_t *file,
|
||||
// Change the position of the file
|
||||
//
|
||||
// The change in position is determined by the offset and whence flag.
|
||||
// Returns the new position of the file, or a negative error code on failure.
|
||||
// Returns the old position of the file, or a negative error code on failure.
|
||||
lfs_soff_t lfs_file_seek(lfs_t *lfs, lfs_file_t *file,
|
||||
lfs_soff_t off, int whence);
|
||||
|
||||
@@ -550,7 +545,7 @@ lfs_soff_t lfs_file_tell(lfs_t *lfs, lfs_file_t *file);
|
||||
|
||||
// Change the position of the file to the beginning of the file
|
||||
//
|
||||
// Equivalent to lfs_file_seek(lfs, file, 0, LFS_SEEK_SET)
|
||||
// Equivalent to lfs_file_seek(lfs, file, 0, LFS_SEEK_CUR)
|
||||
// Returns a negative error code on failure.
|
||||
int lfs_file_rewind(lfs_t *lfs, lfs_file_t *file);
|
||||
|
||||
|
||||
42
lfs_util.h
42
lfs_util.h
@@ -31,10 +31,7 @@
|
||||
#ifndef LFS_NO_ASSERT
|
||||
#include <assert.h>
|
||||
#endif
|
||||
#if !defined(LFS_NO_DEBUG) || \
|
||||
!defined(LFS_NO_WARN) || \
|
||||
!defined(LFS_NO_ERROR) || \
|
||||
defined(LFS_YES_TRACE)
|
||||
#if !defined(LFS_NO_DEBUG) || !defined(LFS_NO_WARN) || !defined(LFS_NO_ERROR)
|
||||
#include <stdio.h>
|
||||
#endif
|
||||
|
||||
@@ -49,30 +46,23 @@ extern "C"
|
||||
// code footprint
|
||||
|
||||
// Logging functions
|
||||
#ifdef LFS_YES_TRACE
|
||||
#define LFS_TRACE(fmt, ...) \
|
||||
printf("lfs_trace:%d: " fmt "\n", __LINE__, __VA_ARGS__)
|
||||
#else
|
||||
#define LFS_TRACE(fmt, ...)
|
||||
#endif
|
||||
|
||||
#ifndef LFS_NO_DEBUG
|
||||
#define LFS_DEBUG(fmt, ...) \
|
||||
printf("lfs_debug:%d: " fmt "\n", __LINE__, __VA_ARGS__)
|
||||
printf("lfs debug:%d: " fmt "\n", __LINE__, __VA_ARGS__)
|
||||
#else
|
||||
#define LFS_DEBUG(fmt, ...)
|
||||
#endif
|
||||
|
||||
#ifndef LFS_NO_WARN
|
||||
#define LFS_WARN(fmt, ...) \
|
||||
printf("lfs_warn:%d: " fmt "\n", __LINE__, __VA_ARGS__)
|
||||
printf("lfs warn:%d: " fmt "\n", __LINE__, __VA_ARGS__)
|
||||
#else
|
||||
#define LFS_WARN(fmt, ...)
|
||||
#endif
|
||||
|
||||
#ifndef LFS_NO_ERROR
|
||||
#define LFS_ERROR(fmt, ...) \
|
||||
printf("lfs_error:%d: " fmt "\n", __LINE__, __VA_ARGS__)
|
||||
printf("lfs error:%d: " fmt "\n", __LINE__, __VA_ARGS__)
|
||||
#else
|
||||
#define LFS_ERROR(fmt, ...)
|
||||
#endif
|
||||
@@ -153,14 +143,14 @@ static inline int lfs_scmp(uint32_t a, uint32_t b) {
|
||||
// Convert between 32-bit little-endian and native order
|
||||
static inline uint32_t lfs_fromle32(uint32_t a) {
|
||||
#if !defined(LFS_NO_INTRINSICS) && ( \
|
||||
(defined( BYTE_ORDER ) && defined( ORDER_LITTLE_ENDIAN ) && BYTE_ORDER == ORDER_LITTLE_ENDIAN ) || \
|
||||
(defined(__BYTE_ORDER ) && defined(__ORDER_LITTLE_ENDIAN ) && __BYTE_ORDER == __ORDER_LITTLE_ENDIAN ) || \
|
||||
(defined(__BYTE_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__))
|
||||
(defined( BYTE_ORDER ) && BYTE_ORDER == ORDER_LITTLE_ENDIAN ) || \
|
||||
(defined(__BYTE_ORDER ) && __BYTE_ORDER == __ORDER_LITTLE_ENDIAN ) || \
|
||||
(defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__))
|
||||
return a;
|
||||
#elif !defined(LFS_NO_INTRINSICS) && ( \
|
||||
(defined( BYTE_ORDER ) && defined( ORDER_BIG_ENDIAN ) && BYTE_ORDER == ORDER_BIG_ENDIAN ) || \
|
||||
(defined(__BYTE_ORDER ) && defined(__ORDER_BIG_ENDIAN ) && __BYTE_ORDER == __ORDER_BIG_ENDIAN ) || \
|
||||
(defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__))
|
||||
(defined( BYTE_ORDER ) && BYTE_ORDER == ORDER_BIG_ENDIAN ) || \
|
||||
(defined(__BYTE_ORDER ) && __BYTE_ORDER == __ORDER_BIG_ENDIAN ) || \
|
||||
(defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__))
|
||||
return __builtin_bswap32(a);
|
||||
#else
|
||||
return (((uint8_t*)&a)[0] << 0) |
|
||||
@@ -177,14 +167,14 @@ static inline uint32_t lfs_tole32(uint32_t a) {
|
||||
// Convert between 32-bit big-endian and native order
|
||||
static inline uint32_t lfs_frombe32(uint32_t a) {
|
||||
#if !defined(LFS_NO_INTRINSICS) && ( \
|
||||
(defined( BYTE_ORDER ) && defined( ORDER_LITTLE_ENDIAN ) && BYTE_ORDER == ORDER_LITTLE_ENDIAN ) || \
|
||||
(defined(__BYTE_ORDER ) && defined(__ORDER_LITTLE_ENDIAN ) && __BYTE_ORDER == __ORDER_LITTLE_ENDIAN ) || \
|
||||
(defined(__BYTE_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__))
|
||||
(defined( BYTE_ORDER ) && BYTE_ORDER == ORDER_LITTLE_ENDIAN ) || \
|
||||
(defined(__BYTE_ORDER ) && __BYTE_ORDER == __ORDER_LITTLE_ENDIAN ) || \
|
||||
(defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__))
|
||||
return __builtin_bswap32(a);
|
||||
#elif !defined(LFS_NO_INTRINSICS) && ( \
|
||||
(defined( BYTE_ORDER ) && defined( ORDER_BIG_ENDIAN ) && BYTE_ORDER == ORDER_BIG_ENDIAN ) || \
|
||||
(defined(__BYTE_ORDER ) && defined(__ORDER_BIG_ENDIAN ) && __BYTE_ORDER == __ORDER_BIG_ENDIAN ) || \
|
||||
(defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__))
|
||||
(defined( BYTE_ORDER ) && BYTE_ORDER == ORDER_BIG_ENDIAN ) || \
|
||||
(defined(__BYTE_ORDER ) && __BYTE_ORDER == __ORDER_BIG_ENDIAN ) || \
|
||||
(defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__))
|
||||
return a;
|
||||
#else
|
||||
return (((uint8_t*)&a)[0] << 24) |
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
#!/usr/bin/env python2
|
||||
#!/usr/bin/env python
|
||||
|
||||
# This script replaces prefixes of files, and symbols in that file.
|
||||
# Useful for creating different versions of the codebase that don't
|
||||
|
||||
@@ -1,28 +0,0 @@
|
||||
#!/usr/bin/env python2
|
||||
|
||||
import struct
|
||||
import sys
|
||||
import time
|
||||
import os
|
||||
import re
|
||||
|
||||
def main():
|
||||
with open('blocks/.config') as file:
|
||||
read_size, prog_size, block_size, block_count = (
|
||||
struct.unpack('<LLLL', file.read()))
|
||||
|
||||
real_size = sum(
|
||||
os.path.getsize(os.path.join('blocks', f))
|
||||
for f in os.listdir('blocks') if re.match('\d+', f))
|
||||
|
||||
with open('blocks/.stats') as file:
|
||||
read_count, prog_count, erase_count = (
|
||||
struct.unpack('<QQQ', file.read()))
|
||||
|
||||
runtime = time.time() - os.stat('blocks').st_ctime
|
||||
|
||||
print 'results: %dB %dB %dB %.3fs' % (
|
||||
read_count, prog_count, erase_count, runtime)
|
||||
|
||||
if __name__ == "__main__":
|
||||
main(*sys.argv[1:])
|
||||
@@ -1,81 +0,0 @@
|
||||
#!/usr/bin/env python2
|
||||
|
||||
import re
|
||||
import sys
|
||||
import subprocess
|
||||
import os
|
||||
|
||||
|
||||
def generate(test):
|
||||
with open("scripts/template.fmt") as file:
|
||||
template = file.read()
|
||||
|
||||
haslines = 'TEST_LINE' in os.environ and 'TEST_FILE' in os.environ
|
||||
|
||||
lines = []
|
||||
for offset, line in enumerate(
|
||||
re.split('(?<=(?:.;| [{}]))\n', test.read())):
|
||||
match = re.match('((?: *\n)*)( *)(.*)=>(.*);',
|
||||
line, re.DOTALL | re.MULTILINE)
|
||||
if match:
|
||||
preface, tab, test, expect = match.groups()
|
||||
lines.extend(['']*preface.count('\n'))
|
||||
lines.append(tab+'test_assert({test}, {expect});'.format(
|
||||
test=test.strip(), expect=expect.strip()))
|
||||
else:
|
||||
lines.append(line)
|
||||
|
||||
# Create test file
|
||||
with open('test.c', 'w') as file:
|
||||
if 'TEST_LINE' in os.environ and 'TEST_FILE' in os.environ:
|
||||
lines.insert(0, '#line %d "%s"' % (
|
||||
int(os.environ['TEST_LINE']) + 1,
|
||||
os.environ['TEST_FILE']))
|
||||
lines.append('#line %d "test.c"' % (
|
||||
template[:template.find('{tests}')].count('\n')
|
||||
+ len(lines) + 2))
|
||||
|
||||
file.write(template.format(tests='\n'.join(lines)))
|
||||
|
||||
# Remove build artifacts to force rebuild
|
||||
try:
|
||||
os.remove('test.o')
|
||||
os.remove('lfs')
|
||||
except OSError:
|
||||
pass
|
||||
|
||||
def compile():
|
||||
subprocess.check_call([
|
||||
os.environ.get('MAKE', 'make'),
|
||||
'--no-print-directory', '-s'])
|
||||
|
||||
def execute():
|
||||
if 'EXEC' in os.environ:
|
||||
subprocess.check_call([os.environ['EXEC'], "./lfs"])
|
||||
else:
|
||||
subprocess.check_call(["./lfs"])
|
||||
|
||||
def main(test=None):
|
||||
try:
|
||||
if test and not test.startswith('-'):
|
||||
with open(test) as file:
|
||||
generate(file)
|
||||
else:
|
||||
generate(sys.stdin)
|
||||
|
||||
compile()
|
||||
|
||||
if test == '-s':
|
||||
sys.exit(1)
|
||||
|
||||
execute()
|
||||
|
||||
except subprocess.CalledProcessError:
|
||||
# Python stack trace is counterproductive, just exit
|
||||
sys.exit(2)
|
||||
except KeyboardInterrupt:
|
||||
# Python stack trace is counterproductive, just exit
|
||||
sys.exit(3)
|
||||
|
||||
if __name__ == "__main__":
|
||||
main(*sys.argv[1:])
|
||||
@@ -1,4 +1,4 @@
|
||||
#!/usr/bin/env python2
|
||||
#!/usr/bin/env python
|
||||
|
||||
import struct
|
||||
import sys
|
||||
@@ -95,7 +95,7 @@ def main(*blocks):
|
||||
print '%04x: %08x %-15s %3s %4s %-23s %-8s' % (
|
||||
off, tag,
|
||||
typeof(type) + (' bad!' if iscrc and ~crc else ''),
|
||||
hex(id)[2:] if id != 0x3ff else '.',
|
||||
id if id != 0x3ff else '.',
|
||||
size if size != 0x3ff else 'x',
|
||||
' '.join('%02x' % ord(c) for c in data[:8]),
|
||||
''.join(c if c >= ' ' and c <= '~' else '.' for c in data[:8]))
|
||||
30
tests/stats.py
Executable file
30
tests/stats.py
Executable file
@@ -0,0 +1,30 @@
|
||||
#!/usr/bin/env python
|
||||
|
||||
import struct
|
||||
import sys
|
||||
import time
|
||||
import os
|
||||
import re
|
||||
|
||||
def main():
|
||||
with open('blocks/.config') as file:
|
||||
s = struct.unpack('<LLLL', file.read())
|
||||
print 'read_size: %d' % s[0]
|
||||
print 'prog_size: %d' % s[1]
|
||||
print 'block_size: %d' % s[2]
|
||||
print 'block_size: %d' % s[3]
|
||||
|
||||
print 'real_size: %d' % sum(
|
||||
os.path.getsize(os.path.join('blocks', f))
|
||||
for f in os.listdir('blocks') if re.match('\d+', f))
|
||||
|
||||
with open('blocks/.stats') as file:
|
||||
s = struct.unpack('<QQQ', file.read())
|
||||
print 'read_count: %d' % s[0]
|
||||
print 'prog_count: %d' % s[1]
|
||||
print 'erase_count: %d' % s[2]
|
||||
|
||||
print 'runtime: %.3f' % (time.time() - os.stat('blocks').st_ctime)
|
||||
|
||||
if __name__ == "__main__":
|
||||
main(*sys.argv[1:])
|
||||
@@ -7,21 +7,34 @@
|
||||
|
||||
|
||||
// test stuff
|
||||
static void test_log(const char *s, uintmax_t v) {{
|
||||
printf("%s: %jd\n", s, v);
|
||||
}}
|
||||
|
||||
static void test_assert(const char *file, unsigned line,
|
||||
const char *s, uintmax_t v, uintmax_t e) {{
|
||||
static const char *last[6] = {{0, 0}};
|
||||
if (v != e || !(last[0] == s || last[1] == s ||
|
||||
last[2] == s || last[3] == s ||
|
||||
last[4] == s || last[5] == s)) {{
|
||||
test_log(s, v);
|
||||
last[0] = last[1];
|
||||
last[1] = last[2];
|
||||
last[2] = last[3];
|
||||
last[3] = last[4];
|
||||
last[4] = last[5];
|
||||
last[5] = s;
|
||||
}}
|
||||
|
||||
if (v != e) {{
|
||||
fprintf(stderr, "\033[97m%s:%u: \033[91m"
|
||||
"assert failed with %jd, expected %jd\033[0m\n"
|
||||
" %s\n\n", file, line, v, e, s);
|
||||
fprintf(stderr, "\033[31m%s:%u: assert %s failed with %jd, "
|
||||
"expected %jd\033[0m\n", file, line, s, v, e);
|
||||
exit(-2);
|
||||
}}
|
||||
}}
|
||||
|
||||
#define test_assert(v, e) \
|
||||
test_assert(__FILE__, __LINE__, #v " => " #e, v, e)
|
||||
#define test_assert(s, v, e) test_assert(__FILE__, __LINE__, s, v, e)
|
||||
|
||||
// implicit variable for asserts
|
||||
uintmax_t test;
|
||||
|
||||
// utility functions for traversals
|
||||
static int __attribute__((used)) test_count(void *p, lfs_block_t b) {{
|
||||
@@ -31,17 +44,23 @@ static int __attribute__((used)) test_count(void *p, lfs_block_t b) {{
|
||||
return 0;
|
||||
}}
|
||||
|
||||
|
||||
// lfs declarations
|
||||
lfs_t lfs;
|
||||
lfs_emubd_t bd;
|
||||
// other declarations for convenience
|
||||
lfs_file_t file;
|
||||
lfs_dir_t dir;
|
||||
lfs_file_t file[4];
|
||||
lfs_dir_t dir[4];
|
||||
struct lfs_info info;
|
||||
uint8_t buffer[1024];
|
||||
char path[1024];
|
||||
|
||||
// test configuration options
|
||||
uint8_t buffer[1024];
|
||||
uint8_t wbuffer[1024];
|
||||
uint8_t rbuffer[1024];
|
||||
lfs_size_t size;
|
||||
lfs_size_t wsize;
|
||||
lfs_size_t rsize;
|
||||
|
||||
uintmax_t test;
|
||||
|
||||
#ifndef LFS_READ_SIZE
|
||||
#define LFS_READ_SIZE 16
|
||||
#endif
|
||||
@@ -63,7 +82,7 @@ char path[1024];
|
||||
#endif
|
||||
|
||||
#ifndef LFS_CACHE_SIZE
|
||||
#define LFS_CACHE_SIZE (64 % LFS_PROG_SIZE == 0 ? 64 : LFS_PROG_SIZE)
|
||||
#define LFS_CACHE_SIZE 64
|
||||
#endif
|
||||
|
||||
#ifndef LFS_LOOKAHEAD_SIZE
|
||||
@@ -92,5 +111,6 @@ int main(void) {{
|
||||
lfs_emubd_create(&cfg, "blocks");
|
||||
|
||||
{tests}
|
||||
|
||||
lfs_emubd_destroy(&cfg);
|
||||
}}
|
||||
61
tests/test.py
Executable file
61
tests/test.py
Executable file
@@ -0,0 +1,61 @@
|
||||
#!/usr/bin/env python
|
||||
|
||||
import re
|
||||
import sys
|
||||
import subprocess
|
||||
import os
|
||||
|
||||
def generate(test):
|
||||
with open("tests/template.fmt") as file:
|
||||
template = file.read()
|
||||
|
||||
lines = []
|
||||
for line in re.split('(?<=(?:.;| [{}]))\n', test.read()):
|
||||
match = re.match('(?: *\n)*( *)(.*)=>(.*);', line, re.DOTALL | re.MULTILINE)
|
||||
if match:
|
||||
tab, test, expect = match.groups()
|
||||
lines.append(tab+'test = {test};'.format(test=test.strip()))
|
||||
lines.append(tab+'test_assert("{name}", test, {expect});'.format(
|
||||
name = re.match('\w*', test.strip()).group(),
|
||||
expect = expect.strip()))
|
||||
else:
|
||||
lines.append(line)
|
||||
|
||||
# Create test file
|
||||
with open('test.c', 'w') as file:
|
||||
file.write(template.format(tests='\n'.join(lines)))
|
||||
|
||||
# Remove build artifacts to force rebuild
|
||||
try:
|
||||
os.remove('test.o')
|
||||
os.remove('lfs')
|
||||
except OSError:
|
||||
pass
|
||||
|
||||
def compile():
|
||||
subprocess.check_call([
|
||||
os.environ.get('MAKE', 'make'),
|
||||
'--no-print-directory', '-s'])
|
||||
|
||||
def execute():
|
||||
if 'EXEC' in os.environ:
|
||||
subprocess.check_call([os.environ['EXEC'], "./lfs"])
|
||||
else:
|
||||
subprocess.check_call(["./lfs"])
|
||||
|
||||
def main(test=None):
|
||||
if test and not test.startswith('-'):
|
||||
with open(test) as file:
|
||||
generate(file)
|
||||
else:
|
||||
generate(sys.stdin)
|
||||
|
||||
compile()
|
||||
|
||||
if test == '-s':
|
||||
sys.exit(1)
|
||||
|
||||
execute()
|
||||
|
||||
if __name__ == "__main__":
|
||||
main(*sys.argv[1:])
|
||||
@@ -1,18 +1,16 @@
|
||||
#!/bin/bash
|
||||
set -euE
|
||||
export TEST_FILE=$0
|
||||
trap 'export TEST_LINE=$LINENO' DEBUG
|
||||
set -eu
|
||||
|
||||
echo "=== Allocator tests ==="
|
||||
rm -rf blocks
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_format(&lfs, &cfg) => 0;
|
||||
TEST
|
||||
|
||||
SIZE=15000
|
||||
|
||||
lfs_mkdir() {
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_mkdir(&lfs, "$1") => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
@@ -20,7 +18,7 @@ TEST
|
||||
}
|
||||
|
||||
lfs_remove() {
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_remove(&lfs, "$1/eggs") => 0;
|
||||
lfs_remove(&lfs, "$1/bacon") => 0;
|
||||
@@ -31,23 +29,22 @@ TEST
|
||||
}
|
||||
|
||||
lfs_alloc_singleproc() {
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
const char *names[] = {"bacon", "eggs", "pancakes"};
|
||||
lfs_file_t files[sizeof(names)/sizeof(names[0])];
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
for (unsigned n = 0; n < sizeof(names)/sizeof(names[0]); n++) {
|
||||
sprintf(path, "$1/%s", names[n]);
|
||||
lfs_file_open(&lfs, &files[n], path,
|
||||
sprintf((char*)buffer, "$1/%s", names[n]);
|
||||
lfs_file_open(&lfs, &file[n], (char*)buffer,
|
||||
LFS_O_WRONLY | LFS_O_CREAT | LFS_O_APPEND) => 0;
|
||||
}
|
||||
for (unsigned n = 0; n < sizeof(names)/sizeof(names[0]); n++) {
|
||||
lfs_size_t size = strlen(names[n]);
|
||||
size = strlen(names[n]);
|
||||
for (int i = 0; i < $SIZE; i++) {
|
||||
lfs_file_write(&lfs, &files[n], names[n], size) => size;
|
||||
lfs_file_write(&lfs, &file[n], names[n], size) => size;
|
||||
}
|
||||
}
|
||||
for (unsigned n = 0; n < sizeof(names)/sizeof(names[0]); n++) {
|
||||
lfs_file_close(&lfs, &files[n]) => 0;
|
||||
lfs_file_close(&lfs, &file[n]) => 0;
|
||||
}
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
@@ -56,16 +53,16 @@ TEST
|
||||
lfs_alloc_multiproc() {
|
||||
for name in bacon eggs pancakes
|
||||
do
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_file_open(&lfs, &file, "$1/$name",
|
||||
lfs_file_open(&lfs, &file[0], "$1/$name",
|
||||
LFS_O_WRONLY | LFS_O_CREAT | LFS_O_APPEND) => 0;
|
||||
lfs_size_t size = strlen("$name");
|
||||
size = strlen("$name");
|
||||
memcpy(buffer, "$name", size);
|
||||
for (int i = 0; i < $SIZE; i++) {
|
||||
lfs_file_write(&lfs, &file, buffer, size) => size;
|
||||
lfs_file_write(&lfs, &file[0], buffer, size) => size;
|
||||
}
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_file_close(&lfs, &file[0]) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
done
|
||||
@@ -74,15 +71,15 @@ done
|
||||
lfs_verify() {
|
||||
for name in bacon eggs pancakes
|
||||
do
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_file_open(&lfs, &file, "$1/$name", LFS_O_RDONLY) => 0;
|
||||
lfs_size_t size = strlen("$name");
|
||||
lfs_file_open(&lfs, &file[0], "$1/$name", LFS_O_RDONLY) => 0;
|
||||
size = strlen("$name");
|
||||
for (int i = 0; i < $SIZE; i++) {
|
||||
lfs_file_read(&lfs, &file, buffer, size) => size;
|
||||
lfs_file_read(&lfs, &file[0], buffer, size) => size;
|
||||
memcmp(buffer, "$name", size) => 0;
|
||||
}
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_file_close(&lfs, &file[0]) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
done
|
||||
@@ -118,19 +115,19 @@ lfs_remove multiprocreuse
|
||||
lfs_remove singleprocreuse
|
||||
|
||||
echo "--- Exhaustion test ---"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_file_open(&lfs, &file, "exhaustion", LFS_O_WRONLY | LFS_O_CREAT);
|
||||
lfs_size_t size = strlen("exhaustion");
|
||||
lfs_file_open(&lfs, &file[0], "exhaustion", LFS_O_WRONLY | LFS_O_CREAT);
|
||||
size = strlen("exhaustion");
|
||||
memcpy(buffer, "exhaustion", size);
|
||||
lfs_file_write(&lfs, &file, buffer, size) => size;
|
||||
lfs_file_sync(&lfs, &file) => 0;
|
||||
lfs_file_write(&lfs, &file[0], buffer, size) => size;
|
||||
lfs_file_sync(&lfs, &file[0]) => 0;
|
||||
|
||||
size = strlen("blahblahblahblah");
|
||||
memcpy(buffer, "blahblahblahblah", size);
|
||||
lfs_ssize_t res;
|
||||
while (true) {
|
||||
res = lfs_file_write(&lfs, &file, buffer, size);
|
||||
res = lfs_file_write(&lfs, &file[0], buffer, size);
|
||||
if (res < 0) {
|
||||
break;
|
||||
}
|
||||
@@ -139,45 +136,45 @@ scripts/test.py << TEST
|
||||
}
|
||||
res => LFS_ERR_NOSPC;
|
||||
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_file_close(&lfs, &file[0]) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_file_open(&lfs, &file, "exhaustion", LFS_O_RDONLY);
|
||||
lfs_size_t size = strlen("exhaustion");
|
||||
lfs_file_size(&lfs, &file) => size;
|
||||
lfs_file_read(&lfs, &file, buffer, size) => size;
|
||||
lfs_file_open(&lfs, &file[0], "exhaustion", LFS_O_RDONLY);
|
||||
size = strlen("exhaustion");
|
||||
lfs_file_size(&lfs, &file[0]) => size;
|
||||
lfs_file_read(&lfs, &file[0], buffer, size) => size;
|
||||
memcmp(buffer, "exhaustion", size) => 0;
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_file_close(&lfs, &file[0]) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
|
||||
echo "--- Exhaustion wraparound test ---"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_remove(&lfs, "exhaustion") => 0;
|
||||
|
||||
lfs_file_open(&lfs, &file, "padding", LFS_O_WRONLY | LFS_O_CREAT);
|
||||
lfs_size_t size = strlen("buffering");
|
||||
lfs_file_open(&lfs, &file[0], "padding", LFS_O_WRONLY | LFS_O_CREAT);
|
||||
size = strlen("buffering");
|
||||
memcpy(buffer, "buffering", size);
|
||||
for (int i = 0; i < $SIZE; i++) {
|
||||
lfs_file_write(&lfs, &file, buffer, size) => size;
|
||||
lfs_file_write(&lfs, &file[0], buffer, size) => size;
|
||||
}
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_file_close(&lfs, &file[0]) => 0;
|
||||
lfs_remove(&lfs, "padding") => 0;
|
||||
|
||||
lfs_file_open(&lfs, &file, "exhaustion", LFS_O_WRONLY | LFS_O_CREAT);
|
||||
lfs_file_open(&lfs, &file[0], "exhaustion", LFS_O_WRONLY | LFS_O_CREAT);
|
||||
size = strlen("exhaustion");
|
||||
memcpy(buffer, "exhaustion", size);
|
||||
lfs_file_write(&lfs, &file, buffer, size) => size;
|
||||
lfs_file_sync(&lfs, &file) => 0;
|
||||
lfs_file_write(&lfs, &file[0], buffer, size) => size;
|
||||
lfs_file_sync(&lfs, &file[0]) => 0;
|
||||
|
||||
size = strlen("blahblahblahblah");
|
||||
memcpy(buffer, "blahblahblahblah", size);
|
||||
lfs_ssize_t res;
|
||||
while (true) {
|
||||
res = lfs_file_write(&lfs, &file, buffer, size);
|
||||
res = lfs_file_write(&lfs, &file[0], buffer, size);
|
||||
if (res < 0) {
|
||||
break;
|
||||
}
|
||||
@@ -186,34 +183,34 @@ scripts/test.py << TEST
|
||||
}
|
||||
res => LFS_ERR_NOSPC;
|
||||
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_file_close(&lfs, &file[0]) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_file_open(&lfs, &file, "exhaustion", LFS_O_RDONLY);
|
||||
lfs_size_t size = strlen("exhaustion");
|
||||
lfs_file_size(&lfs, &file) => size;
|
||||
lfs_file_read(&lfs, &file, buffer, size) => size;
|
||||
lfs_file_open(&lfs, &file[0], "exhaustion", LFS_O_RDONLY);
|
||||
size = strlen("exhaustion");
|
||||
lfs_file_size(&lfs, &file[0]) => size;
|
||||
lfs_file_read(&lfs, &file[0], buffer, size) => size;
|
||||
memcmp(buffer, "exhaustion", size) => 0;
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_file_close(&lfs, &file[0]) => 0;
|
||||
lfs_remove(&lfs, "exhaustion") => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
|
||||
echo "--- Dir exhaustion test ---"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
|
||||
// find out max file size
|
||||
lfs_mkdir(&lfs, "exhaustiondir") => 0;
|
||||
lfs_size_t size = strlen("blahblahblahblah");
|
||||
size = strlen("blahblahblahblah");
|
||||
memcpy(buffer, "blahblahblahblah", size);
|
||||
lfs_file_open(&lfs, &file, "exhaustion", LFS_O_WRONLY | LFS_O_CREAT);
|
||||
lfs_file_open(&lfs, &file[0], "exhaustion", LFS_O_WRONLY | LFS_O_CREAT);
|
||||
int count = 0;
|
||||
int err;
|
||||
while (true) {
|
||||
err = lfs_file_write(&lfs, &file, buffer, size);
|
||||
err = lfs_file_write(&lfs, &file[0], buffer, size);
|
||||
if (err < 0) {
|
||||
break;
|
||||
}
|
||||
@@ -221,28 +218,28 @@ scripts/test.py << TEST
|
||||
count += 1;
|
||||
}
|
||||
err => LFS_ERR_NOSPC;
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_file_close(&lfs, &file[0]) => 0;
|
||||
|
||||
lfs_remove(&lfs, "exhaustion") => 0;
|
||||
lfs_remove(&lfs, "exhaustiondir") => 0;
|
||||
|
||||
// see if dir fits with max file size
|
||||
lfs_file_open(&lfs, &file, "exhaustion", LFS_O_WRONLY | LFS_O_CREAT);
|
||||
lfs_file_open(&lfs, &file[0], "exhaustion", LFS_O_WRONLY | LFS_O_CREAT);
|
||||
for (int i = 0; i < count; i++) {
|
||||
lfs_file_write(&lfs, &file, buffer, size) => size;
|
||||
lfs_file_write(&lfs, &file[0], buffer, size) => size;
|
||||
}
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_file_close(&lfs, &file[0]) => 0;
|
||||
|
||||
lfs_mkdir(&lfs, "exhaustiondir") => 0;
|
||||
lfs_remove(&lfs, "exhaustiondir") => 0;
|
||||
lfs_remove(&lfs, "exhaustion") => 0;
|
||||
|
||||
// see if dir fits with > max file size
|
||||
lfs_file_open(&lfs, &file, "exhaustion", LFS_O_WRONLY | LFS_O_CREAT);
|
||||
lfs_file_open(&lfs, &file[0], "exhaustion", LFS_O_WRONLY | LFS_O_CREAT);
|
||||
for (int i = 0; i < count+1; i++) {
|
||||
lfs_file_write(&lfs, &file, buffer, size) => size;
|
||||
lfs_file_write(&lfs, &file[0], buffer, size) => size;
|
||||
}
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_file_close(&lfs, &file[0]) => 0;
|
||||
|
||||
lfs_mkdir(&lfs, "exhaustiondir") => LFS_ERR_NOSPC;
|
||||
|
||||
@@ -251,22 +248,22 @@ scripts/test.py << TEST
|
||||
TEST
|
||||
|
||||
echo "--- Chained dir exhaustion test ---"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
|
||||
// find out max file size
|
||||
lfs_mkdir(&lfs, "exhaustiondir") => 0;
|
||||
for (int i = 0; i < 10; i++) {
|
||||
sprintf(path, "dirwithanexhaustivelylongnameforpadding%d", i);
|
||||
lfs_mkdir(&lfs, path) => 0;
|
||||
sprintf((char*)buffer, "dirwithanexhaustivelylongnameforpadding%d", i);
|
||||
lfs_mkdir(&lfs, (char*)buffer) => 0;
|
||||
}
|
||||
lfs_size_t size = strlen("blahblahblahblah");
|
||||
size = strlen("blahblahblahblah");
|
||||
memcpy(buffer, "blahblahblahblah", size);
|
||||
lfs_file_open(&lfs, &file, "exhaustion", LFS_O_WRONLY | LFS_O_CREAT);
|
||||
lfs_file_open(&lfs, &file[0], "exhaustion", LFS_O_WRONLY | LFS_O_CREAT);
|
||||
int count = 0;
|
||||
int err;
|
||||
while (true) {
|
||||
err = lfs_file_write(&lfs, &file, buffer, size);
|
||||
err = lfs_file_write(&lfs, &file[0], buffer, size);
|
||||
if (err < 0) {
|
||||
break;
|
||||
}
|
||||
@@ -274,25 +271,25 @@ scripts/test.py << TEST
|
||||
count += 1;
|
||||
}
|
||||
err => LFS_ERR_NOSPC;
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_file_close(&lfs, &file[0]) => 0;
|
||||
|
||||
lfs_remove(&lfs, "exhaustion") => 0;
|
||||
lfs_remove(&lfs, "exhaustiondir") => 0;
|
||||
for (int i = 0; i < 10; i++) {
|
||||
sprintf(path, "dirwithanexhaustivelylongnameforpadding%d", i);
|
||||
lfs_remove(&lfs, path) => 0;
|
||||
sprintf((char*)buffer, "dirwithanexhaustivelylongnameforpadding%d", i);
|
||||
lfs_remove(&lfs, (char*)buffer) => 0;
|
||||
}
|
||||
|
||||
// see that chained dir fails
|
||||
lfs_file_open(&lfs, &file, "exhaustion", LFS_O_WRONLY | LFS_O_CREAT);
|
||||
lfs_file_open(&lfs, &file[0], "exhaustion", LFS_O_WRONLY | LFS_O_CREAT);
|
||||
for (int i = 0; i < count+1; i++) {
|
||||
lfs_file_write(&lfs, &file, buffer, size) => size;
|
||||
lfs_file_write(&lfs, &file[0], buffer, size) => size;
|
||||
}
|
||||
lfs_file_sync(&lfs, &file) => 0;
|
||||
lfs_file_sync(&lfs, &file[0]) => 0;
|
||||
|
||||
for (int i = 0; i < 10; i++) {
|
||||
sprintf(path, "dirwithanexhaustivelylongnameforpadding%d", i);
|
||||
lfs_mkdir(&lfs, path) => 0;
|
||||
sprintf((char*)buffer, "dirwithanexhaustivelylongnameforpadding%d", i);
|
||||
lfs_mkdir(&lfs, (char*)buffer) => 0;
|
||||
}
|
||||
|
||||
lfs_mkdir(&lfs, "exhaustiondir") => LFS_ERR_NOSPC;
|
||||
@@ -304,44 +301,45 @@ scripts/test.py << TEST
|
||||
break;
|
||||
}
|
||||
|
||||
lfs_ssize_t filesize = lfs_file_size(&lfs, &file);
|
||||
lfs_ssize_t filesize = lfs_file_size(&lfs, &file[0]);
|
||||
filesize > 0 => true;
|
||||
|
||||
lfs_file_truncate(&lfs, &file, filesize - size) => 0;
|
||||
lfs_file_sync(&lfs, &file) => 0;
|
||||
lfs_file_truncate(&lfs, &file[0], filesize - size) => 0;
|
||||
lfs_file_sync(&lfs, &file[0]) => 0;
|
||||
}
|
||||
err => 0;
|
||||
|
||||
lfs_mkdir(&lfs, "exhaustiondir2") => LFS_ERR_NOSPC;
|
||||
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_file_close(&lfs, &file[0]) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
|
||||
echo "--- Split dir test ---"
|
||||
scripts/test.py << TEST
|
||||
rm -rf blocks
|
||||
tests/test.py << TEST
|
||||
lfs_format(&lfs, &cfg) => 0;
|
||||
TEST
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
|
||||
// create one block hole for half a directory
|
||||
lfs_file_open(&lfs, &file, "bump", LFS_O_WRONLY | LFS_O_CREAT) => 0;
|
||||
lfs_file_open(&lfs, &file[0], "bump", LFS_O_WRONLY | LFS_O_CREAT) => 0;
|
||||
for (lfs_size_t i = 0; i < cfg.block_size; i += 2) {
|
||||
memcpy(&buffer[i], "hi", 2);
|
||||
}
|
||||
lfs_file_write(&lfs, &file, buffer, cfg.block_size) => cfg.block_size;
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_file_write(&lfs, &file[0], buffer, cfg.block_size) => cfg.block_size;
|
||||
lfs_file_close(&lfs, &file[0]) => 0;
|
||||
|
||||
lfs_file_open(&lfs, &file, "exhaustion", LFS_O_WRONLY | LFS_O_CREAT);
|
||||
lfs_size_t size = strlen("blahblahblahblah");
|
||||
lfs_file_open(&lfs, &file[0], "exhaustion", LFS_O_WRONLY | LFS_O_CREAT);
|
||||
size = strlen("blahblahblahblah");
|
||||
memcpy(buffer, "blahblahblahblah", size);
|
||||
for (lfs_size_t i = 0;
|
||||
i < (cfg.block_count-4)*(cfg.block_size-8);
|
||||
i += size) {
|
||||
lfs_file_write(&lfs, &file, buffer, size) => size;
|
||||
lfs_file_write(&lfs, &file[0], buffer, size) => size;
|
||||
}
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_file_close(&lfs, &file[0]) => 0;
|
||||
|
||||
// remount to force reset of lookahead
|
||||
lfs_unmount(&lfs) => 0;
|
||||
@@ -351,134 +349,137 @@ scripts/test.py << TEST
|
||||
lfs_remove(&lfs, "bump") => 0;
|
||||
|
||||
lfs_mkdir(&lfs, "splitdir") => 0;
|
||||
lfs_file_open(&lfs, &file, "splitdir/bump",
|
||||
lfs_file_open(&lfs, &file[0], "splitdir/bump",
|
||||
LFS_O_WRONLY | LFS_O_CREAT) => 0;
|
||||
for (lfs_size_t i = 0; i < cfg.block_size; i += 2) {
|
||||
memcpy(&buffer[i], "hi", 2);
|
||||
}
|
||||
lfs_file_write(&lfs, &file, buffer, 2*cfg.block_size) => LFS_ERR_NOSPC;
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_file_write(&lfs, &file[0], buffer, 2*cfg.block_size) => LFS_ERR_NOSPC;
|
||||
lfs_file_close(&lfs, &file[0]) => 0;
|
||||
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
|
||||
echo "--- Outdated lookahead test ---"
|
||||
scripts/test.py << TEST
|
||||
rm -rf blocks
|
||||
tests/test.py << TEST
|
||||
lfs_format(&lfs, &cfg) => 0;
|
||||
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
|
||||
// fill completely with two files
|
||||
lfs_file_open(&lfs, &file, "exhaustion1",
|
||||
lfs_file_open(&lfs, &file[0], "exhaustion1",
|
||||
LFS_O_WRONLY | LFS_O_CREAT) => 0;
|
||||
lfs_size_t size = strlen("blahblahblahblah");
|
||||
size = strlen("blahblahblahblah");
|
||||
memcpy(buffer, "blahblahblahblah", size);
|
||||
for (lfs_size_t i = 0;
|
||||
i < ((cfg.block_count-2)/2)*(cfg.block_size-8);
|
||||
i += size) {
|
||||
lfs_file_write(&lfs, &file, buffer, size) => size;
|
||||
lfs_file_write(&lfs, &file[0], buffer, size) => size;
|
||||
}
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_file_close(&lfs, &file[0]) => 0;
|
||||
|
||||
lfs_file_open(&lfs, &file, "exhaustion2",
|
||||
lfs_file_open(&lfs, &file[0], "exhaustion2",
|
||||
LFS_O_WRONLY | LFS_O_CREAT) => 0;
|
||||
size = strlen("blahblahblahblah");
|
||||
memcpy(buffer, "blahblahblahblah", size);
|
||||
for (lfs_size_t i = 0;
|
||||
i < ((cfg.block_count-2+1)/2)*(cfg.block_size-8);
|
||||
i += size) {
|
||||
lfs_file_write(&lfs, &file, buffer, size) => size;
|
||||
lfs_file_write(&lfs, &file[0], buffer, size) => size;
|
||||
}
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_file_close(&lfs, &file[0]) => 0;
|
||||
|
||||
// remount to force reset of lookahead
|
||||
lfs_unmount(&lfs) => 0;
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
|
||||
// rewrite one file
|
||||
lfs_file_open(&lfs, &file, "exhaustion1",
|
||||
lfs_file_open(&lfs, &file[0], "exhaustion1",
|
||||
LFS_O_WRONLY | LFS_O_TRUNC) => 0;
|
||||
lfs_file_sync(&lfs, &file) => 0;
|
||||
lfs_file_sync(&lfs, &file[0]) => 0;
|
||||
size = strlen("blahblahblahblah");
|
||||
memcpy(buffer, "blahblahblahblah", size);
|
||||
for (lfs_size_t i = 0;
|
||||
i < ((cfg.block_count-2)/2)*(cfg.block_size-8);
|
||||
i += size) {
|
||||
lfs_file_write(&lfs, &file, buffer, size) => size;
|
||||
lfs_file_write(&lfs, &file[0], buffer, size) => size;
|
||||
}
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_file_close(&lfs, &file[0]) => 0;
|
||||
|
||||
// rewrite second file, this requires lookahead does not
|
||||
// use old population
|
||||
lfs_file_open(&lfs, &file, "exhaustion2",
|
||||
lfs_file_open(&lfs, &file[0], "exhaustion2",
|
||||
LFS_O_WRONLY | LFS_O_TRUNC) => 0;
|
||||
lfs_file_sync(&lfs, &file) => 0;
|
||||
lfs_file_sync(&lfs, &file[0]) => 0;
|
||||
size = strlen("blahblahblahblah");
|
||||
memcpy(buffer, "blahblahblahblah", size);
|
||||
for (lfs_size_t i = 0;
|
||||
i < ((cfg.block_count-2+1)/2)*(cfg.block_size-8);
|
||||
i += size) {
|
||||
lfs_file_write(&lfs, &file, buffer, size) => size;
|
||||
lfs_file_write(&lfs, &file[0], buffer, size) => size;
|
||||
}
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_file_close(&lfs, &file[0]) => 0;
|
||||
TEST
|
||||
|
||||
echo "--- Outdated lookahead and split dir test ---"
|
||||
scripts/test.py << TEST
|
||||
rm -rf blocks
|
||||
tests/test.py << TEST
|
||||
lfs_format(&lfs, &cfg) => 0;
|
||||
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
|
||||
// fill completely with two files
|
||||
lfs_file_open(&lfs, &file, "exhaustion1",
|
||||
lfs_file_open(&lfs, &file[0], "exhaustion1",
|
||||
LFS_O_WRONLY | LFS_O_CREAT) => 0;
|
||||
lfs_size_t size = strlen("blahblahblahblah");
|
||||
size = strlen("blahblahblahblah");
|
||||
memcpy(buffer, "blahblahblahblah", size);
|
||||
for (lfs_size_t i = 0;
|
||||
i < ((cfg.block_count-2)/2)*(cfg.block_size-8);
|
||||
i += size) {
|
||||
lfs_file_write(&lfs, &file, buffer, size) => size;
|
||||
lfs_file_write(&lfs, &file[0], buffer, size) => size;
|
||||
}
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_file_close(&lfs, &file[0]) => 0;
|
||||
|
||||
lfs_file_open(&lfs, &file, "exhaustion2",
|
||||
lfs_file_open(&lfs, &file[0], "exhaustion2",
|
||||
LFS_O_WRONLY | LFS_O_CREAT) => 0;
|
||||
size = strlen("blahblahblahblah");
|
||||
memcpy(buffer, "blahblahblahblah", size);
|
||||
for (lfs_size_t i = 0;
|
||||
i < ((cfg.block_count-2+1)/2)*(cfg.block_size-8);
|
||||
i += size) {
|
||||
lfs_file_write(&lfs, &file, buffer, size) => size;
|
||||
lfs_file_write(&lfs, &file[0], buffer, size) => size;
|
||||
}
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_file_close(&lfs, &file[0]) => 0;
|
||||
|
||||
// remount to force reset of lookahead
|
||||
lfs_unmount(&lfs) => 0;
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
|
||||
// rewrite one file with a hole of one block
|
||||
lfs_file_open(&lfs, &file, "exhaustion1",
|
||||
lfs_file_open(&lfs, &file[0], "exhaustion1",
|
||||
LFS_O_WRONLY | LFS_O_TRUNC) => 0;
|
||||
lfs_file_sync(&lfs, &file) => 0;
|
||||
lfs_file_sync(&lfs, &file[0]) => 0;
|
||||
size = strlen("blahblahblahblah");
|
||||
memcpy(buffer, "blahblahblahblah", size);
|
||||
for (lfs_size_t i = 0;
|
||||
i < ((cfg.block_count-2)/2 - 1)*(cfg.block_size-8);
|
||||
i += size) {
|
||||
lfs_file_write(&lfs, &file, buffer, size) => size;
|
||||
lfs_file_write(&lfs, &file[0], buffer, size) => size;
|
||||
}
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_file_close(&lfs, &file[0]) => 0;
|
||||
|
||||
// try to allocate a directory, should fail!
|
||||
lfs_mkdir(&lfs, "split") => LFS_ERR_NOSPC;
|
||||
|
||||
// file should not fail
|
||||
lfs_file_open(&lfs, &file, "notasplit",
|
||||
lfs_file_open(&lfs, &file[0], "notasplit",
|
||||
LFS_O_WRONLY | LFS_O_CREAT) => 0;
|
||||
lfs_file_write(&lfs, &file, "hi", 2) => 2;
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_file_write(&lfs, &file[0], "hi", 2) => 2;
|
||||
lfs_file_close(&lfs, &file[0]) => 0;
|
||||
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
|
||||
scripts/results.py
|
||||
echo "--- Results ---"
|
||||
tests/stats.py
|
||||
|
||||
@@ -1,27 +1,24 @@
|
||||
#!/bin/bash
|
||||
set -eu
|
||||
export TEST_FILE=$0
|
||||
trap 'export TEST_LINE=$LINENO' DEBUG
|
||||
|
||||
echo "=== Attr tests ==="
|
||||
rm -rf blocks
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_format(&lfs, &cfg) => 0;
|
||||
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_mkdir(&lfs, "hello") => 0;
|
||||
lfs_file_open(&lfs, &file, "hello/hello",
|
||||
lfs_file_open(&lfs, &file[0], "hello/hello",
|
||||
LFS_O_WRONLY | LFS_O_CREAT) => 0;
|
||||
lfs_file_write(&lfs, &file, "hello", strlen("hello"))
|
||||
lfs_file_write(&lfs, &file[0], "hello", strlen("hello"))
|
||||
=> strlen("hello");
|
||||
lfs_file_close(&lfs, &file);
|
||||
lfs_file_close(&lfs, &file[0]);
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
|
||||
echo "--- Set/get attribute ---"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
memset(buffer, 0, sizeof(buffer));
|
||||
lfs_setattr(&lfs, "hello", 'A', "aaaa", 4) => 0;
|
||||
lfs_setattr(&lfs, "hello", 'B', "bbbbbb", 6) => 0;
|
||||
lfs_setattr(&lfs, "hello", 'C', "ccccc", 5) => 0;
|
||||
@@ -72,9 +69,8 @@ scripts/test.py << TEST
|
||||
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
memset(buffer, 0, sizeof(buffer));
|
||||
lfs_getattr(&lfs, "hello", 'A', buffer, 4) => 4;
|
||||
lfs_getattr(&lfs, "hello", 'B', buffer+4, 9) => 9;
|
||||
lfs_getattr(&lfs, "hello", 'C', buffer+13, 5) => 5;
|
||||
@@ -82,17 +78,16 @@ scripts/test.py << TEST
|
||||
memcmp(buffer+4, "fffffffff", 9) => 0;
|
||||
memcmp(buffer+13, "ccccc", 5) => 0;
|
||||
|
||||
lfs_file_open(&lfs, &file, "hello/hello", LFS_O_RDONLY) => 0;
|
||||
lfs_file_read(&lfs, &file, buffer, sizeof(buffer)) => strlen("hello");
|
||||
lfs_file_open(&lfs, &file[0], "hello/hello", LFS_O_RDONLY) => 0;
|
||||
lfs_file_read(&lfs, &file[0], buffer, sizeof(buffer)) => strlen("hello");
|
||||
memcmp(buffer, "hello", strlen("hello")) => 0;
|
||||
lfs_file_close(&lfs, &file);
|
||||
lfs_file_close(&lfs, &file[0]);
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
|
||||
echo "--- Set/get root attribute ---"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
memset(buffer, 0, sizeof(buffer));
|
||||
lfs_setattr(&lfs, "/", 'A', "aaaa", 4) => 0;
|
||||
lfs_setattr(&lfs, "/", 'B', "bbbbbb", 6) => 0;
|
||||
lfs_setattr(&lfs, "/", 'C', "ccccc", 5) => 0;
|
||||
@@ -142,9 +137,8 @@ scripts/test.py << TEST
|
||||
lfs_getattr(&lfs, "/", 'C', buffer+10, 5) => 5;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
memset(buffer, 0, sizeof(buffer));
|
||||
lfs_getattr(&lfs, "/", 'A', buffer, 4) => 4;
|
||||
lfs_getattr(&lfs, "/", 'B', buffer+4, 9) => 9;
|
||||
lfs_getattr(&lfs, "/", 'C', buffer+13, 5) => 5;
|
||||
@@ -152,17 +146,16 @@ scripts/test.py << TEST
|
||||
memcmp(buffer+4, "fffffffff", 9) => 0;
|
||||
memcmp(buffer+13, "ccccc", 5) => 0;
|
||||
|
||||
lfs_file_open(&lfs, &file, "hello/hello", LFS_O_RDONLY) => 0;
|
||||
lfs_file_read(&lfs, &file, buffer, sizeof(buffer)) => strlen("hello");
|
||||
lfs_file_open(&lfs, &file[0], "hello/hello", LFS_O_RDONLY) => 0;
|
||||
lfs_file_read(&lfs, &file[0], buffer, sizeof(buffer)) => strlen("hello");
|
||||
memcmp(buffer, "hello", strlen("hello")) => 0;
|
||||
lfs_file_close(&lfs, &file);
|
||||
lfs_file_close(&lfs, &file[0]);
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
|
||||
echo "--- Set/get file attribute ---"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
memset(buffer, 0, sizeof(buffer));
|
||||
struct lfs_attr attrs1[] = {
|
||||
{'A', buffer, 4},
|
||||
{'B', buffer+4, 6},
|
||||
@@ -170,55 +163,55 @@ scripts/test.py << TEST
|
||||
};
|
||||
struct lfs_file_config cfg1 = {.attrs=attrs1, .attr_count=3};
|
||||
|
||||
lfs_file_opencfg(&lfs, &file, "hello/hello", LFS_O_WRONLY, &cfg1) => 0;
|
||||
lfs_file_opencfg(&lfs, &file[0], "hello/hello", LFS_O_WRONLY, &cfg1) => 0;
|
||||
memcpy(buffer, "aaaa", 4);
|
||||
memcpy(buffer+4, "bbbbbb", 6);
|
||||
memcpy(buffer+10, "ccccc", 5);
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_file_close(&lfs, &file[0]) => 0;
|
||||
memset(buffer, 0, 15);
|
||||
lfs_file_opencfg(&lfs, &file, "hello/hello", LFS_O_RDONLY, &cfg1) => 0;
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_file_opencfg(&lfs, &file[0], "hello/hello", LFS_O_RDONLY, &cfg1) => 0;
|
||||
lfs_file_close(&lfs, &file[0]) => 0;
|
||||
memcmp(buffer, "aaaa", 4) => 0;
|
||||
memcmp(buffer+4, "bbbbbb", 6) => 0;
|
||||
memcmp(buffer+10, "ccccc", 5) => 0;
|
||||
|
||||
attrs1[1].size = 0;
|
||||
lfs_file_opencfg(&lfs, &file, "hello/hello", LFS_O_WRONLY, &cfg1) => 0;
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_file_opencfg(&lfs, &file[0], "hello/hello", LFS_O_WRONLY, &cfg1) => 0;
|
||||
lfs_file_close(&lfs, &file[0]) => 0;
|
||||
memset(buffer, 0, 15);
|
||||
attrs1[1].size = 6;
|
||||
lfs_file_opencfg(&lfs, &file, "hello/hello", LFS_O_RDONLY, &cfg1) => 0;
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_file_opencfg(&lfs, &file[0], "hello/hello", LFS_O_RDONLY, &cfg1) => 0;
|
||||
lfs_file_close(&lfs, &file[0]) => 0;
|
||||
memcmp(buffer, "aaaa", 4) => 0;
|
||||
memcmp(buffer+4, "\0\0\0\0\0\0", 6) => 0;
|
||||
memcmp(buffer+10, "ccccc", 5) => 0;
|
||||
|
||||
attrs1[1].size = 6;
|
||||
lfs_file_opencfg(&lfs, &file, "hello/hello", LFS_O_WRONLY, &cfg1) => 0;
|
||||
lfs_file_opencfg(&lfs, &file[0], "hello/hello", LFS_O_WRONLY, &cfg1) => 0;
|
||||
memcpy(buffer+4, "dddddd", 6);
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_file_close(&lfs, &file[0]) => 0;
|
||||
memset(buffer, 0, 15);
|
||||
attrs1[1].size = 6;
|
||||
lfs_file_opencfg(&lfs, &file, "hello/hello", LFS_O_RDONLY, &cfg1) => 0;
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_file_opencfg(&lfs, &file[0], "hello/hello", LFS_O_RDONLY, &cfg1) => 0;
|
||||
lfs_file_close(&lfs, &file[0]) => 0;
|
||||
memcmp(buffer, "aaaa", 4) => 0;
|
||||
memcmp(buffer+4, "dddddd", 6) => 0;
|
||||
memcmp(buffer+10, "ccccc", 5) => 0;
|
||||
|
||||
attrs1[1].size = 3;
|
||||
lfs_file_opencfg(&lfs, &file, "hello/hello", LFS_O_WRONLY, &cfg1) => 0;
|
||||
lfs_file_opencfg(&lfs, &file[0], "hello/hello", LFS_O_WRONLY, &cfg1) => 0;
|
||||
memcpy(buffer+4, "eee", 3);
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_file_close(&lfs, &file[0]) => 0;
|
||||
memset(buffer, 0, 15);
|
||||
attrs1[1].size = 6;
|
||||
lfs_file_opencfg(&lfs, &file, "hello/hello", LFS_O_RDONLY, &cfg1) => 0;
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_file_opencfg(&lfs, &file[0], "hello/hello", LFS_O_RDONLY, &cfg1) => 0;
|
||||
lfs_file_close(&lfs, &file[0]) => 0;
|
||||
memcmp(buffer, "aaaa", 4) => 0;
|
||||
memcmp(buffer+4, "eee\0\0\0", 6) => 0;
|
||||
memcmp(buffer+10, "ccccc", 5) => 0;
|
||||
|
||||
attrs1[0].size = LFS_ATTR_MAX+1;
|
||||
lfs_file_opencfg(&lfs, &file, "hello/hello", LFS_O_WRONLY, &cfg1)
|
||||
lfs_file_opencfg(&lfs, &file[0], "hello/hello", LFS_O_WRONLY, &cfg1)
|
||||
=> LFS_ERR_NOSPC;
|
||||
|
||||
struct lfs_attr attrs2[] = {
|
||||
@@ -227,18 +220,17 @@ scripts/test.py << TEST
|
||||
{'C', buffer+13, 5},
|
||||
};
|
||||
struct lfs_file_config cfg2 = {.attrs=attrs2, .attr_count=3};
|
||||
lfs_file_opencfg(&lfs, &file, "hello/hello", LFS_O_RDWR, &cfg2) => 0;
|
||||
lfs_file_opencfg(&lfs, &file[0], "hello/hello", LFS_O_RDWR, &cfg2) => 0;
|
||||
memcpy(buffer+4, "fffffffff", 9);
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_file_close(&lfs, &file[0]) => 0;
|
||||
attrs1[0].size = 4;
|
||||
lfs_file_opencfg(&lfs, &file, "hello/hello", LFS_O_RDONLY, &cfg1) => 0;
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_file_opencfg(&lfs, &file[0], "hello/hello", LFS_O_RDONLY, &cfg1) => 0;
|
||||
lfs_file_close(&lfs, &file[0]) => 0;
|
||||
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
memset(buffer, 0, sizeof(buffer));
|
||||
struct lfs_attr attrs2[] = {
|
||||
{'A', buffer, 4},
|
||||
{'B', buffer+4, 9},
|
||||
@@ -246,23 +238,22 @@ scripts/test.py << TEST
|
||||
};
|
||||
struct lfs_file_config cfg2 = {.attrs=attrs2, .attr_count=3};
|
||||
|
||||
lfs_file_opencfg(&lfs, &file, "hello/hello", LFS_O_RDONLY, &cfg2) => 0;
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_file_opencfg(&lfs, &file[0], "hello/hello", LFS_O_RDONLY, &cfg2) => 0;
|
||||
lfs_file_close(&lfs, &file[0]) => 0;
|
||||
memcmp(buffer, "aaaa", 4) => 0;
|
||||
memcmp(buffer+4, "fffffffff", 9) => 0;
|
||||
memcmp(buffer+13, "ccccc", 5) => 0;
|
||||
|
||||
lfs_file_open(&lfs, &file, "hello/hello", LFS_O_RDONLY) => 0;
|
||||
lfs_file_read(&lfs, &file, buffer, sizeof(buffer)) => strlen("hello");
|
||||
lfs_file_open(&lfs, &file[0], "hello/hello", LFS_O_RDONLY) => 0;
|
||||
lfs_file_read(&lfs, &file[0], buffer, sizeof(buffer)) => strlen("hello");
|
||||
memcmp(buffer, "hello", strlen("hello")) => 0;
|
||||
lfs_file_close(&lfs, &file);
|
||||
lfs_file_close(&lfs, &file[0]);
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
|
||||
echo "--- Deferred file attributes ---"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
memset(buffer, 0, sizeof(buffer));
|
||||
struct lfs_attr attrs1[] = {
|
||||
{'B', "gggg", 4},
|
||||
{'C', "", 0},
|
||||
@@ -270,7 +261,7 @@ scripts/test.py << TEST
|
||||
};
|
||||
struct lfs_file_config cfg1 = {.attrs=attrs1, .attr_count=3};
|
||||
|
||||
lfs_file_opencfg(&lfs, &file, "hello/hello", LFS_O_WRONLY, &cfg1) => 0;
|
||||
lfs_file_opencfg(&lfs, &file[0], "hello/hello", LFS_O_WRONLY, &cfg1) => 0;
|
||||
|
||||
lfs_getattr(&lfs, "hello/hello", 'B', buffer, 9) => 9;
|
||||
lfs_getattr(&lfs, "hello/hello", 'C', buffer+9, 9) => 5;
|
||||
@@ -279,7 +270,7 @@ scripts/test.py << TEST
|
||||
memcmp(buffer+9, "ccccc\0\0\0\0", 9) => 0;
|
||||
memcmp(buffer+18, "\0\0\0\0\0\0\0\0\0", 9) => 0;
|
||||
|
||||
lfs_file_sync(&lfs, &file) => 0;
|
||||
lfs_file_sync(&lfs, &file[0]) => 0;
|
||||
lfs_getattr(&lfs, "hello/hello", 'B', buffer, 9) => 4;
|
||||
lfs_getattr(&lfs, "hello/hello", 'C', buffer+9, 9) => 0;
|
||||
lfs_getattr(&lfs, "hello/hello", 'D', buffer+18, 9) => 4;
|
||||
@@ -287,8 +278,9 @@ scripts/test.py << TEST
|
||||
memcmp(buffer+9, "\0\0\0\0\0\0\0\0\0", 9) => 0;
|
||||
memcmp(buffer+18, "hhhh\0\0\0\0\0", 9) => 0;
|
||||
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_file_close(&lfs, &file[0]) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
|
||||
scripts/results.py
|
||||
echo "--- Results ---"
|
||||
tests/stats.py
|
||||
|
||||
@@ -1,7 +1,5 @@
|
||||
#!/bin/bash
|
||||
set -eu
|
||||
export TEST_FILE=$0
|
||||
trap 'export TEST_LINE=$LINENO' DEBUG
|
||||
|
||||
echo "=== Corrupt tests ==="
|
||||
|
||||
@@ -9,7 +7,7 @@ NAMEMULT=64
|
||||
FILEMULT=1
|
||||
|
||||
lfs_mktree() {
|
||||
scripts/test.py ${1:-} << TEST
|
||||
tests/test.py ${1:-} << TEST
|
||||
lfs_format(&lfs, &cfg) => 0;
|
||||
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
@@ -25,22 +23,22 @@ scripts/test.py ${1:-} << TEST
|
||||
buffer[j+$NAMEMULT+1] = '0'+i;
|
||||
}
|
||||
buffer[2*$NAMEMULT+1] = '\0';
|
||||
lfs_file_open(&lfs, &file, (char*)buffer,
|
||||
lfs_file_open(&lfs, &file[0], (char*)buffer,
|
||||
LFS_O_WRONLY | LFS_O_CREAT) => 0;
|
||||
|
||||
lfs_size_t size = $NAMEMULT;
|
||||
size = $NAMEMULT;
|
||||
for (int j = 0; j < i*$FILEMULT; j++) {
|
||||
lfs_file_write(&lfs, &file, buffer, size) => size;
|
||||
lfs_file_write(&lfs, &file[0], buffer, size) => size;
|
||||
}
|
||||
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_file_close(&lfs, &file[0]) => 0;
|
||||
}
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
}
|
||||
|
||||
lfs_chktree() {
|
||||
scripts/test.py ${1:-} << TEST
|
||||
tests/test.py ${1:-} << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
for (int i = 1; i < 10; i++) {
|
||||
for (int j = 0; j < $NAMEMULT; j++) {
|
||||
@@ -55,16 +53,15 @@ scripts/test.py ${1:-} << TEST
|
||||
buffer[j+$NAMEMULT+1] = '0'+i;
|
||||
}
|
||||
buffer[2*$NAMEMULT+1] = '\0';
|
||||
lfs_file_open(&lfs, &file, (char*)buffer, LFS_O_RDONLY) => 0;
|
||||
lfs_file_open(&lfs, &file[0], (char*)buffer, LFS_O_RDONLY) => 0;
|
||||
|
||||
lfs_size_t size = $NAMEMULT;
|
||||
size = $NAMEMULT;
|
||||
for (int j = 0; j < i*$FILEMULT; j++) {
|
||||
uint8_t rbuffer[1024];
|
||||
lfs_file_read(&lfs, &file, rbuffer, size) => size;
|
||||
lfs_file_read(&lfs, &file[0], rbuffer, size) => size;
|
||||
memcmp(buffer, rbuffer, size) => 0;
|
||||
}
|
||||
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_file_close(&lfs, &file[0]) => 0;
|
||||
}
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
@@ -117,4 +114,5 @@ done
|
||||
lfs_mktree
|
||||
lfs_chktree
|
||||
|
||||
scripts/results.py
|
||||
echo "--- Results ---"
|
||||
tests/stats.py
|
||||
|
||||
@@ -1,191 +1,188 @@
|
||||
#!/bin/bash
|
||||
set -eu
|
||||
export TEST_FILE=$0
|
||||
trap 'export TEST_LINE=$LINENO' DEBUG
|
||||
|
||||
echo "=== Directory tests ==="
|
||||
|
||||
LARGESIZE=128
|
||||
|
||||
echo "=== Directory tests ==="
|
||||
rm -rf blocks
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_format(&lfs, &cfg) => 0;
|
||||
TEST
|
||||
|
||||
echo "--- Root directory ---"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "/") => 0;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
lfs_dir_open(&lfs, &dir[0], "/") => 0;
|
||||
lfs_dir_close(&lfs, &dir[0]) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
|
||||
echo "--- Directory creation ---"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_mkdir(&lfs, "potato") => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
|
||||
echo "--- File creation ---"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_file_open(&lfs, &file, "burito", LFS_O_CREAT | LFS_O_WRONLY) => 0;
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_file_open(&lfs, &file[0], "burito", LFS_O_CREAT | LFS_O_WRONLY) => 0;
|
||||
lfs_file_close(&lfs, &file[0]) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
|
||||
echo "--- Directory iteration ---"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "/") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_open(&lfs, &dir[0], "/") => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, ".") => 0;
|
||||
info.type => LFS_TYPE_DIR;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "..") => 0;
|
||||
info.type => LFS_TYPE_DIR;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "burito") => 0;
|
||||
info.type => LFS_TYPE_REG;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "potato") => 0;
|
||||
info.type => LFS_TYPE_DIR;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 0;
|
||||
lfs_dir_close(&lfs, &dir[0]) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
|
||||
echo "--- Directory failures ---"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_mkdir(&lfs, "potato") => LFS_ERR_EXIST;
|
||||
lfs_dir_open(&lfs, &dir, "tomato") => LFS_ERR_NOENT;
|
||||
lfs_dir_open(&lfs, &dir, "burito") => LFS_ERR_NOTDIR;
|
||||
lfs_file_open(&lfs, &file, "tomato", LFS_O_RDONLY) => LFS_ERR_NOENT;
|
||||
lfs_file_open(&lfs, &file, "potato", LFS_O_RDONLY) => LFS_ERR_ISDIR;
|
||||
lfs_dir_open(&lfs, &dir[0], "tomato") => LFS_ERR_NOENT;
|
||||
lfs_dir_open(&lfs, &dir[0], "burito") => LFS_ERR_NOTDIR;
|
||||
lfs_file_open(&lfs, &file[0], "tomato", LFS_O_RDONLY) => LFS_ERR_NOENT;
|
||||
lfs_file_open(&lfs, &file[0], "potato", LFS_O_RDONLY) => LFS_ERR_ISDIR;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
|
||||
echo "--- Nested directories ---"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_mkdir(&lfs, "potato/baked") => 0;
|
||||
lfs_mkdir(&lfs, "potato/sweet") => 0;
|
||||
lfs_mkdir(&lfs, "potato/fried") => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "potato") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_open(&lfs, &dir[0], "potato") => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, ".") => 0;
|
||||
info.type => LFS_TYPE_DIR;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "..") => 0;
|
||||
info.type => LFS_TYPE_DIR;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "baked") => 0;
|
||||
info.type => LFS_TYPE_DIR;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "fried") => 0;
|
||||
info.type => LFS_TYPE_DIR;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "sweet") => 0;
|
||||
info.type => LFS_TYPE_DIR;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 0;
|
||||
lfs_dir_close(&lfs, &dir[0]) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
|
||||
echo "--- Multi-block directory ---"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_mkdir(&lfs, "cactus") => 0;
|
||||
for (int i = 0; i < $LARGESIZE; i++) {
|
||||
sprintf(path, "cactus/test%03d", i);
|
||||
lfs_mkdir(&lfs, path) => 0;
|
||||
sprintf((char*)buffer, "cactus/test%03d", i);
|
||||
lfs_mkdir(&lfs, (char*)buffer) => 0;
|
||||
}
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "cactus") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_open(&lfs, &dir[0], "cactus") => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, ".") => 0;
|
||||
info.type => LFS_TYPE_DIR;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "..") => 0;
|
||||
info.type => LFS_TYPE_DIR;
|
||||
for (int i = 0; i < $LARGESIZE; i++) {
|
||||
sprintf(path, "test%03d", i);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
strcmp(info.name, path) => 0;
|
||||
sprintf((char*)buffer, "test%03d", i);
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, (char*)buffer) => 0;
|
||||
info.type => LFS_TYPE_DIR;
|
||||
}
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
|
||||
echo "--- Directory remove ---"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_remove(&lfs, "potato") => LFS_ERR_NOTEMPTY;
|
||||
lfs_remove(&lfs, "potato/sweet") => 0;
|
||||
lfs_remove(&lfs, "potato/baked") => 0;
|
||||
lfs_remove(&lfs, "potato/fried") => 0;
|
||||
|
||||
lfs_dir_open(&lfs, &dir, "potato") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_open(&lfs, &dir[0], "potato") => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, ".") => 0;
|
||||
info.type => LFS_TYPE_DIR;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "..") => 0;
|
||||
info.type => LFS_TYPE_DIR;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 0;
|
||||
lfs_dir_close(&lfs, &dir[0]) => 0;
|
||||
|
||||
lfs_remove(&lfs, "potato") => 0;
|
||||
|
||||
lfs_dir_open(&lfs, &dir, "/") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_open(&lfs, &dir[0], "/") => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, ".") => 0;
|
||||
info.type => LFS_TYPE_DIR;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "..") => 0;
|
||||
info.type => LFS_TYPE_DIR;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "burito") => 0;
|
||||
info.type => LFS_TYPE_REG;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "cactus") => 0;
|
||||
info.type => LFS_TYPE_DIR;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 0;
|
||||
lfs_dir_close(&lfs, &dir[0]) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "/") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_open(&lfs, &dir[0], "/") => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, ".") => 0;
|
||||
info.type => LFS_TYPE_DIR;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "..") => 0;
|
||||
info.type => LFS_TYPE_DIR;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "burito") => 0;
|
||||
info.type => LFS_TYPE_REG;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "cactus") => 0;
|
||||
info.type => LFS_TYPE_DIR;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 0;
|
||||
lfs_dir_close(&lfs, &dir[0]) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
|
||||
echo "--- Directory rename ---"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_mkdir(&lfs, "coldpotato") => 0;
|
||||
lfs_mkdir(&lfs, "coldpotato/baked") => 0;
|
||||
@@ -193,34 +190,34 @@ scripts/test.py << TEST
|
||||
lfs_mkdir(&lfs, "coldpotato/fried") => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_rename(&lfs, "coldpotato", "hotpotato") => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "hotpotato") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_open(&lfs, &dir[0], "hotpotato") => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, ".") => 0;
|
||||
info.type => LFS_TYPE_DIR;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "..") => 0;
|
||||
info.type => LFS_TYPE_DIR;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "baked") => 0;
|
||||
info.type => LFS_TYPE_DIR;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "fried") => 0;
|
||||
info.type => LFS_TYPE_DIR;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "sweet") => 0;
|
||||
info.type => LFS_TYPE_DIR;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 0;
|
||||
lfs_dir_close(&lfs, &dir[0]) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_mkdir(&lfs, "warmpotato") => 0;
|
||||
lfs_mkdir(&lfs, "warmpotato/mushy") => 0;
|
||||
@@ -231,29 +228,29 @@ scripts/test.py << TEST
|
||||
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "warmpotato") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_open(&lfs, &dir[0], "warmpotato") => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, ".") => 0;
|
||||
info.type => LFS_TYPE_DIR;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "..") => 0;
|
||||
info.type => LFS_TYPE_DIR;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "baked") => 0;
|
||||
info.type => LFS_TYPE_DIR;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "fried") => 0;
|
||||
info.type => LFS_TYPE_DIR;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "sweet") => 0;
|
||||
info.type => LFS_TYPE_DIR;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 0;
|
||||
lfs_dir_close(&lfs, &dir[0]) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_mkdir(&lfs, "coldpotato") => 0;
|
||||
lfs_rename(&lfs, "warmpotato/baked", "coldpotato/baked") => 0;
|
||||
@@ -263,227 +260,225 @@ scripts/test.py << TEST
|
||||
lfs_remove(&lfs, "warmpotato") => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "coldpotato") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_open(&lfs, &dir[0], "coldpotato") => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, ".") => 0;
|
||||
info.type => LFS_TYPE_DIR;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "..") => 0;
|
||||
info.type => LFS_TYPE_DIR;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "baked") => 0;
|
||||
info.type => LFS_TYPE_DIR;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "fried") => 0;
|
||||
info.type => LFS_TYPE_DIR;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "sweet") => 0;
|
||||
info.type => LFS_TYPE_DIR;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 0;
|
||||
lfs_dir_close(&lfs, &dir[0]) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
|
||||
echo "--- Recursive remove ---"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_remove(&lfs, "coldpotato") => LFS_ERR_NOTEMPTY;
|
||||
|
||||
lfs_dir_open(&lfs, &dir, "coldpotato") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_open(&lfs, &dir[0], "coldpotato") => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
|
||||
while (true) {
|
||||
int err = lfs_dir_read(&lfs, &dir, &info);
|
||||
int err = lfs_dir_read(&lfs, &dir[0], &info);
|
||||
err >= 0 => 1;
|
||||
if (err == 0) {
|
||||
break;
|
||||
}
|
||||
|
||||
strcpy(path, "coldpotato/");
|
||||
strcat(path, info.name);
|
||||
lfs_remove(&lfs, path) => 0;
|
||||
strcpy((char*)buffer, "coldpotato/");
|
||||
strcat((char*)buffer, info.name);
|
||||
lfs_remove(&lfs, (char*)buffer) => 0;
|
||||
}
|
||||
|
||||
lfs_remove(&lfs, "coldpotato") => 0;
|
||||
TEST
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "/") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_open(&lfs, &dir[0], "/") => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, ".") => 0;
|
||||
info.type => LFS_TYPE_DIR;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "..") => 0;
|
||||
info.type => LFS_TYPE_DIR;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "burito") => 0;
|
||||
info.type => LFS_TYPE_REG;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "cactus") => 0;
|
||||
info.type => LFS_TYPE_DIR;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 0;
|
||||
lfs_dir_close(&lfs, &dir[0]) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
|
||||
echo "--- Multi-block rename ---"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
for (int i = 0; i < $LARGESIZE; i++) {
|
||||
char oldpath[1024];
|
||||
char newpath[1024];
|
||||
sprintf(oldpath, "cactus/test%03d", i);
|
||||
sprintf(newpath, "cactus/tedd%03d", i);
|
||||
lfs_rename(&lfs, oldpath, newpath) => 0;
|
||||
sprintf((char*)buffer, "cactus/test%03d", i);
|
||||
sprintf((char*)wbuffer, "cactus/tedd%03d", i);
|
||||
lfs_rename(&lfs, (char*)buffer, (char*)wbuffer) => 0;
|
||||
}
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "cactus") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_open(&lfs, &dir[0], "cactus") => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, ".") => 0;
|
||||
info.type => LFS_TYPE_DIR;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "..") => 0;
|
||||
info.type => LFS_TYPE_DIR;
|
||||
for (int i = 0; i < $LARGESIZE; i++) {
|
||||
sprintf(path, "tedd%03d", i);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
strcmp(info.name, path) => 0;
|
||||
sprintf((char*)buffer, "tedd%03d", i);
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, (char*)buffer) => 0;
|
||||
info.type => LFS_TYPE_DIR;
|
||||
}
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
|
||||
echo "--- Multi-block remove ---"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_remove(&lfs, "cactus") => LFS_ERR_NOTEMPTY;
|
||||
|
||||
for (int i = 0; i < $LARGESIZE; i++) {
|
||||
sprintf(path, "cactus/tedd%03d", i);
|
||||
lfs_remove(&lfs, path) => 0;
|
||||
sprintf((char*)buffer, "cactus/tedd%03d", i);
|
||||
lfs_remove(&lfs, (char*)buffer) => 0;
|
||||
}
|
||||
|
||||
lfs_remove(&lfs, "cactus") => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "/") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_open(&lfs, &dir[0], "/") => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, ".") => 0;
|
||||
info.type => LFS_TYPE_DIR;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "..") => 0;
|
||||
info.type => LFS_TYPE_DIR;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "burito") => 0;
|
||||
info.type => LFS_TYPE_REG;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 0;
|
||||
lfs_dir_close(&lfs, &dir[0]) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
|
||||
echo "--- Multi-block directory with files ---"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_mkdir(&lfs, "prickly-pear") => 0;
|
||||
for (int i = 0; i < $LARGESIZE; i++) {
|
||||
sprintf(path, "prickly-pear/test%03d", i);
|
||||
lfs_file_open(&lfs, &file, path, LFS_O_WRONLY | LFS_O_CREAT) => 0;
|
||||
lfs_size_t size = 6;
|
||||
memcpy(buffer, "Hello", size);
|
||||
lfs_file_write(&lfs, &file, buffer, size) => size;
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
sprintf((char*)buffer, "prickly-pear/test%03d", i);
|
||||
lfs_file_open(&lfs, &file[0], (char*)buffer,
|
||||
LFS_O_WRONLY | LFS_O_CREAT) => 0;
|
||||
size = 6;
|
||||
memcpy(wbuffer, "Hello", size);
|
||||
lfs_file_write(&lfs, &file[0], wbuffer, size) => size;
|
||||
lfs_file_close(&lfs, &file[0]) => 0;
|
||||
}
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "prickly-pear") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_open(&lfs, &dir[0], "prickly-pear") => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, ".") => 0;
|
||||
info.type => LFS_TYPE_DIR;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "..") => 0;
|
||||
info.type => LFS_TYPE_DIR;
|
||||
for (int i = 0; i < $LARGESIZE; i++) {
|
||||
sprintf(path, "test%03d", i);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
strcmp(info.name, path) => 0;
|
||||
sprintf((char*)buffer, "test%03d", i);
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, (char*)buffer) => 0;
|
||||
info.type => LFS_TYPE_REG;
|
||||
info.size => 6;
|
||||
}
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
|
||||
echo "--- Multi-block rename with files ---"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
for (int i = 0; i < $LARGESIZE; i++) {
|
||||
char oldpath[1024];
|
||||
char newpath[1024];
|
||||
sprintf(oldpath, "prickly-pear/test%03d", i);
|
||||
sprintf(newpath, "prickly-pear/tedd%03d", i);
|
||||
lfs_rename(&lfs, oldpath, newpath) => 0;
|
||||
sprintf((char*)buffer, "prickly-pear/test%03d", i);
|
||||
sprintf((char*)wbuffer, "prickly-pear/tedd%03d", i);
|
||||
lfs_rename(&lfs, (char*)buffer, (char*)wbuffer) => 0;
|
||||
}
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "prickly-pear") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_open(&lfs, &dir[0], "prickly-pear") => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, ".") => 0;
|
||||
info.type => LFS_TYPE_DIR;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "..") => 0;
|
||||
info.type => LFS_TYPE_DIR;
|
||||
for (int i = 0; i < $LARGESIZE; i++) {
|
||||
sprintf(path, "tedd%03d", i);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
strcmp(info.name, path) => 0;
|
||||
sprintf((char*)buffer, "tedd%03d", i);
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, (char*)buffer) => 0;
|
||||
info.type => LFS_TYPE_REG;
|
||||
info.size => 6;
|
||||
}
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
|
||||
echo "--- Multi-block remove with files ---"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_remove(&lfs, "prickly-pear") => LFS_ERR_NOTEMPTY;
|
||||
|
||||
for (int i = 0; i < $LARGESIZE; i++) {
|
||||
sprintf(path, "prickly-pear/tedd%03d", i);
|
||||
lfs_remove(&lfs, path) => 0;
|
||||
sprintf((char*)buffer, "prickly-pear/tedd%03d", i);
|
||||
lfs_remove(&lfs, (char*)buffer) => 0;
|
||||
}
|
||||
|
||||
lfs_remove(&lfs, "prickly-pear") => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "/") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_open(&lfs, &dir[0], "/") => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, ".") => 0;
|
||||
info.type => LFS_TYPE_DIR;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "..") => 0;
|
||||
info.type => LFS_TYPE_DIR;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "burito") => 0;
|
||||
info.type => LFS_TYPE_REG;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 0;
|
||||
lfs_dir_close(&lfs, &dir[0]) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
|
||||
scripts/results.py
|
||||
echo "--- Results ---"
|
||||
tests/stats.py
|
||||
|
||||
@@ -1,22 +1,19 @@
|
||||
#!/bin/bash
|
||||
set -eu
|
||||
export TEST_FILE=$0
|
||||
trap 'export TEST_LINE=$LINENO' DEBUG
|
||||
|
||||
echo "=== Entry tests ==="
|
||||
|
||||
# Note: These tests are intended for 512 byte inline size at different
|
||||
# inline sizes they should still pass, but won't be testing anything
|
||||
|
||||
echo "=== Entry tests ==="
|
||||
rm -rf blocks
|
||||
function read_file {
|
||||
cat << TEST
|
||||
|
||||
size = $2;
|
||||
lfs_file_open(&lfs, &file, "$1", LFS_O_RDONLY) => 0;
|
||||
lfs_file_read(&lfs, &file, rbuffer, size) => size;
|
||||
lfs_file_open(&lfs, &file[0], "$1", LFS_O_RDONLY) => 0;
|
||||
lfs_file_read(&lfs, &file[0], rbuffer, size) => size;
|
||||
memcmp(rbuffer, wbuffer, size) => 0;
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_file_close(&lfs, &file[0]) => 0;
|
||||
TEST
|
||||
}
|
||||
|
||||
@@ -24,22 +21,18 @@ function write_file {
|
||||
cat << TEST
|
||||
|
||||
size = $2;
|
||||
lfs_file_open(&lfs, &file, "$1",
|
||||
lfs_file_open(&lfs, &file[0], "$1",
|
||||
LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0;
|
||||
memset(wbuffer, 'c', size);
|
||||
lfs_file_write(&lfs, &file, wbuffer, size) => size;
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_file_write(&lfs, &file[0], wbuffer, size) => size;
|
||||
lfs_file_close(&lfs, &file[0]) => 0;
|
||||
TEST
|
||||
}
|
||||
|
||||
echo "--- Entry grow test ---"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_format(&lfs, &cfg) => 0;
|
||||
|
||||
uint8_t wbuffer[1024];
|
||||
uint8_t rbuffer[1024];
|
||||
lfs_size_t size;
|
||||
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
$(write_file "hi0" 20)
|
||||
$(write_file "hi1" 20)
|
||||
@@ -57,13 +50,9 @@ scripts/test.py << TEST
|
||||
TEST
|
||||
|
||||
echo "--- Entry shrink test ---"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_format(&lfs, &cfg) => 0;
|
||||
|
||||
uint8_t wbuffer[1024];
|
||||
uint8_t rbuffer[1024];
|
||||
lfs_size_t size;
|
||||
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
$(write_file "hi0" 20)
|
||||
$(write_file "hi1" 200)
|
||||
@@ -81,13 +70,9 @@ scripts/test.py << TEST
|
||||
TEST
|
||||
|
||||
echo "--- Entry spill test ---"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_format(&lfs, &cfg) => 0;
|
||||
|
||||
uint8_t wbuffer[1024];
|
||||
uint8_t rbuffer[1024];
|
||||
lfs_size_t size;
|
||||
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
$(write_file "hi0" 200)
|
||||
$(write_file "hi1" 200)
|
||||
@@ -102,13 +87,9 @@ scripts/test.py << TEST
|
||||
TEST
|
||||
|
||||
echo "--- Entry push spill test ---"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_format(&lfs, &cfg) => 0;
|
||||
|
||||
uint8_t wbuffer[1024];
|
||||
uint8_t rbuffer[1024];
|
||||
lfs_size_t size;
|
||||
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
$(write_file "hi0" 200)
|
||||
$(write_file "hi1" 20)
|
||||
@@ -126,13 +107,9 @@ scripts/test.py << TEST
|
||||
TEST
|
||||
|
||||
echo "--- Entry push spill two test ---"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_format(&lfs, &cfg) => 0;
|
||||
|
||||
uint8_t wbuffer[1024];
|
||||
uint8_t rbuffer[1024];
|
||||
lfs_size_t size;
|
||||
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
$(write_file "hi0" 200)
|
||||
$(write_file "hi1" 20)
|
||||
@@ -152,13 +129,9 @@ scripts/test.py << TEST
|
||||
TEST
|
||||
|
||||
echo "--- Entry drop test ---"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_format(&lfs, &cfg) => 0;
|
||||
|
||||
uint8_t wbuffer[1024];
|
||||
uint8_t rbuffer[1024];
|
||||
lfs_size_t size;
|
||||
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
$(write_file "hi0" 200)
|
||||
$(write_file "hi1" 200)
|
||||
@@ -186,66 +159,63 @@ scripts/test.py << TEST
|
||||
TEST
|
||||
|
||||
echo "--- Create too big ---"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_format(&lfs, &cfg) => 0;
|
||||
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
memset(path, 'm', 200);
|
||||
path[200] = '\0';
|
||||
|
||||
lfs_size_t size = 400;
|
||||
lfs_file_open(&lfs, &file, path,
|
||||
LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0;
|
||||
uint8_t wbuffer[1024];
|
||||
memset(wbuffer, 'c', size);
|
||||
lfs_file_write(&lfs, &file, wbuffer, size) => size;
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
memset(buffer, 'm', 200);
|
||||
buffer[200] = '\0';
|
||||
|
||||
size = 400;
|
||||
lfs_file_open(&lfs, &file, path, LFS_O_RDONLY) => 0;
|
||||
uint8_t rbuffer[1024];
|
||||
lfs_file_read(&lfs, &file, rbuffer, size) => size;
|
||||
lfs_file_open(&lfs, &file[0], (char*)buffer,
|
||||
LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0;
|
||||
memset(wbuffer, 'c', size);
|
||||
lfs_file_write(&lfs, &file[0], wbuffer, size) => size;
|
||||
lfs_file_close(&lfs, &file[0]) => 0;
|
||||
|
||||
size = 400;
|
||||
lfs_file_open(&lfs, &file[0], (char*)buffer, LFS_O_RDONLY) => 0;
|
||||
lfs_file_read(&lfs, &file[0], rbuffer, size) => size;
|
||||
memcmp(rbuffer, wbuffer, size) => 0;
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_file_close(&lfs, &file[0]) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
|
||||
echo "--- Resize too big ---"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_format(&lfs, &cfg) => 0;
|
||||
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
memset(path, 'm', 200);
|
||||
path[200] = '\0';
|
||||
|
||||
lfs_size_t size = 40;
|
||||
lfs_file_open(&lfs, &file, path,
|
||||
LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0;
|
||||
uint8_t wbuffer[1024];
|
||||
memset(wbuffer, 'c', size);
|
||||
lfs_file_write(&lfs, &file, wbuffer, size) => size;
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
memset(buffer, 'm', 200);
|
||||
buffer[200] = '\0';
|
||||
|
||||
size = 40;
|
||||
lfs_file_open(&lfs, &file, path, LFS_O_RDONLY) => 0;
|
||||
uint8_t rbuffer[1024];
|
||||
lfs_file_read(&lfs, &file, rbuffer, size) => size;
|
||||
memcmp(rbuffer, wbuffer, size) => 0;
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
|
||||
size = 400;
|
||||
lfs_file_open(&lfs, &file, path,
|
||||
lfs_file_open(&lfs, &file[0], (char*)buffer,
|
||||
LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0;
|
||||
memset(wbuffer, 'c', size);
|
||||
lfs_file_write(&lfs, &file, wbuffer, size) => size;
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_file_write(&lfs, &file[0], wbuffer, size) => size;
|
||||
lfs_file_close(&lfs, &file[0]) => 0;
|
||||
|
||||
size = 40;
|
||||
lfs_file_open(&lfs, &file[0], (char*)buffer, LFS_O_RDONLY) => 0;
|
||||
lfs_file_read(&lfs, &file[0], rbuffer, size) => size;
|
||||
memcmp(rbuffer, wbuffer, size) => 0;
|
||||
lfs_file_close(&lfs, &file[0]) => 0;
|
||||
|
||||
size = 400;
|
||||
lfs_file_open(&lfs, &file, path, LFS_O_RDONLY) => 0;
|
||||
lfs_file_read(&lfs, &file, rbuffer, size) => size;
|
||||
lfs_file_open(&lfs, &file[0], (char*)buffer,
|
||||
LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0;
|
||||
memset(wbuffer, 'c', size);
|
||||
lfs_file_write(&lfs, &file[0], wbuffer, size) => size;
|
||||
lfs_file_close(&lfs, &file[0]) => 0;
|
||||
|
||||
size = 400;
|
||||
lfs_file_open(&lfs, &file[0], (char*)buffer, LFS_O_RDONLY) => 0;
|
||||
lfs_file_read(&lfs, &file[0], rbuffer, size) => size;
|
||||
memcmp(rbuffer, wbuffer, size) => 0;
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_file_close(&lfs, &file[0]) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
|
||||
scripts/results.py
|
||||
echo "--- Results ---"
|
||||
tests/stats.py
|
||||
|
||||
@@ -1,76 +1,71 @@
|
||||
#!/bin/bash
|
||||
set -eu
|
||||
export TEST_FILE=$0
|
||||
trap 'export TEST_LINE=$LINENO' DEBUG
|
||||
|
||||
echo "=== File tests ==="
|
||||
|
||||
SMALLSIZE=32
|
||||
MEDIUMSIZE=8192
|
||||
LARGESIZE=262144
|
||||
|
||||
echo "=== File tests ==="
|
||||
rm -rf blocks
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_format(&lfs, &cfg) => 0;
|
||||
TEST
|
||||
|
||||
echo "--- Simple file test ---"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_file_open(&lfs, &file, "hello", LFS_O_WRONLY | LFS_O_CREAT) => 0;
|
||||
lfs_size_t size = strlen("Hello World!\n");
|
||||
uint8_t wbuffer[1024];
|
||||
memcpy(wbuffer, "Hello World!\n", size);
|
||||
lfs_file_write(&lfs, &file, wbuffer, size) => size;
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
|
||||
lfs_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0;
|
||||
lfs_file_open(&lfs, &file[0], "hello", LFS_O_WRONLY | LFS_O_CREAT) => 0;
|
||||
size = strlen("Hello World!\n");
|
||||
uint8_t rbuffer[1024];
|
||||
lfs_file_read(&lfs, &file, rbuffer, size) => size;
|
||||
memcpy(wbuffer, "Hello World!\n", size);
|
||||
lfs_file_write(&lfs, &file[0], wbuffer, size) => size;
|
||||
lfs_file_close(&lfs, &file[0]) => 0;
|
||||
|
||||
lfs_file_open(&lfs, &file[0], "hello", LFS_O_RDONLY) => 0;
|
||||
size = strlen("Hello World!\n");
|
||||
lfs_file_read(&lfs, &file[0], rbuffer, size) => size;
|
||||
memcmp(rbuffer, wbuffer, size) => 0;
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_file_close(&lfs, &file[0]) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
|
||||
w_test() {
|
||||
scripts/test.py ${4:-} << TEST
|
||||
lfs_size_t size = $1;
|
||||
tests/test.py ${4:-} << TEST
|
||||
size = $1;
|
||||
lfs_size_t chunk = 31;
|
||||
srand(0);
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_file_open(&lfs, &file, "$2",
|
||||
lfs_file_open(&lfs, &file[0], "$2",
|
||||
${3:-LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC}) => 0;
|
||||
for (lfs_size_t i = 0; i < size; i += chunk) {
|
||||
chunk = (chunk < size - i) ? chunk : size - i;
|
||||
for (lfs_size_t b = 0; b < chunk; b++) {
|
||||
buffer[b] = rand() & 0xff;
|
||||
}
|
||||
lfs_file_write(&lfs, &file, buffer, chunk) => chunk;
|
||||
lfs_file_write(&lfs, &file[0], buffer, chunk) => chunk;
|
||||
}
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_file_close(&lfs, &file[0]) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
}
|
||||
|
||||
r_test() {
|
||||
scripts/test.py << TEST
|
||||
lfs_size_t size = $1;
|
||||
tests/test.py << TEST
|
||||
size = $1;
|
||||
lfs_size_t chunk = 29;
|
||||
srand(0);
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_stat(&lfs, "$2", &info) => 0;
|
||||
info.type => LFS_TYPE_REG;
|
||||
info.size => size;
|
||||
lfs_file_open(&lfs, &file, "$2", ${3:-LFS_O_RDONLY}) => 0;
|
||||
lfs_file_open(&lfs, &file[0], "$2", ${3:-LFS_O_RDONLY}) => 0;
|
||||
for (lfs_size_t i = 0; i < size; i += chunk) {
|
||||
chunk = (chunk < size - i) ? chunk : size - i;
|
||||
lfs_file_read(&lfs, &file, buffer, chunk) => chunk;
|
||||
lfs_file_read(&lfs, &file[0], buffer, chunk) => chunk;
|
||||
for (lfs_size_t b = 0; b < chunk && i+b < size; b++) {
|
||||
buffer[b] => rand() & 0xff;
|
||||
}
|
||||
}
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_file_close(&lfs, &file[0]) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
}
|
||||
@@ -110,112 +105,54 @@ r_test $LARGESIZE largeavacado
|
||||
r_test 0 noavacado
|
||||
|
||||
echo "--- Dir check ---"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "/") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_open(&lfs, &dir[0], "/") => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "hello") => 0;
|
||||
info.type => LFS_TYPE_REG;
|
||||
info.size => strlen("Hello World!\n");
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "largeavacado") => 0;
|
||||
info.type => LFS_TYPE_REG;
|
||||
info.size => $LARGESIZE;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "mediumavacado") => 0;
|
||||
info.type => LFS_TYPE_REG;
|
||||
info.size => $MEDIUMSIZE;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "noavacado") => 0;
|
||||
info.type => LFS_TYPE_REG;
|
||||
info.size => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "smallavacado") => 0;
|
||||
info.type => LFS_TYPE_REG;
|
||||
info.size => $SMALLSIZE;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 0;
|
||||
lfs_dir_close(&lfs, &dir[0]) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
|
||||
echo "--- Many files test ---"
|
||||
scripts/test.py << TEST
|
||||
echo "--- Many file test ---"
|
||||
tests/test.py << TEST
|
||||
lfs_format(&lfs, &cfg) => 0;
|
||||
TEST
|
||||
scripts/test.py << TEST
|
||||
// Create 300 files of 7 bytes
|
||||
tests/test.py << TEST
|
||||
// Create 300 files of 6 bytes
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_mkdir(&lfs, "directory") => 0;
|
||||
for (unsigned i = 0; i < 300; i++) {
|
||||
sprintf(path, "file_%03d", i);
|
||||
lfs_file_open(&lfs, &file, path,
|
||||
LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0;
|
||||
lfs_size_t size = 7;
|
||||
uint8_t wbuffer[1024];
|
||||
uint8_t rbuffer[1024];
|
||||
snprintf((char*)wbuffer, size, "Hi %03d", i);
|
||||
lfs_file_write(&lfs, &file, wbuffer, size) => size;
|
||||
lfs_file_rewind(&lfs, &file) => 0;
|
||||
lfs_file_read(&lfs, &file, rbuffer, size) => size;
|
||||
memcmp(wbuffer, rbuffer, size) => 0;
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
snprintf((char*)buffer, sizeof(buffer), "file_%03d", i);
|
||||
lfs_file_open(&lfs, &file[0], (char*)buffer, LFS_O_WRONLY | LFS_O_CREAT) => 0;
|
||||
size = 6;
|
||||
memcpy(wbuffer, "Hello", size);
|
||||
lfs_file_write(&lfs, &file[0], wbuffer, size) => size;
|
||||
lfs_file_close(&lfs, &file[0]) => 0;
|
||||
}
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
|
||||
echo "--- Many files with flush test ---"
|
||||
scripts/test.py << TEST
|
||||
lfs_format(&lfs, &cfg) => 0;
|
||||
TEST
|
||||
scripts/test.py << TEST
|
||||
// Create 300 files of 7 bytes
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
for (unsigned i = 0; i < 300; i++) {
|
||||
sprintf(path, "file_%03d", i);
|
||||
lfs_file_open(&lfs, &file, path,
|
||||
LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0;
|
||||
lfs_size_t size = 7;
|
||||
uint8_t wbuffer[1024];
|
||||
uint8_t rbuffer[1024];
|
||||
snprintf((char*)wbuffer, size, "Hi %03d", i);
|
||||
lfs_file_write(&lfs, &file, wbuffer, size) => size;
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
|
||||
lfs_file_open(&lfs, &file, path, LFS_O_RDONLY) => 0;
|
||||
lfs_file_read(&lfs, &file, rbuffer, size) => size;
|
||||
memcmp(wbuffer, rbuffer, size) => 0;
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
}
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
|
||||
echo "--- Many files with power cycle test ---"
|
||||
scripts/test.py << TEST
|
||||
lfs_format(&lfs, &cfg) => 0;
|
||||
TEST
|
||||
scripts/test.py << TEST
|
||||
// Create 300 files of 7 bytes
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
for (unsigned i = 0; i < 300; i++) {
|
||||
sprintf(path, "file_%03d", i);
|
||||
lfs_file_open(&lfs, &file, path,
|
||||
LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0;
|
||||
lfs_size_t size = 7;
|
||||
uint8_t wbuffer[1024];
|
||||
uint8_t rbuffer[1024];
|
||||
snprintf((char*)wbuffer, size, "Hi %03d", i);
|
||||
lfs_file_write(&lfs, &file, wbuffer, size) => size;
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_file_open(&lfs, &file, path, LFS_O_RDONLY) => 0;
|
||||
lfs_file_read(&lfs, &file, rbuffer, size) => size;
|
||||
memcmp(wbuffer, rbuffer, size) => 0;
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
}
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
|
||||
scripts/results.py
|
||||
echo "--- Results ---"
|
||||
tests/stats.py
|
||||
|
||||
@@ -1,18 +1,16 @@
|
||||
#!/bin/bash
|
||||
set -eu
|
||||
export TEST_FILE=$0
|
||||
trap 'export TEST_LINE=$LINENO' DEBUG
|
||||
|
||||
echo "=== Formatting tests ==="
|
||||
rm -rf blocks
|
||||
|
||||
echo "--- Basic formatting ---"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_format(&lfs, &cfg) => 0;
|
||||
TEST
|
||||
|
||||
echo "--- Basic mounting ---"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_format(&lfs, &cfg) => 0;
|
||||
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
@@ -22,18 +20,18 @@ TEST
|
||||
echo "--- Invalid superblocks ---"
|
||||
ln -f -s /dev/zero blocks/0
|
||||
ln -f -s /dev/zero blocks/1
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_format(&lfs, &cfg) => LFS_ERR_NOSPC;
|
||||
TEST
|
||||
rm blocks/0 blocks/1
|
||||
|
||||
echo "--- Invalid mount ---"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => LFS_ERR_CORRUPT;
|
||||
TEST
|
||||
|
||||
echo "--- Expanding superblock ---"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_format(&lfs, &cfg) => 0;
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
for (int i = 0; i < 100; i++) {
|
||||
@@ -42,10 +40,11 @@ scripts/test.py << TEST
|
||||
}
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_mkdir(&lfs, "dummy") => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
|
||||
scripts/results.py
|
||||
echo "--- Results ---"
|
||||
tests/stats.py
|
||||
|
||||
@@ -1,93 +1,89 @@
|
||||
#!/bin/bash
|
||||
set -eu
|
||||
export TEST_FILE=$0
|
||||
trap 'export TEST_LINE=$LINENO' DEBUG
|
||||
|
||||
echo "=== Interspersed tests ==="
|
||||
rm -rf blocks
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_format(&lfs, &cfg) => 0;
|
||||
TEST
|
||||
|
||||
echo "--- Interspersed file test ---"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_file_t files[4];
|
||||
lfs_file_open(&lfs, &files[0], "a", LFS_O_WRONLY | LFS_O_CREAT) => 0;
|
||||
lfs_file_open(&lfs, &files[1], "b", LFS_O_WRONLY | LFS_O_CREAT) => 0;
|
||||
lfs_file_open(&lfs, &files[2], "c", LFS_O_WRONLY | LFS_O_CREAT) => 0;
|
||||
lfs_file_open(&lfs, &files[3], "d", LFS_O_WRONLY | LFS_O_CREAT) => 0;
|
||||
lfs_file_open(&lfs, &file[0], "a", LFS_O_WRONLY | LFS_O_CREAT) => 0;
|
||||
lfs_file_open(&lfs, &file[1], "b", LFS_O_WRONLY | LFS_O_CREAT) => 0;
|
||||
lfs_file_open(&lfs, &file[2], "c", LFS_O_WRONLY | LFS_O_CREAT) => 0;
|
||||
lfs_file_open(&lfs, &file[3], "d", LFS_O_WRONLY | LFS_O_CREAT) => 0;
|
||||
|
||||
for (int i = 0; i < 10; i++) {
|
||||
lfs_file_write(&lfs, &files[0], (const void*)"a", 1) => 1;
|
||||
lfs_file_write(&lfs, &files[1], (const void*)"b", 1) => 1;
|
||||
lfs_file_write(&lfs, &files[2], (const void*)"c", 1) => 1;
|
||||
lfs_file_write(&lfs, &files[3], (const void*)"d", 1) => 1;
|
||||
lfs_file_write(&lfs, &file[0], (const void*)"a", 1) => 1;
|
||||
lfs_file_write(&lfs, &file[1], (const void*)"b", 1) => 1;
|
||||
lfs_file_write(&lfs, &file[2], (const void*)"c", 1) => 1;
|
||||
lfs_file_write(&lfs, &file[3], (const void*)"d", 1) => 1;
|
||||
}
|
||||
|
||||
lfs_file_close(&lfs, &files[0]);
|
||||
lfs_file_close(&lfs, &files[1]);
|
||||
lfs_file_close(&lfs, &files[2]);
|
||||
lfs_file_close(&lfs, &files[3]);
|
||||
lfs_file_close(&lfs, &file[0]);
|
||||
lfs_file_close(&lfs, &file[1]);
|
||||
lfs_file_close(&lfs, &file[2]);
|
||||
lfs_file_close(&lfs, &file[3]);
|
||||
|
||||
lfs_dir_open(&lfs, &dir, "/") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_open(&lfs, &dir[0], "/") => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, ".") => 0;
|
||||
info.type => LFS_TYPE_DIR;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "..") => 0;
|
||||
info.type => LFS_TYPE_DIR;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "a") => 0;
|
||||
info.type => LFS_TYPE_REG;
|
||||
info.size => 10;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "b") => 0;
|
||||
info.type => LFS_TYPE_REG;
|
||||
info.size => 10;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "c") => 0;
|
||||
info.type => LFS_TYPE_REG;
|
||||
info.size => 10;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "d") => 0;
|
||||
info.type => LFS_TYPE_REG;
|
||||
info.size => 10;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 0;
|
||||
lfs_dir_close(&lfs, &dir[0]) => 0;
|
||||
|
||||
lfs_file_open(&lfs, &files[0], "a", LFS_O_RDONLY) => 0;
|
||||
lfs_file_open(&lfs, &files[1], "b", LFS_O_RDONLY) => 0;
|
||||
lfs_file_open(&lfs, &files[2], "c", LFS_O_RDONLY) => 0;
|
||||
lfs_file_open(&lfs, &files[3], "d", LFS_O_RDONLY) => 0;
|
||||
lfs_file_open(&lfs, &file[0], "a", LFS_O_RDONLY) => 0;
|
||||
lfs_file_open(&lfs, &file[1], "b", LFS_O_RDONLY) => 0;
|
||||
lfs_file_open(&lfs, &file[2], "c", LFS_O_RDONLY) => 0;
|
||||
lfs_file_open(&lfs, &file[3], "d", LFS_O_RDONLY) => 0;
|
||||
|
||||
for (int i = 0; i < 10; i++) {
|
||||
lfs_file_read(&lfs, &files[0], buffer, 1) => 1;
|
||||
lfs_file_read(&lfs, &file[0], buffer, 1) => 1;
|
||||
buffer[0] => 'a';
|
||||
lfs_file_read(&lfs, &files[1], buffer, 1) => 1;
|
||||
lfs_file_read(&lfs, &file[1], buffer, 1) => 1;
|
||||
buffer[0] => 'b';
|
||||
lfs_file_read(&lfs, &files[2], buffer, 1) => 1;
|
||||
lfs_file_read(&lfs, &file[2], buffer, 1) => 1;
|
||||
buffer[0] => 'c';
|
||||
lfs_file_read(&lfs, &files[3], buffer, 1) => 1;
|
||||
lfs_file_read(&lfs, &file[3], buffer, 1) => 1;
|
||||
buffer[0] => 'd';
|
||||
}
|
||||
|
||||
lfs_file_close(&lfs, &files[0]);
|
||||
lfs_file_close(&lfs, &files[1]);
|
||||
lfs_file_close(&lfs, &files[2]);
|
||||
lfs_file_close(&lfs, &files[3]);
|
||||
lfs_file_close(&lfs, &file[0]);
|
||||
lfs_file_close(&lfs, &file[1]);
|
||||
lfs_file_close(&lfs, &file[2]);
|
||||
lfs_file_close(&lfs, &file[3]);
|
||||
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
|
||||
echo "--- Interspersed remove file test ---"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_file_t files[4];
|
||||
lfs_file_open(&lfs, &files[0], "e", LFS_O_WRONLY | LFS_O_CREAT) => 0;
|
||||
lfs_file_open(&lfs, &file[0], "e", LFS_O_WRONLY | LFS_O_CREAT) => 0;
|
||||
|
||||
for (int i = 0; i < 5; i++) {
|
||||
lfs_file_write(&lfs, &files[0], (const void*)"e", 1) => 1;
|
||||
lfs_file_write(&lfs, &file[0], (const void*)"e", 1) => 1;
|
||||
}
|
||||
|
||||
lfs_remove(&lfs, "a") => 0;
|
||||
@@ -96,95 +92,95 @@ scripts/test.py << TEST
|
||||
lfs_remove(&lfs, "d") => 0;
|
||||
|
||||
for (int i = 0; i < 5; i++) {
|
||||
lfs_file_write(&lfs, &files[0], (const void*)"e", 1) => 1;
|
||||
lfs_file_write(&lfs, &file[0], (const void*)"e", 1) => 1;
|
||||
}
|
||||
|
||||
lfs_file_close(&lfs, &files[0]);
|
||||
lfs_file_close(&lfs, &file[0]);
|
||||
|
||||
lfs_dir_open(&lfs, &dir, "/") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_open(&lfs, &dir[0], "/") => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, ".") => 0;
|
||||
info.type => LFS_TYPE_DIR;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "..") => 0;
|
||||
info.type => LFS_TYPE_DIR;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "e") => 0;
|
||||
info.type => LFS_TYPE_REG;
|
||||
info.size => 10;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 0;
|
||||
lfs_dir_close(&lfs, &dir[0]) => 0;
|
||||
|
||||
lfs_file_open(&lfs, &files[0], "e", LFS_O_RDONLY) => 0;
|
||||
lfs_file_open(&lfs, &file[0], "e", LFS_O_RDONLY) => 0;
|
||||
|
||||
for (int i = 0; i < 10; i++) {
|
||||
lfs_file_read(&lfs, &files[0], buffer, 1) => 1;
|
||||
lfs_file_read(&lfs, &file[0], buffer, 1) => 1;
|
||||
buffer[0] => 'e';
|
||||
}
|
||||
|
||||
lfs_file_close(&lfs, &files[0]);
|
||||
lfs_file_close(&lfs, &file[0]);
|
||||
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
|
||||
echo "--- Remove inconveniently test ---"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_file_t files[4];
|
||||
lfs_file_open(&lfs, &files[0], "e", LFS_O_WRONLY | LFS_O_TRUNC) => 0;
|
||||
lfs_file_open(&lfs, &files[1], "f", LFS_O_WRONLY | LFS_O_CREAT) => 0;
|
||||
lfs_file_open(&lfs, &files[2], "g", LFS_O_WRONLY | LFS_O_CREAT) => 0;
|
||||
lfs_file_open(&lfs, &file[0], "e", LFS_O_WRONLY | LFS_O_TRUNC) => 0;
|
||||
lfs_file_open(&lfs, &file[1], "f", LFS_O_WRONLY | LFS_O_CREAT) => 0;
|
||||
lfs_file_open(&lfs, &file[2], "g", LFS_O_WRONLY | LFS_O_CREAT) => 0;
|
||||
|
||||
for (int i = 0; i < 5; i++) {
|
||||
lfs_file_write(&lfs, &files[0], (const void*)"e", 1) => 1;
|
||||
lfs_file_write(&lfs, &files[1], (const void*)"f", 1) => 1;
|
||||
lfs_file_write(&lfs, &files[2], (const void*)"g", 1) => 1;
|
||||
lfs_file_write(&lfs, &file[0], (const void*)"e", 1) => 1;
|
||||
lfs_file_write(&lfs, &file[1], (const void*)"f", 1) => 1;
|
||||
lfs_file_write(&lfs, &file[2], (const void*)"g", 1) => 1;
|
||||
}
|
||||
|
||||
lfs_remove(&lfs, "f") => 0;
|
||||
|
||||
for (int i = 0; i < 5; i++) {
|
||||
lfs_file_write(&lfs, &files[0], (const void*)"e", 1) => 1;
|
||||
lfs_file_write(&lfs, &files[1], (const void*)"f", 1) => 1;
|
||||
lfs_file_write(&lfs, &files[2], (const void*)"g", 1) => 1;
|
||||
lfs_file_write(&lfs, &file[0], (const void*)"e", 1) => 1;
|
||||
lfs_file_write(&lfs, &file[1], (const void*)"f", 1) => 1;
|
||||
lfs_file_write(&lfs, &file[2], (const void*)"g", 1) => 1;
|
||||
}
|
||||
|
||||
lfs_file_close(&lfs, &files[0]);
|
||||
lfs_file_close(&lfs, &files[1]);
|
||||
lfs_file_close(&lfs, &files[2]);
|
||||
lfs_file_close(&lfs, &file[0]);
|
||||
lfs_file_close(&lfs, &file[1]);
|
||||
lfs_file_close(&lfs, &file[2]);
|
||||
|
||||
lfs_dir_open(&lfs, &dir, "/") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_open(&lfs, &dir[0], "/") => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, ".") => 0;
|
||||
info.type => LFS_TYPE_DIR;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "..") => 0;
|
||||
info.type => LFS_TYPE_DIR;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "e") => 0;
|
||||
info.type => LFS_TYPE_REG;
|
||||
info.size => 10;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "g") => 0;
|
||||
info.type => LFS_TYPE_REG;
|
||||
info.size => 10;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 0;
|
||||
lfs_dir_close(&lfs, &dir[0]) => 0;
|
||||
|
||||
lfs_file_open(&lfs, &files[0], "e", LFS_O_RDONLY) => 0;
|
||||
lfs_file_open(&lfs, &files[1], "g", LFS_O_RDONLY) => 0;
|
||||
lfs_file_open(&lfs, &file[0], "e", LFS_O_RDONLY) => 0;
|
||||
lfs_file_open(&lfs, &file[1], "g", LFS_O_RDONLY) => 0;
|
||||
|
||||
for (int i = 0; i < 10; i++) {
|
||||
lfs_file_read(&lfs, &files[0], buffer, 1) => 1;
|
||||
lfs_file_read(&lfs, &file[0], buffer, 1) => 1;
|
||||
buffer[0] => 'e';
|
||||
lfs_file_read(&lfs, &files[1], buffer, 1) => 1;
|
||||
lfs_file_read(&lfs, &file[1], buffer, 1) => 1;
|
||||
buffer[0] => 'g';
|
||||
}
|
||||
|
||||
lfs_file_close(&lfs, &files[0]);
|
||||
lfs_file_close(&lfs, &files[1]);
|
||||
lfs_file_close(&lfs, &file[0]);
|
||||
lfs_file_close(&lfs, &file[1]);
|
||||
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
|
||||
scripts/results.py
|
||||
echo "--- Results ---"
|
||||
tests/stats.py
|
||||
|
||||
@@ -1,11 +1,9 @@
|
||||
#!/bin/bash
|
||||
set -eu
|
||||
export TEST_FILE=$0
|
||||
trap 'export TEST_LINE=$LINENO' DEBUG
|
||||
|
||||
echo "=== Move tests ==="
|
||||
rm -rf blocks
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_format(&lfs, &cfg) => 0;
|
||||
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
@@ -19,272 +17,272 @@ scripts/test.py << TEST
|
||||
lfs_mkdir(&lfs, "a/hi/bonjour") => 0;
|
||||
lfs_mkdir(&lfs, "a/hi/ohayo") => 0;
|
||||
|
||||
lfs_file_open(&lfs, &file, "a/hello", LFS_O_CREAT | LFS_O_WRONLY) => 0;
|
||||
lfs_file_write(&lfs, &file, "hola\n", 5) => 5;
|
||||
lfs_file_write(&lfs, &file, "bonjour\n", 8) => 8;
|
||||
lfs_file_write(&lfs, &file, "ohayo\n", 6) => 6;
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_file_open(&lfs, &file[0], "a/hello", LFS_O_CREAT | LFS_O_WRONLY) => 0;
|
||||
lfs_file_write(&lfs, &file[0], "hola\n", 5) => 5;
|
||||
lfs_file_write(&lfs, &file[0], "bonjour\n", 8) => 8;
|
||||
lfs_file_write(&lfs, &file[0], "ohayo\n", 6) => 6;
|
||||
lfs_file_close(&lfs, &file[0]) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
|
||||
echo "--- Move file ---"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_rename(&lfs, "a/hello", "b/hello") => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "a") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_open(&lfs, &dir[0], "a") => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, ".") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "..") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "hi") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "b") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 0;
|
||||
lfs_dir_close(&lfs, &dir[0]) => 0;
|
||||
lfs_dir_open(&lfs, &dir[0], "b") => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, ".") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "..") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "hello") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
|
||||
echo "--- Move file corrupt source ---"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_rename(&lfs, "b/hello", "c/hello") => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
scripts/corrupt.py -n 1
|
||||
scripts/test.py << TEST
|
||||
tests/corrupt.py -n 1
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "b") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_open(&lfs, &dir[0], "b") => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, ".") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "..") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "c") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 0;
|
||||
lfs_dir_close(&lfs, &dir[0]) => 0;
|
||||
lfs_dir_open(&lfs, &dir[0], "c") => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, ".") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "..") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "hello") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
|
||||
echo "--- Move file corrupt source and dest ---"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_rename(&lfs, "c/hello", "d/hello") => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
scripts/corrupt.py -n 2
|
||||
scripts/test.py << TEST
|
||||
tests/corrupt.py -n 2
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "c") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_open(&lfs, &dir[0], "c") => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, ".") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "..") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "hello") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "d") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 0;
|
||||
lfs_dir_close(&lfs, &dir[0]) => 0;
|
||||
lfs_dir_open(&lfs, &dir[0], "d") => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, ".") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "..") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
|
||||
echo "--- Move file after corrupt ---"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_rename(&lfs, "c/hello", "d/hello") => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "c") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_open(&lfs, &dir[0], "c") => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, ".") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "..") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "d") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 0;
|
||||
lfs_dir_close(&lfs, &dir[0]) => 0;
|
||||
lfs_dir_open(&lfs, &dir[0], "d") => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, ".") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "..") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "hello") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
|
||||
echo "--- Move dir ---"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_rename(&lfs, "a/hi", "b/hi") => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "a") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_open(&lfs, &dir[0], "a") => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, ".") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "..") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "b") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 0;
|
||||
lfs_dir_close(&lfs, &dir[0]) => 0;
|
||||
lfs_dir_open(&lfs, &dir[0], "b") => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, ".") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "..") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "hi") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
|
||||
echo "--- Move dir corrupt source ---"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_rename(&lfs, "b/hi", "c/hi") => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
scripts/corrupt.py -n 1
|
||||
scripts/test.py << TEST
|
||||
tests/corrupt.py -n 1
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "b") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_open(&lfs, &dir[0], "b") => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, ".") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "..") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "c") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 0;
|
||||
lfs_dir_close(&lfs, &dir[0]) => 0;
|
||||
lfs_dir_open(&lfs, &dir[0], "c") => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, ".") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "..") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "hi") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
|
||||
echo "--- Move dir corrupt source and dest ---"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_rename(&lfs, "c/hi", "d/hi") => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
scripts/corrupt.py -n 2
|
||||
scripts/test.py << TEST
|
||||
tests/corrupt.py -n 2
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "c") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_open(&lfs, &dir[0], "c") => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, ".") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "..") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "hi") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "d") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 0;
|
||||
lfs_dir_close(&lfs, &dir[0]) => 0;
|
||||
lfs_dir_open(&lfs, &dir[0], "d") => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, ".") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "..") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "hello") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
|
||||
echo "--- Move dir after corrupt ---"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_rename(&lfs, "c/hi", "d/hi") => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "c") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_open(&lfs, &dir[0], "c") => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, ".") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "..") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "d") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 0;
|
||||
lfs_dir_close(&lfs, &dir[0]) => 0;
|
||||
lfs_dir_open(&lfs, &dir[0], "d") => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, ".") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "..") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "hello") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "hi") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
|
||||
echo "--- Move check ---"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
|
||||
lfs_dir_open(&lfs, &dir, "a/hi") => LFS_ERR_NOENT;
|
||||
lfs_dir_open(&lfs, &dir, "b/hi") => LFS_ERR_NOENT;
|
||||
lfs_dir_open(&lfs, &dir, "c/hi") => LFS_ERR_NOENT;
|
||||
lfs_dir_open(&lfs, &dir[0], "a/hi") => LFS_ERR_NOENT;
|
||||
lfs_dir_open(&lfs, &dir[0], "b/hi") => LFS_ERR_NOENT;
|
||||
lfs_dir_open(&lfs, &dir[0], "c/hi") => LFS_ERR_NOENT;
|
||||
|
||||
lfs_dir_open(&lfs, &dir, "d/hi") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_open(&lfs, &dir[0], "d/hi") => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, ".") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "..") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "bonjour") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "hola") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "ohayo") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 0;
|
||||
lfs_dir_close(&lfs, &dir[0]) => 0;
|
||||
|
||||
lfs_dir_open(&lfs, &dir, "a/hello") => LFS_ERR_NOENT;
|
||||
lfs_dir_open(&lfs, &dir, "b/hello") => LFS_ERR_NOENT;
|
||||
lfs_dir_open(&lfs, &dir, "c/hello") => LFS_ERR_NOENT;
|
||||
lfs_dir_open(&lfs, &dir[0], "a/hello") => LFS_ERR_NOENT;
|
||||
lfs_dir_open(&lfs, &dir[0], "b/hello") => LFS_ERR_NOENT;
|
||||
lfs_dir_open(&lfs, &dir[0], "c/hello") => LFS_ERR_NOENT;
|
||||
|
||||
lfs_file_open(&lfs, &file, "d/hello", LFS_O_RDONLY) => 0;
|
||||
lfs_file_read(&lfs, &file, buffer, 5) => 5;
|
||||
lfs_file_open(&lfs, &file[0], "d/hello", LFS_O_RDONLY) => 0;
|
||||
lfs_file_read(&lfs, &file[0], buffer, 5) => 5;
|
||||
memcmp(buffer, "hola\n", 5) => 0;
|
||||
lfs_file_read(&lfs, &file, buffer, 8) => 8;
|
||||
lfs_file_read(&lfs, &file[0], buffer, 8) => 8;
|
||||
memcmp(buffer, "bonjour\n", 8) => 0;
|
||||
lfs_file_read(&lfs, &file, buffer, 6) => 6;
|
||||
lfs_file_read(&lfs, &file[0], buffer, 6) => 6;
|
||||
memcmp(buffer, "ohayo\n", 6) => 0;
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_file_close(&lfs, &file[0]) => 0;
|
||||
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
|
||||
echo "--- Move state stealing ---"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
|
||||
lfs_remove(&lfs, "b") => 0;
|
||||
@@ -292,42 +290,43 @@ scripts/test.py << TEST
|
||||
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
|
||||
lfs_dir_open(&lfs, &dir, "a/hi") => LFS_ERR_NOENT;
|
||||
lfs_dir_open(&lfs, &dir, "b") => LFS_ERR_NOENT;
|
||||
lfs_dir_open(&lfs, &dir, "c") => LFS_ERR_NOENT;
|
||||
lfs_dir_open(&lfs, &dir[0], "a/hi") => LFS_ERR_NOENT;
|
||||
lfs_dir_open(&lfs, &dir[0], "b") => LFS_ERR_NOENT;
|
||||
lfs_dir_open(&lfs, &dir[0], "c") => LFS_ERR_NOENT;
|
||||
|
||||
lfs_dir_open(&lfs, &dir, "d/hi") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_open(&lfs, &dir[0], "d/hi") => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, ".") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "..") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "bonjour") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "hola") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "ohayo") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 0;
|
||||
lfs_dir_close(&lfs, &dir[0]) => 0;
|
||||
|
||||
lfs_dir_open(&lfs, &dir, "a/hello") => LFS_ERR_NOENT;
|
||||
lfs_dir_open(&lfs, &dir, "b") => LFS_ERR_NOENT;
|
||||
lfs_dir_open(&lfs, &dir, "c") => LFS_ERR_NOENT;
|
||||
lfs_dir_open(&lfs, &dir[0], "a/hello") => LFS_ERR_NOENT;
|
||||
lfs_dir_open(&lfs, &dir[0], "b") => LFS_ERR_NOENT;
|
||||
lfs_dir_open(&lfs, &dir[0], "c") => LFS_ERR_NOENT;
|
||||
|
||||
lfs_file_open(&lfs, &file, "d/hello", LFS_O_RDONLY) => 0;
|
||||
lfs_file_read(&lfs, &file, buffer, 5) => 5;
|
||||
lfs_file_open(&lfs, &file[0], "d/hello", LFS_O_RDONLY) => 0;
|
||||
lfs_file_read(&lfs, &file[0], buffer, 5) => 5;
|
||||
memcmp(buffer, "hola\n", 5) => 0;
|
||||
lfs_file_read(&lfs, &file, buffer, 8) => 8;
|
||||
lfs_file_read(&lfs, &file[0], buffer, 8) => 8;
|
||||
memcmp(buffer, "bonjour\n", 8) => 0;
|
||||
lfs_file_read(&lfs, &file, buffer, 6) => 6;
|
||||
lfs_file_read(&lfs, &file[0], buffer, 6) => 6;
|
||||
memcmp(buffer, "ohayo\n", 6) => 0;
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_file_close(&lfs, &file[0]) => 0;
|
||||
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
|
||||
|
||||
scripts/results.py
|
||||
echo "--- Results ---"
|
||||
tests/stats.py
|
||||
|
||||
@@ -1,16 +1,14 @@
|
||||
#!/bin/bash
|
||||
set -eu
|
||||
export TEST_FILE=$0
|
||||
trap 'export TEST_LINE=$LINENO' DEBUG
|
||||
|
||||
echo "=== Orphan tests ==="
|
||||
rm -rf blocks
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_format(&lfs, &cfg) => 0;
|
||||
TEST
|
||||
|
||||
echo "--- Orphan test ---"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_mkdir(&lfs, "parent") => 0;
|
||||
lfs_mkdir(&lfs, "parent/orphan") => 0;
|
||||
@@ -19,8 +17,8 @@ scripts/test.py << TEST
|
||||
TEST
|
||||
# corrupt most recent commit, this should be the update to the previous
|
||||
# linked-list entry and should orphan the child
|
||||
scripts/corrupt.py
|
||||
scripts/test.py << TEST
|
||||
tests/corrupt.py
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
|
||||
lfs_stat(&lfs, "parent/orphan", &info) => LFS_ERR_NOENT;
|
||||
@@ -43,4 +41,5 @@ scripts/test.py << TEST
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
|
||||
scripts/results.py
|
||||
echo "--- Results ---"
|
||||
tests/stats.py
|
||||
|
||||
@@ -1,15 +1,13 @@
|
||||
#!/bin/bash
|
||||
set -eu
|
||||
export TEST_FILE=$0
|
||||
trap 'export TEST_LINE=$LINENO' DEBUG
|
||||
|
||||
echo "=== Path tests ==="
|
||||
rm -rf blocks
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_format(&lfs, &cfg) => 0;
|
||||
TEST
|
||||
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_mkdir(&lfs, "tea") => 0;
|
||||
lfs_mkdir(&lfs, "coffee") => 0;
|
||||
@@ -27,7 +25,7 @@ scripts/test.py << TEST
|
||||
TEST
|
||||
|
||||
echo "--- Root path tests ---"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_stat(&lfs, "tea/hottea", &info) => 0;
|
||||
strcmp(info.name, "hottea") => 0;
|
||||
@@ -41,7 +39,7 @@ scripts/test.py << TEST
|
||||
TEST
|
||||
|
||||
echo "--- Redundant slash path tests ---"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_stat(&lfs, "/tea/hottea", &info) => 0;
|
||||
strcmp(info.name, "hottea") => 0;
|
||||
@@ -57,7 +55,7 @@ scripts/test.py << TEST
|
||||
TEST
|
||||
|
||||
echo "--- Dot path tests ---"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_stat(&lfs, "./tea/hottea", &info) => 0;
|
||||
strcmp(info.name, "hottea") => 0;
|
||||
@@ -75,7 +73,7 @@ scripts/test.py << TEST
|
||||
TEST
|
||||
|
||||
echo "--- Dot dot path tests ---"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_stat(&lfs, "coffee/../tea/hottea", &info) => 0;
|
||||
strcmp(info.name, "hottea") => 0;
|
||||
@@ -93,7 +91,7 @@ scripts/test.py << TEST
|
||||
TEST
|
||||
|
||||
echo "--- Trailing dot path tests ---"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_stat(&lfs, "tea/hottea/", &info) => 0;
|
||||
strcmp(info.name, "hottea") => 0;
|
||||
@@ -109,7 +107,7 @@ scripts/test.py << TEST
|
||||
TEST
|
||||
|
||||
echo "--- Root dot dot path tests ---"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_stat(&lfs, "coffee/../../../../../../tea/hottea", &info) => 0;
|
||||
strcmp(info.name, "hottea") => 0;
|
||||
@@ -121,14 +119,14 @@ scripts/test.py << TEST
|
||||
TEST
|
||||
|
||||
echo "--- Root tests ---"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_stat(&lfs, "/", &info) => 0;
|
||||
info.type => LFS_TYPE_DIR;
|
||||
strcmp(info.name, "/") => 0;
|
||||
|
||||
lfs_mkdir(&lfs, "/") => LFS_ERR_EXIST;
|
||||
lfs_file_open(&lfs, &file, "/", LFS_O_WRONLY | LFS_O_CREAT)
|
||||
lfs_file_open(&lfs, &file[0], "/", LFS_O_WRONLY | LFS_O_CREAT)
|
||||
=> LFS_ERR_ISDIR;
|
||||
|
||||
// more corner cases
|
||||
@@ -142,7 +140,7 @@ scripts/test.py << TEST
|
||||
TEST
|
||||
|
||||
echo "--- Sketchy path tests ---"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_mkdir(&lfs, "dirt/ground") => LFS_ERR_NOENT;
|
||||
lfs_mkdir(&lfs, "dirt/ground/earth") => LFS_ERR_NOENT;
|
||||
@@ -150,7 +148,7 @@ scripts/test.py << TEST
|
||||
TEST
|
||||
|
||||
echo "--- Superblock conflict test ---"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_mkdir(&lfs, "littlefs") => 0;
|
||||
lfs_remove(&lfs, "littlefs") => 0;
|
||||
@@ -158,45 +156,46 @@ scripts/test.py << TEST
|
||||
TEST
|
||||
|
||||
echo "--- Max path test ---"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
memset(path, 'w', LFS_NAME_MAX+1);
|
||||
path[LFS_NAME_MAX+2] = '\0';
|
||||
lfs_mkdir(&lfs, path) => LFS_ERR_NAMETOOLONG;
|
||||
lfs_file_open(&lfs, &file, path,
|
||||
memset(buffer, 'w', LFS_NAME_MAX+1);
|
||||
buffer[LFS_NAME_MAX+2] = '\0';
|
||||
lfs_mkdir(&lfs, (char*)buffer) => LFS_ERR_NAMETOOLONG;
|
||||
lfs_file_open(&lfs, &file[0], (char*)buffer,
|
||||
LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_NAMETOOLONG;
|
||||
|
||||
memcpy(path, "coffee/", strlen("coffee/"));
|
||||
memset(path+strlen("coffee/"), 'w', LFS_NAME_MAX+1);
|
||||
path[strlen("coffee/")+LFS_NAME_MAX+2] = '\0';
|
||||
lfs_mkdir(&lfs, path) => LFS_ERR_NAMETOOLONG;
|
||||
lfs_file_open(&lfs, &file, path,
|
||||
memcpy(buffer, "coffee/", strlen("coffee/"));
|
||||
memset(buffer+strlen("coffee/"), 'w', LFS_NAME_MAX+1);
|
||||
buffer[strlen("coffee/")+LFS_NAME_MAX+2] = '\0';
|
||||
lfs_mkdir(&lfs, (char*)buffer) => LFS_ERR_NAMETOOLONG;
|
||||
lfs_file_open(&lfs, &file[0], (char*)buffer,
|
||||
LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_NAMETOOLONG;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
|
||||
echo "--- Really big path test ---"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
memset(path, 'w', LFS_NAME_MAX);
|
||||
path[LFS_NAME_MAX] = '\0';
|
||||
lfs_mkdir(&lfs, path) => 0;
|
||||
lfs_remove(&lfs, path) => 0;
|
||||
lfs_file_open(&lfs, &file, path,
|
||||
memset(buffer, 'w', LFS_NAME_MAX);
|
||||
buffer[LFS_NAME_MAX+1] = '\0';
|
||||
lfs_mkdir(&lfs, (char*)buffer) => 0;
|
||||
lfs_remove(&lfs, (char*)buffer) => 0;
|
||||
lfs_file_open(&lfs, &file[0], (char*)buffer,
|
||||
LFS_O_WRONLY | LFS_O_CREAT) => 0;
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_remove(&lfs, path) => 0;
|
||||
lfs_file_close(&lfs, &file[0]) => 0;
|
||||
lfs_remove(&lfs, (char*)buffer) => 0;
|
||||
|
||||
memcpy(path, "coffee/", strlen("coffee/"));
|
||||
memset(path+strlen("coffee/"), 'w', LFS_NAME_MAX);
|
||||
path[strlen("coffee/")+LFS_NAME_MAX] = '\0';
|
||||
lfs_mkdir(&lfs, path) => 0;
|
||||
lfs_remove(&lfs, path) => 0;
|
||||
lfs_file_open(&lfs, &file, path,
|
||||
memcpy(buffer, "coffee/", strlen("coffee/"));
|
||||
memset(buffer+strlen("coffee/"), 'w', LFS_NAME_MAX);
|
||||
buffer[strlen("coffee/")+LFS_NAME_MAX+1] = '\0';
|
||||
lfs_mkdir(&lfs, (char*)buffer) => 0;
|
||||
lfs_remove(&lfs, (char*)buffer) => 0;
|
||||
lfs_file_open(&lfs, &file[0], (char*)buffer,
|
||||
LFS_O_WRONLY | LFS_O_CREAT) => 0;
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_remove(&lfs, path) => 0;
|
||||
lfs_file_close(&lfs, &file[0]) => 0;
|
||||
lfs_remove(&lfs, (char*)buffer) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
|
||||
scripts/results.py
|
||||
echo "--- Results ---"
|
||||
tests/stats.py
|
||||
|
||||
@@ -1,431 +1,361 @@
|
||||
#!/bin/bash
|
||||
set -eu
|
||||
export TEST_FILE=$0
|
||||
trap 'export TEST_LINE=$LINENO' DEBUG
|
||||
|
||||
echo "=== Seek tests ==="
|
||||
|
||||
SMALLSIZE=4
|
||||
MEDIUMSIZE=128
|
||||
LARGESIZE=132
|
||||
|
||||
echo "=== Seek tests ==="
|
||||
rm -rf blocks
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_format(&lfs, &cfg) => 0;
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_mkdir(&lfs, "hello") => 0;
|
||||
for (int i = 0; i < $LARGESIZE; i++) {
|
||||
sprintf(path, "hello/kitty%03d", i);
|
||||
lfs_file_open(&lfs, &file, path,
|
||||
sprintf((char*)buffer, "hello/kitty%03d", i);
|
||||
lfs_file_open(&lfs, &file[0], (char*)buffer,
|
||||
LFS_O_WRONLY | LFS_O_CREAT | LFS_O_APPEND) => 0;
|
||||
|
||||
lfs_size_t size = strlen("kittycatcat");
|
||||
size = strlen("kittycatcat");
|
||||
memcpy(buffer, "kittycatcat", size);
|
||||
for (int j = 0; j < $LARGESIZE; j++) {
|
||||
lfs_file_write(&lfs, &file, buffer, size);
|
||||
lfs_file_write(&lfs, &file[0], buffer, size);
|
||||
}
|
||||
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_file_close(&lfs, &file[0]) => 0;
|
||||
}
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
|
||||
echo "--- Simple dir seek ---"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "hello") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_open(&lfs, &dir[0], "hello") => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, ".") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "..") => 0;
|
||||
|
||||
lfs_soff_t pos;
|
||||
int i;
|
||||
for (i = 0; i < $SMALLSIZE; i++) {
|
||||
sprintf(path, "kitty%03d", i);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
strcmp(info.name, path) => 0;
|
||||
pos = lfs_dir_tell(&lfs, &dir);
|
||||
sprintf((char*)buffer, "kitty%03d", i);
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, (char*)buffer) => 0;
|
||||
pos = lfs_dir_tell(&lfs, &dir[0]);
|
||||
}
|
||||
pos >= 0 => 1;
|
||||
|
||||
lfs_dir_seek(&lfs, &dir, pos) => 0;
|
||||
sprintf(path, "kitty%03d", i);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
strcmp(info.name, path) => 0;
|
||||
lfs_dir_seek(&lfs, &dir[0], pos) => 0;
|
||||
sprintf((char*)buffer, "kitty%03d", i);
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, (char*)buffer) => 0;
|
||||
|
||||
lfs_dir_rewind(&lfs, &dir) => 0;
|
||||
sprintf(path, "kitty%03d", 0);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_rewind(&lfs, &dir[0]) => 0;
|
||||
sprintf((char*)buffer, "kitty%03d", 0);
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, ".") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "..") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
strcmp(info.name, path) => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, (char*)buffer) => 0;
|
||||
|
||||
lfs_dir_seek(&lfs, &dir, pos) => 0;
|
||||
sprintf(path, "kitty%03d", i);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
strcmp(info.name, path) => 0;
|
||||
lfs_dir_seek(&lfs, &dir[0], pos) => 0;
|
||||
sprintf((char*)buffer, "kitty%03d", i);
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, (char*)buffer) => 0;
|
||||
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
lfs_dir_close(&lfs, &dir[0]) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
|
||||
echo "--- Large dir seek ---"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "hello") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_open(&lfs, &dir[0], "hello") => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, ".") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "..") => 0;
|
||||
|
||||
lfs_soff_t pos;
|
||||
int i;
|
||||
for (i = 0; i < $MEDIUMSIZE; i++) {
|
||||
sprintf(path, "kitty%03d", i);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
strcmp(info.name, path) => 0;
|
||||
pos = lfs_dir_tell(&lfs, &dir);
|
||||
sprintf((char*)buffer, "kitty%03d", i);
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, (char*)buffer) => 0;
|
||||
pos = lfs_dir_tell(&lfs, &dir[0]);
|
||||
}
|
||||
pos >= 0 => 1;
|
||||
|
||||
lfs_dir_seek(&lfs, &dir, pos) => 0;
|
||||
sprintf(path, "kitty%03d", i);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
strcmp(info.name, path) => 0;
|
||||
lfs_dir_seek(&lfs, &dir[0], pos) => 0;
|
||||
sprintf((char*)buffer, "kitty%03d", i);
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, (char*)buffer) => 0;
|
||||
|
||||
lfs_dir_rewind(&lfs, &dir) => 0;
|
||||
sprintf(path, "kitty%03d", 0);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_rewind(&lfs, &dir[0]) => 0;
|
||||
sprintf((char*)buffer, "kitty%03d", 0);
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, ".") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, "..") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
strcmp(info.name, path) => 0;
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, (char*)buffer) => 0;
|
||||
|
||||
lfs_dir_seek(&lfs, &dir, pos) => 0;
|
||||
sprintf(path, "kitty%03d", i);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
strcmp(info.name, path) => 0;
|
||||
lfs_dir_seek(&lfs, &dir[0], pos) => 0;
|
||||
sprintf((char*)buffer, "kitty%03d", i);
|
||||
lfs_dir_read(&lfs, &dir[0], &info) => 1;
|
||||
strcmp(info.name, (char*)buffer) => 0;
|
||||
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
lfs_dir_close(&lfs, &dir[0]) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
|
||||
echo "--- Simple file seek ---"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_file_open(&lfs, &file, "hello/kitty042", LFS_O_RDONLY) => 0;
|
||||
lfs_file_open(&lfs, &file[0], "hello/kitty042", LFS_O_RDONLY) => 0;
|
||||
|
||||
lfs_soff_t pos;
|
||||
lfs_size_t size = strlen("kittycatcat");
|
||||
size = strlen("kittycatcat");
|
||||
for (int i = 0; i < $SMALLSIZE; i++) {
|
||||
lfs_file_read(&lfs, &file, buffer, size) => size;
|
||||
lfs_file_read(&lfs, &file[0], buffer, size) => size;
|
||||
memcmp(buffer, "kittycatcat", size) => 0;
|
||||
pos = lfs_file_tell(&lfs, &file);
|
||||
pos = lfs_file_tell(&lfs, &file[0]);
|
||||
}
|
||||
pos >= 0 => 1;
|
||||
|
||||
lfs_file_seek(&lfs, &file, pos, LFS_SEEK_SET) => pos;
|
||||
lfs_file_read(&lfs, &file, buffer, size) => size;
|
||||
lfs_file_seek(&lfs, &file[0], pos, LFS_SEEK_SET) => pos;
|
||||
lfs_file_read(&lfs, &file[0], buffer, size) => size;
|
||||
memcmp(buffer, "kittycatcat", size) => 0;
|
||||
|
||||
lfs_file_rewind(&lfs, &file) => 0;
|
||||
lfs_file_read(&lfs, &file, buffer, size) => size;
|
||||
lfs_file_rewind(&lfs, &file[0]) => 0;
|
||||
lfs_file_read(&lfs, &file[0], buffer, size) => size;
|
||||
memcmp(buffer, "kittycatcat", size) => 0;
|
||||
|
||||
lfs_file_seek(&lfs, &file, 0, LFS_SEEK_CUR) => size;
|
||||
lfs_file_read(&lfs, &file, buffer, size) => size;
|
||||
lfs_file_seek(&lfs, &file[0], 0, LFS_SEEK_CUR) => size;
|
||||
lfs_file_read(&lfs, &file[0], buffer, size) => size;
|
||||
memcmp(buffer, "kittycatcat", size) => 0;
|
||||
|
||||
lfs_file_seek(&lfs, &file, size, LFS_SEEK_CUR) => 3*size;
|
||||
lfs_file_read(&lfs, &file, buffer, size) => size;
|
||||
lfs_file_seek(&lfs, &file[0], size, LFS_SEEK_CUR) => 3*size;
|
||||
lfs_file_read(&lfs, &file[0], buffer, size) => size;
|
||||
memcmp(buffer, "kittycatcat", size) => 0;
|
||||
|
||||
lfs_file_seek(&lfs, &file, pos, LFS_SEEK_SET) => pos;
|
||||
lfs_file_read(&lfs, &file, buffer, size) => size;
|
||||
lfs_file_seek(&lfs, &file[0], pos, LFS_SEEK_SET) => pos;
|
||||
lfs_file_read(&lfs, &file[0], buffer, size) => size;
|
||||
memcmp(buffer, "kittycatcat", size) => 0;
|
||||
|
||||
lfs_file_seek(&lfs, &file, -size, LFS_SEEK_CUR) => pos;
|
||||
lfs_file_read(&lfs, &file, buffer, size) => size;
|
||||
lfs_file_seek(&lfs, &file[0], -size, LFS_SEEK_CUR) => pos;
|
||||
lfs_file_read(&lfs, &file[0], buffer, size) => size;
|
||||
memcmp(buffer, "kittycatcat", size) => 0;
|
||||
|
||||
lfs_file_seek(&lfs, &file, -size, LFS_SEEK_END) >= 0 => 1;
|
||||
lfs_file_read(&lfs, &file, buffer, size) => size;
|
||||
lfs_file_seek(&lfs, &file[0], -size, LFS_SEEK_END) >= 0 => 1;
|
||||
lfs_file_read(&lfs, &file[0], buffer, size) => size;
|
||||
memcmp(buffer, "kittycatcat", size) => 0;
|
||||
|
||||
size = lfs_file_size(&lfs, &file);
|
||||
lfs_file_seek(&lfs, &file, 0, LFS_SEEK_CUR) => size;
|
||||
size = lfs_file_size(&lfs, &file[0]);
|
||||
lfs_file_seek(&lfs, &file[0], 0, LFS_SEEK_CUR) => size;
|
||||
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_file_close(&lfs, &file[0]) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
|
||||
echo "--- Large file seek ---"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_file_open(&lfs, &file, "hello/kitty042", LFS_O_RDONLY) => 0;
|
||||
lfs_file_open(&lfs, &file[0], "hello/kitty042", LFS_O_RDONLY) => 0;
|
||||
|
||||
lfs_soff_t pos;
|
||||
lfs_size_t size = strlen("kittycatcat");
|
||||
size = strlen("kittycatcat");
|
||||
for (int i = 0; i < $MEDIUMSIZE; i++) {
|
||||
lfs_file_read(&lfs, &file, buffer, size) => size;
|
||||
lfs_file_read(&lfs, &file[0], buffer, size) => size;
|
||||
memcmp(buffer, "kittycatcat", size) => 0;
|
||||
pos = lfs_file_tell(&lfs, &file);
|
||||
pos = lfs_file_tell(&lfs, &file[0]);
|
||||
}
|
||||
pos >= 0 => 1;
|
||||
|
||||
lfs_file_seek(&lfs, &file, pos, LFS_SEEK_SET) => pos;
|
||||
lfs_file_read(&lfs, &file, buffer, size) => size;
|
||||
lfs_file_seek(&lfs, &file[0], pos, LFS_SEEK_SET) => pos;
|
||||
lfs_file_read(&lfs, &file[0], buffer, size) => size;
|
||||
memcmp(buffer, "kittycatcat", size) => 0;
|
||||
|
||||
lfs_file_rewind(&lfs, &file) => 0;
|
||||
lfs_file_read(&lfs, &file, buffer, size) => size;
|
||||
lfs_file_rewind(&lfs, &file[0]) => 0;
|
||||
lfs_file_read(&lfs, &file[0], buffer, size) => size;
|
||||
memcmp(buffer, "kittycatcat", size) => 0;
|
||||
|
||||
lfs_file_seek(&lfs, &file, 0, LFS_SEEK_CUR) => size;
|
||||
lfs_file_read(&lfs, &file, buffer, size) => size;
|
||||
lfs_file_seek(&lfs, &file[0], 0, LFS_SEEK_CUR) => size;
|
||||
lfs_file_read(&lfs, &file[0], buffer, size) => size;
|
||||
memcmp(buffer, "kittycatcat", size) => 0;
|
||||
|
||||
lfs_file_seek(&lfs, &file, size, LFS_SEEK_CUR) => 3*size;
|
||||
lfs_file_read(&lfs, &file, buffer, size) => size;
|
||||
lfs_file_seek(&lfs, &file[0], size, LFS_SEEK_CUR) => 3*size;
|
||||
lfs_file_read(&lfs, &file[0], buffer, size) => size;
|
||||
memcmp(buffer, "kittycatcat", size) => 0;
|
||||
|
||||
lfs_file_seek(&lfs, &file, pos, LFS_SEEK_SET) => pos;
|
||||
lfs_file_read(&lfs, &file, buffer, size) => size;
|
||||
lfs_file_seek(&lfs, &file[0], pos, LFS_SEEK_SET) => pos;
|
||||
lfs_file_read(&lfs, &file[0], buffer, size) => size;
|
||||
memcmp(buffer, "kittycatcat", size) => 0;
|
||||
|
||||
lfs_file_seek(&lfs, &file, -size, LFS_SEEK_CUR) => pos;
|
||||
lfs_file_read(&lfs, &file, buffer, size) => size;
|
||||
lfs_file_seek(&lfs, &file[0], -size, LFS_SEEK_CUR) => pos;
|
||||
lfs_file_read(&lfs, &file[0], buffer, size) => size;
|
||||
memcmp(buffer, "kittycatcat", size) => 0;
|
||||
|
||||
lfs_file_seek(&lfs, &file, -size, LFS_SEEK_END) >= 0 => 1;
|
||||
lfs_file_read(&lfs, &file, buffer, size) => size;
|
||||
lfs_file_seek(&lfs, &file[0], -size, LFS_SEEK_END) >= 0 => 1;
|
||||
lfs_file_read(&lfs, &file[0], buffer, size) => size;
|
||||
memcmp(buffer, "kittycatcat", size) => 0;
|
||||
|
||||
size = lfs_file_size(&lfs, &file);
|
||||
lfs_file_seek(&lfs, &file, 0, LFS_SEEK_CUR) => size;
|
||||
size = lfs_file_size(&lfs, &file[0]);
|
||||
lfs_file_seek(&lfs, &file[0], 0, LFS_SEEK_CUR) => size;
|
||||
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_file_close(&lfs, &file[0]) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
|
||||
echo "--- Simple file seek and write ---"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_file_open(&lfs, &file, "hello/kitty042", LFS_O_RDWR) => 0;
|
||||
lfs_file_open(&lfs, &file[0], "hello/kitty042", LFS_O_RDWR) => 0;
|
||||
|
||||
lfs_soff_t pos;
|
||||
lfs_size_t size = strlen("kittycatcat");
|
||||
size = strlen("kittycatcat");
|
||||
for (int i = 0; i < $SMALLSIZE; i++) {
|
||||
lfs_file_read(&lfs, &file, buffer, size) => size;
|
||||
lfs_file_read(&lfs, &file[0], buffer, size) => size;
|
||||
memcmp(buffer, "kittycatcat", size) => 0;
|
||||
pos = lfs_file_tell(&lfs, &file);
|
||||
pos = lfs_file_tell(&lfs, &file[0]);
|
||||
}
|
||||
pos >= 0 => 1;
|
||||
|
||||
memcpy(buffer, "doggodogdog", size);
|
||||
lfs_file_seek(&lfs, &file, pos, LFS_SEEK_SET) => pos;
|
||||
lfs_file_write(&lfs, &file, buffer, size) => size;
|
||||
lfs_file_seek(&lfs, &file[0], pos, LFS_SEEK_SET) => pos;
|
||||
lfs_file_write(&lfs, &file[0], buffer, size) => size;
|
||||
|
||||
lfs_file_seek(&lfs, &file, pos, LFS_SEEK_SET) => pos;
|
||||
lfs_file_read(&lfs, &file, buffer, size) => size;
|
||||
lfs_file_seek(&lfs, &file[0], pos, LFS_SEEK_SET) => pos;
|
||||
lfs_file_read(&lfs, &file[0], buffer, size) => size;
|
||||
memcmp(buffer, "doggodogdog", size) => 0;
|
||||
|
||||
lfs_file_rewind(&lfs, &file) => 0;
|
||||
lfs_file_read(&lfs, &file, buffer, size) => size;
|
||||
lfs_file_rewind(&lfs, &file[0]) => 0;
|
||||
lfs_file_read(&lfs, &file[0], buffer, size) => size;
|
||||
memcmp(buffer, "kittycatcat", size) => 0;
|
||||
|
||||
lfs_file_seek(&lfs, &file, pos, LFS_SEEK_SET) => pos;
|
||||
lfs_file_read(&lfs, &file, buffer, size) => size;
|
||||
lfs_file_seek(&lfs, &file[0], pos, LFS_SEEK_SET) => pos;
|
||||
lfs_file_read(&lfs, &file[0], buffer, size) => size;
|
||||
memcmp(buffer, "doggodogdog", size) => 0;
|
||||
|
||||
lfs_file_seek(&lfs, &file, -size, LFS_SEEK_END) >= 0 => 1;
|
||||
lfs_file_read(&lfs, &file, buffer, size) => size;
|
||||
lfs_file_seek(&lfs, &file[0], -size, LFS_SEEK_END) >= 0 => 1;
|
||||
lfs_file_read(&lfs, &file[0], buffer, size) => size;
|
||||
memcmp(buffer, "kittycatcat", size) => 0;
|
||||
|
||||
size = lfs_file_size(&lfs, &file);
|
||||
lfs_file_seek(&lfs, &file, 0, LFS_SEEK_CUR) => size;
|
||||
size = lfs_file_size(&lfs, &file[0]);
|
||||
lfs_file_seek(&lfs, &file[0], 0, LFS_SEEK_CUR) => size;
|
||||
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_file_close(&lfs, &file[0]) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
|
||||
echo "--- Large file seek and write ---"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_file_open(&lfs, &file, "hello/kitty042", LFS_O_RDWR) => 0;
|
||||
lfs_file_open(&lfs, &file[0], "hello/kitty042", LFS_O_RDWR) => 0;
|
||||
|
||||
lfs_soff_t pos;
|
||||
lfs_size_t size = strlen("kittycatcat");
|
||||
size = strlen("kittycatcat");
|
||||
for (int i = 0; i < $MEDIUMSIZE; i++) {
|
||||
lfs_file_read(&lfs, &file, buffer, size) => size;
|
||||
lfs_file_read(&lfs, &file[0], buffer, size) => size;
|
||||
if (i != $SMALLSIZE) {
|
||||
memcmp(buffer, "kittycatcat", size) => 0;
|
||||
}
|
||||
pos = lfs_file_tell(&lfs, &file);
|
||||
pos = lfs_file_tell(&lfs, &file[0]);
|
||||
}
|
||||
pos >= 0 => 1;
|
||||
|
||||
memcpy(buffer, "doggodogdog", size);
|
||||
lfs_file_seek(&lfs, &file, pos, LFS_SEEK_SET) => pos;
|
||||
lfs_file_write(&lfs, &file, buffer, size) => size;
|
||||
lfs_file_seek(&lfs, &file[0], pos, LFS_SEEK_SET) => pos;
|
||||
lfs_file_write(&lfs, &file[0], buffer, size) => size;
|
||||
|
||||
lfs_file_seek(&lfs, &file, pos, LFS_SEEK_SET) => pos;
|
||||
lfs_file_read(&lfs, &file, buffer, size) => size;
|
||||
lfs_file_seek(&lfs, &file[0], pos, LFS_SEEK_SET) => pos;
|
||||
lfs_file_read(&lfs, &file[0], buffer, size) => size;
|
||||
memcmp(buffer, "doggodogdog", size) => 0;
|
||||
|
||||
lfs_file_rewind(&lfs, &file) => 0;
|
||||
lfs_file_read(&lfs, &file, buffer, size) => size;
|
||||
lfs_file_rewind(&lfs, &file[0]) => 0;
|
||||
lfs_file_read(&lfs, &file[0], buffer, size) => size;
|
||||
memcmp(buffer, "kittycatcat", size) => 0;
|
||||
|
||||
lfs_file_seek(&lfs, &file, pos, LFS_SEEK_SET) => pos;
|
||||
lfs_file_read(&lfs, &file, buffer, size) => size;
|
||||
lfs_file_seek(&lfs, &file[0], pos, LFS_SEEK_SET) => pos;
|
||||
lfs_file_read(&lfs, &file[0], buffer, size) => size;
|
||||
memcmp(buffer, "doggodogdog", size) => 0;
|
||||
|
||||
lfs_file_seek(&lfs, &file, -size, LFS_SEEK_END) >= 0 => 1;
|
||||
lfs_file_read(&lfs, &file, buffer, size) => size;
|
||||
lfs_file_seek(&lfs, &file[0], -size, LFS_SEEK_END) >= 0 => 1;
|
||||
lfs_file_read(&lfs, &file[0], buffer, size) => size;
|
||||
memcmp(buffer, "kittycatcat", size) => 0;
|
||||
|
||||
size = lfs_file_size(&lfs, &file);
|
||||
lfs_file_seek(&lfs, &file, 0, LFS_SEEK_CUR) => size;
|
||||
size = lfs_file_size(&lfs, &file[0]);
|
||||
lfs_file_seek(&lfs, &file[0], 0, LFS_SEEK_CUR) => size;
|
||||
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_file_close(&lfs, &file[0]) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
|
||||
echo "--- Boundary seek and write ---"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_file_open(&lfs, &file, "hello/kitty042", LFS_O_RDWR) => 0;
|
||||
lfs_file_open(&lfs, &file[0], "hello/kitty042", LFS_O_RDWR) => 0;
|
||||
|
||||
lfs_size_t size = strlen("hedgehoghog");
|
||||
size = strlen("hedgehoghog");
|
||||
const lfs_soff_t offsets[] = {512, 1020, 513, 1021, 511, 1019};
|
||||
|
||||
for (unsigned i = 0; i < sizeof(offsets) / sizeof(offsets[0]); i++) {
|
||||
lfs_soff_t off = offsets[i];
|
||||
memcpy(buffer, "hedgehoghog", size);
|
||||
lfs_file_seek(&lfs, &file, off, LFS_SEEK_SET) => off;
|
||||
lfs_file_write(&lfs, &file, buffer, size) => size;
|
||||
lfs_file_seek(&lfs, &file, off, LFS_SEEK_SET) => off;
|
||||
lfs_file_read(&lfs, &file, buffer, size) => size;
|
||||
lfs_file_seek(&lfs, &file[0], off, LFS_SEEK_SET) => off;
|
||||
lfs_file_write(&lfs, &file[0], buffer, size) => size;
|
||||
lfs_file_seek(&lfs, &file[0], off, LFS_SEEK_SET) => off;
|
||||
lfs_file_read(&lfs, &file[0], buffer, size) => size;
|
||||
memcmp(buffer, "hedgehoghog", size) => 0;
|
||||
|
||||
lfs_file_seek(&lfs, &file, 0, LFS_SEEK_SET) => 0;
|
||||
lfs_file_read(&lfs, &file, buffer, size) => size;
|
||||
lfs_file_seek(&lfs, &file[0], 0, LFS_SEEK_SET) => 0;
|
||||
lfs_file_read(&lfs, &file[0], buffer, size) => size;
|
||||
memcmp(buffer, "kittycatcat", size) => 0;
|
||||
|
||||
lfs_file_sync(&lfs, &file) => 0;
|
||||
lfs_file_sync(&lfs, &file[0]) => 0;
|
||||
}
|
||||
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_file_close(&lfs, &file[0]) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
|
||||
echo "--- Out-of-bounds seek ---"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_file_open(&lfs, &file, "hello/kitty042", LFS_O_RDWR) => 0;
|
||||
lfs_file_open(&lfs, &file[0], "hello/kitty042", LFS_O_RDWR) => 0;
|
||||
|
||||
lfs_size_t size = strlen("kittycatcat");
|
||||
lfs_file_size(&lfs, &file) => $LARGESIZE*size;
|
||||
lfs_file_seek(&lfs, &file, ($LARGESIZE+$SMALLSIZE)*size,
|
||||
size = strlen("kittycatcat");
|
||||
lfs_file_size(&lfs, &file[0]) => $LARGESIZE*size;
|
||||
lfs_file_seek(&lfs, &file[0], ($LARGESIZE+$SMALLSIZE)*size,
|
||||
LFS_SEEK_SET) => ($LARGESIZE+$SMALLSIZE)*size;
|
||||
lfs_file_read(&lfs, &file, buffer, size) => 0;
|
||||
lfs_file_read(&lfs, &file[0], buffer, size) => 0;
|
||||
|
||||
memcpy(buffer, "porcupineee", size);
|
||||
lfs_file_write(&lfs, &file, buffer, size) => size;
|
||||
lfs_file_write(&lfs, &file[0], buffer, size) => size;
|
||||
|
||||
lfs_file_seek(&lfs, &file, ($LARGESIZE+$SMALLSIZE)*size,
|
||||
lfs_file_seek(&lfs, &file[0], ($LARGESIZE+$SMALLSIZE)*size,
|
||||
LFS_SEEK_SET) => ($LARGESIZE+$SMALLSIZE)*size;
|
||||
lfs_file_read(&lfs, &file, buffer, size) => size;
|
||||
lfs_file_read(&lfs, &file[0], buffer, size) => size;
|
||||
memcmp(buffer, "porcupineee", size) => 0;
|
||||
|
||||
lfs_file_seek(&lfs, &file, $LARGESIZE*size,
|
||||
lfs_file_seek(&lfs, &file[0], $LARGESIZE*size,
|
||||
LFS_SEEK_SET) => $LARGESIZE*size;
|
||||
lfs_file_read(&lfs, &file, buffer, size) => size;
|
||||
lfs_file_read(&lfs, &file[0], buffer, size) => size;
|
||||
memcmp(buffer, "\0\0\0\0\0\0\0\0\0\0\0", size) => 0;
|
||||
|
||||
lfs_file_seek(&lfs, &file, -(($LARGESIZE+$SMALLSIZE)*size),
|
||||
lfs_file_seek(&lfs, &file[0], -(($LARGESIZE+$SMALLSIZE)*size),
|
||||
LFS_SEEK_CUR) => LFS_ERR_INVAL;
|
||||
lfs_file_tell(&lfs, &file) => ($LARGESIZE+1)*size;
|
||||
lfs_file_tell(&lfs, &file[0]) => ($LARGESIZE+1)*size;
|
||||
|
||||
lfs_file_seek(&lfs, &file, -(($LARGESIZE+2*$SMALLSIZE)*size),
|
||||
lfs_file_seek(&lfs, &file[0], -(($LARGESIZE+2*$SMALLSIZE)*size),
|
||||
LFS_SEEK_END) => LFS_ERR_INVAL;
|
||||
lfs_file_tell(&lfs, &file) => ($LARGESIZE+1)*size;
|
||||
lfs_file_tell(&lfs, &file[0]) => ($LARGESIZE+1)*size;
|
||||
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_file_close(&lfs, &file[0]) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
|
||||
echo "--- Inline write and seek ---"
|
||||
for SIZE in $SMALLSIZE $MEDIUMSIZE $LARGESIZE
|
||||
do
|
||||
scripts/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_file_open(&lfs, &file, "hello/tinykitty$SIZE",
|
||||
LFS_O_RDWR | LFS_O_CREAT) => 0;
|
||||
int j = 0;
|
||||
int k = 0;
|
||||
|
||||
memcpy(buffer, "abcdefghijklmnopqrstuvwxyz", 26);
|
||||
for (unsigned i = 0; i < $SIZE; i++) {
|
||||
lfs_file_write(&lfs, &file, &buffer[j++ % 26], 1) => 1;
|
||||
lfs_file_tell(&lfs, &file) => i+1;
|
||||
lfs_file_size(&lfs, &file) => i+1;
|
||||
}
|
||||
|
||||
lfs_file_seek(&lfs, &file, 0, LFS_SEEK_SET) => 0;
|
||||
lfs_file_tell(&lfs, &file) => 0;
|
||||
lfs_file_size(&lfs, &file) => $SIZE;
|
||||
for (unsigned i = 0; i < $SIZE; i++) {
|
||||
uint8_t c;
|
||||
lfs_file_read(&lfs, &file, &c, 1) => 1;
|
||||
c => buffer[k++ % 26];
|
||||
}
|
||||
|
||||
lfs_file_sync(&lfs, &file) => 0;
|
||||
lfs_file_tell(&lfs, &file) => $SIZE;
|
||||
lfs_file_size(&lfs, &file) => $SIZE;
|
||||
|
||||
lfs_file_seek(&lfs, &file, 0, LFS_SEEK_SET) => 0;
|
||||
for (unsigned i = 0; i < $SIZE; i++) {
|
||||
lfs_file_write(&lfs, &file, &buffer[j++ % 26], 1) => 1;
|
||||
lfs_file_tell(&lfs, &file) => i+1;
|
||||
lfs_file_size(&lfs, &file) => $SIZE;
|
||||
lfs_file_sync(&lfs, &file) => 0;
|
||||
lfs_file_tell(&lfs, &file) => i+1;
|
||||
lfs_file_size(&lfs, &file) => $SIZE;
|
||||
if (i < $SIZE-2) {
|
||||
uint8_t c[3];
|
||||
lfs_file_seek(&lfs, &file, -1, LFS_SEEK_CUR) => i;
|
||||
lfs_file_read(&lfs, &file, &c, 3) => 3;
|
||||
lfs_file_tell(&lfs, &file) => i+3;
|
||||
lfs_file_size(&lfs, &file) => $SIZE;
|
||||
lfs_file_seek(&lfs, &file, i+1, LFS_SEEK_SET) => i+1;
|
||||
lfs_file_tell(&lfs, &file) => i+1;
|
||||
lfs_file_size(&lfs, &file) => $SIZE;
|
||||
}
|
||||
}
|
||||
|
||||
lfs_file_seek(&lfs, &file, 0, LFS_SEEK_SET) => 0;
|
||||
lfs_file_tell(&lfs, &file) => 0;
|
||||
lfs_file_size(&lfs, &file) => $SIZE;
|
||||
for (unsigned i = 0; i < $SIZE; i++) {
|
||||
uint8_t c;
|
||||
lfs_file_read(&lfs, &file, &c, 1) => 1;
|
||||
c => buffer[k++ % 26];
|
||||
}
|
||||
|
||||
lfs_file_sync(&lfs, &file) => 0;
|
||||
lfs_file_tell(&lfs, &file) => $SIZE;
|
||||
lfs_file_size(&lfs, &file) => $SIZE;
|
||||
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
done
|
||||
|
||||
scripts/results.py
|
||||
echo "--- Results ---"
|
||||
tests/stats.py
|
||||
|
||||
@@ -1,220 +1,22 @@
|
||||
#!/bin/bash
|
||||
set -eu
|
||||
export TEST_FILE=$0
|
||||
trap 'export TEST_LINE=$LINENO' DEBUG
|
||||
|
||||
echo "=== Truncate tests ==="
|
||||
|
||||
SMALLSIZE=32
|
||||
MEDIUMSIZE=2048
|
||||
LARGESIZE=8192
|
||||
|
||||
echo "=== Truncate tests ==="
|
||||
rm -rf blocks
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
lfs_format(&lfs, &cfg) => 0;
|
||||
TEST
|
||||
|
||||
echo "--- Simple truncate ---"
|
||||
scripts/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_file_open(&lfs, &file, "baldynoop",
|
||||
LFS_O_WRONLY | LFS_O_CREAT) => 0;
|
||||
|
||||
strcpy((char*)buffer, "hair");
|
||||
lfs_size_t size = strlen((char*)buffer);
|
||||
for (lfs_off_t j = 0; j < $LARGESIZE; j += size) {
|
||||
lfs_file_write(&lfs, &file, buffer, size) => size;
|
||||
}
|
||||
lfs_file_size(&lfs, &file) => $LARGESIZE;
|
||||
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
scripts/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_file_open(&lfs, &file, "baldynoop", LFS_O_RDWR) => 0;
|
||||
lfs_file_size(&lfs, &file) => $LARGESIZE;
|
||||
|
||||
lfs_file_truncate(&lfs, &file, $MEDIUMSIZE) => 0;
|
||||
lfs_file_size(&lfs, &file) => $MEDIUMSIZE;
|
||||
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
scripts/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_file_open(&lfs, &file, "baldynoop", LFS_O_RDONLY) => 0;
|
||||
lfs_file_size(&lfs, &file) => $MEDIUMSIZE;
|
||||
|
||||
lfs_size_t size = strlen("hair");
|
||||
for (lfs_off_t j = 0; j < $MEDIUMSIZE; j += size) {
|
||||
lfs_file_read(&lfs, &file, buffer, size) => size;
|
||||
memcmp(buffer, "hair", size) => 0;
|
||||
}
|
||||
lfs_file_read(&lfs, &file, buffer, size) => 0;
|
||||
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
|
||||
echo "--- Truncate and read ---"
|
||||
scripts/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_file_open(&lfs, &file, "baldyread",
|
||||
LFS_O_WRONLY | LFS_O_CREAT) => 0;
|
||||
|
||||
strcpy((char*)buffer, "hair");
|
||||
lfs_size_t size = strlen((char*)buffer);
|
||||
for (lfs_off_t j = 0; j < $LARGESIZE; j += size) {
|
||||
lfs_file_write(&lfs, &file, buffer, size) => size;
|
||||
}
|
||||
lfs_file_size(&lfs, &file) => $LARGESIZE;
|
||||
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
scripts/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_file_open(&lfs, &file, "baldyread", LFS_O_RDWR) => 0;
|
||||
lfs_file_size(&lfs, &file) => $LARGESIZE;
|
||||
|
||||
lfs_file_truncate(&lfs, &file, $MEDIUMSIZE) => 0;
|
||||
lfs_file_size(&lfs, &file) => $MEDIUMSIZE;
|
||||
|
||||
lfs_size_t size = strlen("hair");
|
||||
for (lfs_off_t j = 0; j < $MEDIUMSIZE; j += size) {
|
||||
lfs_file_read(&lfs, &file, buffer, size) => size;
|
||||
memcmp(buffer, "hair", size) => 0;
|
||||
}
|
||||
lfs_file_read(&lfs, &file, buffer, size) => 0;
|
||||
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
scripts/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_file_open(&lfs, &file, "baldyread", LFS_O_RDONLY) => 0;
|
||||
lfs_file_size(&lfs, &file) => $MEDIUMSIZE;
|
||||
|
||||
lfs_size_t size = strlen("hair");
|
||||
for (lfs_off_t j = 0; j < $MEDIUMSIZE; j += size) {
|
||||
lfs_file_read(&lfs, &file, buffer, size) => size;
|
||||
memcmp(buffer, "hair", size) => 0;
|
||||
}
|
||||
lfs_file_read(&lfs, &file, buffer, size) => 0;
|
||||
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
|
||||
echo "--- Write, truncate, and read ---"
|
||||
scripts/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_file_open(&lfs, &file, "sequence",
|
||||
LFS_O_RDWR | LFS_O_CREAT | LFS_O_TRUNC) => 0;
|
||||
|
||||
lfs_size_t size = lfs.cfg->cache_size;
|
||||
lfs_size_t qsize = size / 4;
|
||||
uint8_t *wb = buffer;
|
||||
uint8_t *rb = buffer + size;
|
||||
for (lfs_off_t j = 0; j < size; ++j) {
|
||||
wb[j] = j;
|
||||
}
|
||||
|
||||
/* Spread sequence over size */
|
||||
lfs_file_write(&lfs, &file, wb, size) => size;
|
||||
lfs_file_size(&lfs, &file) => size;
|
||||
lfs_file_tell(&lfs, &file) => size;
|
||||
|
||||
lfs_file_seek(&lfs, &file, 0, LFS_SEEK_SET) => 0;
|
||||
lfs_file_tell(&lfs, &file) => 0;
|
||||
|
||||
/* Chop off the last quarter */
|
||||
lfs_size_t trunc = size - qsize;
|
||||
lfs_file_truncate(&lfs, &file, trunc) => 0;
|
||||
lfs_file_tell(&lfs, &file) => 0;
|
||||
lfs_file_size(&lfs, &file) => trunc;
|
||||
|
||||
/* Read should produce first 3/4 */
|
||||
lfs_file_read(&lfs, &file, rb, size) => trunc;
|
||||
memcmp(rb, wb, trunc) => 0;
|
||||
|
||||
/* Move to 1/4 */
|
||||
lfs_file_size(&lfs, &file) => trunc;
|
||||
lfs_file_seek(&lfs, &file, qsize, LFS_SEEK_SET) => qsize;
|
||||
lfs_file_tell(&lfs, &file) => qsize;
|
||||
|
||||
/* Chop to 1/2 */
|
||||
trunc -= qsize;
|
||||
lfs_file_truncate(&lfs, &file, trunc) => 0;
|
||||
lfs_file_tell(&lfs, &file) => qsize;
|
||||
lfs_file_size(&lfs, &file) => trunc;
|
||||
|
||||
/* Read should produce second quarter */
|
||||
lfs_file_read(&lfs, &file, rb, size) => trunc - qsize;
|
||||
memcmp(rb, wb + qsize, trunc - qsize) => 0;
|
||||
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
|
||||
echo "--- Truncate and write ---"
|
||||
scripts/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_file_open(&lfs, &file, "baldywrite",
|
||||
LFS_O_WRONLY | LFS_O_CREAT) => 0;
|
||||
|
||||
strcpy((char*)buffer, "hair");
|
||||
lfs_size_t size = strlen((char*)buffer);
|
||||
for (lfs_off_t j = 0; j < $LARGESIZE; j += size) {
|
||||
lfs_file_write(&lfs, &file, buffer, size) => size;
|
||||
}
|
||||
lfs_file_size(&lfs, &file) => $LARGESIZE;
|
||||
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
scripts/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_file_open(&lfs, &file, "baldywrite", LFS_O_RDWR) => 0;
|
||||
lfs_file_size(&lfs, &file) => $LARGESIZE;
|
||||
|
||||
lfs_file_truncate(&lfs, &file, $MEDIUMSIZE) => 0;
|
||||
lfs_file_size(&lfs, &file) => $MEDIUMSIZE;
|
||||
|
||||
strcpy((char*)buffer, "bald");
|
||||
lfs_size_t size = strlen((char*)buffer);
|
||||
for (lfs_off_t j = 0; j < $MEDIUMSIZE; j += size) {
|
||||
lfs_file_write(&lfs, &file, buffer, size) => size;
|
||||
}
|
||||
lfs_file_size(&lfs, &file) => $MEDIUMSIZE;
|
||||
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
scripts/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_file_open(&lfs, &file, "baldywrite", LFS_O_RDONLY) => 0;
|
||||
lfs_file_size(&lfs, &file) => $MEDIUMSIZE;
|
||||
|
||||
lfs_size_t size = strlen("bald");
|
||||
for (lfs_off_t j = 0; j < $MEDIUMSIZE; j += size) {
|
||||
lfs_file_read(&lfs, &file, buffer, size) => size;
|
||||
memcmp(buffer, "bald", size) => 0;
|
||||
}
|
||||
lfs_file_read(&lfs, &file, buffer, size) => 0;
|
||||
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
|
||||
# More aggressive general truncation tests
|
||||
truncate_test() {
|
||||
STARTSIZES="$1"
|
||||
STARTSEEKS="$2"
|
||||
HOTSIZES="$3"
|
||||
COLDSIZES="$4"
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
static const lfs_off_t startsizes[] = {$STARTSIZES};
|
||||
static const lfs_off_t startseeks[] = {$STARTSEEKS};
|
||||
static const lfs_off_t hotsizes[] = {$HOTSIZES};
|
||||
@@ -222,31 +24,31 @@ scripts/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
|
||||
for (unsigned i = 0; i < sizeof(startsizes)/sizeof(startsizes[0]); i++) {
|
||||
sprintf(path, "hairyhead%d", i);
|
||||
lfs_file_open(&lfs, &file, path,
|
||||
sprintf((char*)buffer, "hairyhead%d", i);
|
||||
lfs_file_open(&lfs, &file[0], (const char*)buffer,
|
||||
LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0;
|
||||
|
||||
strcpy((char*)buffer, "hair");
|
||||
lfs_size_t size = strlen((char*)buffer);
|
||||
size = strlen((char*)buffer);
|
||||
for (lfs_off_t j = 0; j < startsizes[i]; j += size) {
|
||||
lfs_file_write(&lfs, &file, buffer, size) => size;
|
||||
lfs_file_write(&lfs, &file[0], buffer, size) => size;
|
||||
}
|
||||
lfs_file_size(&lfs, &file) => startsizes[i];
|
||||
lfs_file_size(&lfs, &file[0]) => startsizes[i];
|
||||
|
||||
if (startseeks[i] != startsizes[i]) {
|
||||
lfs_file_seek(&lfs, &file,
|
||||
lfs_file_seek(&lfs, &file[0],
|
||||
startseeks[i], LFS_SEEK_SET) => startseeks[i];
|
||||
}
|
||||
|
||||
lfs_file_truncate(&lfs, &file, hotsizes[i]) => 0;
|
||||
lfs_file_size(&lfs, &file) => hotsizes[i];
|
||||
lfs_file_truncate(&lfs, &file[0], hotsizes[i]) => 0;
|
||||
lfs_file_size(&lfs, &file[0]) => hotsizes[i];
|
||||
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_file_close(&lfs, &file[0]) => 0;
|
||||
}
|
||||
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
static const lfs_off_t startsizes[] = {$STARTSIZES};
|
||||
static const lfs_off_t hotsizes[] = {$HOTSIZES};
|
||||
static const lfs_off_t coldsizes[] = {$COLDSIZES};
|
||||
@@ -254,31 +56,31 @@ scripts/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
|
||||
for (unsigned i = 0; i < sizeof(startsizes)/sizeof(startsizes[0]); i++) {
|
||||
sprintf(path, "hairyhead%d", i);
|
||||
lfs_file_open(&lfs, &file, path, LFS_O_RDWR) => 0;
|
||||
lfs_file_size(&lfs, &file) => hotsizes[i];
|
||||
sprintf((char*)buffer, "hairyhead%d", i);
|
||||
lfs_file_open(&lfs, &file[0], (const char*)buffer, LFS_O_RDWR) => 0;
|
||||
lfs_file_size(&lfs, &file[0]) => hotsizes[i];
|
||||
|
||||
lfs_size_t size = strlen("hair");
|
||||
size = strlen("hair");
|
||||
lfs_off_t j = 0;
|
||||
for (; j < startsizes[i] && j < hotsizes[i]; j += size) {
|
||||
lfs_file_read(&lfs, &file, buffer, size) => size;
|
||||
lfs_file_read(&lfs, &file[0], buffer, size) => size;
|
||||
memcmp(buffer, "hair", size) => 0;
|
||||
}
|
||||
|
||||
for (; j < hotsizes[i]; j += size) {
|
||||
lfs_file_read(&lfs, &file, buffer, size) => size;
|
||||
lfs_file_read(&lfs, &file[0], buffer, size) => size;
|
||||
memcmp(buffer, "\0\0\0\0", size) => 0;
|
||||
}
|
||||
|
||||
lfs_file_truncate(&lfs, &file, coldsizes[i]) => 0;
|
||||
lfs_file_size(&lfs, &file) => coldsizes[i];
|
||||
lfs_file_truncate(&lfs, &file[0], coldsizes[i]) => 0;
|
||||
lfs_file_size(&lfs, &file[0]) => coldsizes[i];
|
||||
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_file_close(&lfs, &file[0]) => 0;
|
||||
}
|
||||
|
||||
lfs_unmount(&lfs) => 0;
|
||||
TEST
|
||||
scripts/test.py << TEST
|
||||
tests/test.py << TEST
|
||||
static const lfs_off_t startsizes[] = {$STARTSIZES};
|
||||
static const lfs_off_t hotsizes[] = {$HOTSIZES};
|
||||
static const lfs_off_t coldsizes[] = {$COLDSIZES};
|
||||
@@ -286,24 +88,24 @@ scripts/test.py << TEST
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
|
||||
for (unsigned i = 0; i < sizeof(startsizes)/sizeof(startsizes[0]); i++) {
|
||||
sprintf(path, "hairyhead%d", i);
|
||||
lfs_file_open(&lfs, &file, path, LFS_O_RDONLY) => 0;
|
||||
lfs_file_size(&lfs, &file) => coldsizes[i];
|
||||
sprintf((char*)buffer, "hairyhead%d", i);
|
||||
lfs_file_open(&lfs, &file[0], (const char*)buffer, LFS_O_RDONLY) => 0;
|
||||
lfs_file_size(&lfs, &file[0]) => coldsizes[i];
|
||||
|
||||
lfs_size_t size = strlen("hair");
|
||||
size = strlen("hair");
|
||||
lfs_off_t j = 0;
|
||||
for (; j < startsizes[i] && j < hotsizes[i] && j < coldsizes[i];
|
||||
j += size) {
|
||||
lfs_file_read(&lfs, &file, buffer, size) => size;
|
||||
lfs_file_read(&lfs, &file[0], buffer, size) => size;
|
||||
memcmp(buffer, "hair", size) => 0;
|
||||
}
|
||||
|
||||
for (; j < coldsizes[i]; j += size) {
|
||||
lfs_file_read(&lfs, &file, buffer, size) => size;
|
||||
lfs_file_read(&lfs, &file[0], buffer, size) => size;
|
||||
memcmp(buffer, "\0\0\0\0", size) => 0;
|
||||
}
|
||||
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_file_close(&lfs, &file[0]) => 0;
|
||||
}
|
||||
|
||||
lfs_unmount(&lfs) => 0;
|
||||
@@ -352,4 +154,5 @@ truncate_test \
|
||||
"2*$LARGESIZE, 2*$LARGESIZE, 2*$LARGESIZE, 2*$LARGESIZE, 2*$LARGESIZE" \
|
||||
"2*$LARGESIZE, 2*$LARGESIZE, 2*$LARGESIZE, 2*$LARGESIZE, 2*$LARGESIZE"
|
||||
|
||||
scripts/results.py
|
||||
echo "--- Results ---"
|
||||
tests/stats.py
|
||||
|
||||
Reference in New Issue
Block a user