code stringlengths 1 2.01M | repo_name stringlengths 3 62 | path stringlengths 1 267 | language stringclasses 231
values | license stringclasses 13
values | size int64 1 2.01M |
|---|---|---|---|---|---|
/* -*- c -*- */
#include <syscall.h>
#include <stdio.h>
#include "tests/filesys/seq-test.h"
#include "tests/lib.h"
#include "tests/main.h"
static char buf[512];
static size_t
return_block_size (void)
{
return sizeof buf;
}
void
test_main (void)
{
size_t i;
#ifdef DIRECTORY
CHECK (mkdir (DIRECTORY), "mkdir %s", DIRECTORY);
#define DIR_PREFIX DIRECTORY "/"
#else
#define DIR_PREFIX ""
#endif
for (i = 0; i < FILE_CNT; i++)
{
char file_name[128];
snprintf (file_name, sizeof file_name, "%sfile%zu", DIR_PREFIX, i);
msg ("creating and checking \"%s\"", file_name);
quiet = true;
seq_test (file_name,
buf, sizeof buf, sizeof buf,
return_block_size, NULL);
quiet = false;
}
}
| 10cm | trunk/10cm/pintos/src/tests/filesys/extended/.svn/text-base/grow-dir.inc.svn-base | C | oos | 769 |
# -*- perl -*-
use strict;
use warnings;
use tests::tests;
use tests::random;
check_expected (IGNORE_EXIT_CODES => 1, [<<'EOF']);
(grow-two-files) begin
(grow-two-files) create "a"
(grow-two-files) create "b"
(grow-two-files) open "a"
(grow-two-files) open "b"
(grow-two-files) write "a" and "b" alternately
(grow-two-files) close "a"
(grow-two-files) close "b"
(grow-two-files) open "a" for verification
(grow-two-files) verified contents of "a"
(grow-two-files) close "a"
(grow-two-files) open "b" for verification
(grow-two-files) verified contents of "b"
(grow-two-files) close "b"
(grow-two-files) end
EOF
pass;
| 10cm | trunk/10cm/pintos/src/tests/filesys/extended/.svn/text-base/grow-two-files.ck.svn-base | Perl | oos | 617 |
# -*- perl -*-
use strict;
use warnings;
use tests::tests;
check_archive ({"xyzzy" => {}});
pass;
| 10cm | trunk/10cm/pintos/src/tests/filesys/extended/.svn/text-base/dir-open-persistence.ck.svn-base | Perl | oos | 98 |
# -*- perl -*-
use strict;
use warnings;
use tests::tests;
check_expected (IGNORE_EXIT_CODES => 1, [<<'EOF']);
(dir-mkdir) begin
(dir-mkdir) mkdir "a"
(dir-mkdir) create "a/b"
(dir-mkdir) chdir "a"
(dir-mkdir) open "b"
(dir-mkdir) end
EOF
pass;
| 10cm | trunk/10cm/pintos/src/tests/filesys/extended/.svn/text-base/dir-mkdir.ck.svn-base | Perl | oos | 245 |
# -*- perl -*-
use strict;
use warnings;
use tests::tests;
use tests::random;
my ($fs);
$fs->{"file$_"} = [random_bytes (512)] foreach 0...49;
check_archive ($fs);
pass;
| 10cm | trunk/10cm/pintos/src/tests/filesys/extended/.svn/text-base/grow-root-lg-persistence.ck.svn-base | Perl | oos | 170 |
# -*- perl -*-
use strict;
use warnings;
use tests::tests;
check_archive ({"blargle" => ['']});
pass;
| 10cm | trunk/10cm/pintos/src/tests/filesys/extended/.svn/text-base/grow-create-persistence.ck.svn-base | Perl | oos | 102 |
# -*- perl -*-
use strict;
use warnings;
use tests::tests;
my ($cwd_removable) = check_expected (IGNORE_EXIT_CODES => 1,
{NO => <<'EOF', YES => <<'EOF'});
(dir-rm-cwd) begin
(dir-rm-cwd) open "/"
(dir-rm-cwd) mkdir "a"
(dir-rm-cwd) open "/a"
(dir-rm-cwd) verify "/a" is empty
(dir-rm-cwd) "/" and "/a" must have different inumbers
(dir-rm-cwd) chdir "a"
(dir-rm-cwd) try to remove "/a"
(dir-rm-cwd) remove failed
(dir-rm-cwd) try to remove "../a" (must fail)
(dir-rm-cwd) try to remove ".././a" (must fail)
(dir-rm-cwd) try to remove "/./a" (must fail)
(dir-rm-cwd) open "/a"
(dir-rm-cwd) open "."
(dir-rm-cwd) "/a" and "." must have same inumber
(dir-rm-cwd) "/" and "/a" must have different inumbers
(dir-rm-cwd) chdir "/a"
(dir-rm-cwd) open "."
(dir-rm-cwd) "." must have same inumber as before
(dir-rm-cwd) chdir "/"
(dir-rm-cwd) try to remove "a" (must fail: still open)
(dir-rm-cwd) verify "/a" is empty
(dir-rm-cwd) end
EOF
(dir-rm-cwd) begin
(dir-rm-cwd) open "/"
(dir-rm-cwd) mkdir "a"
(dir-rm-cwd) open "/a"
(dir-rm-cwd) verify "/a" is empty
(dir-rm-cwd) "/" and "/a" must have different inumbers
(dir-rm-cwd) chdir "a"
(dir-rm-cwd) try to remove "/a"
(dir-rm-cwd) remove successful
(dir-rm-cwd) open "/a" (must fail)
(dir-rm-cwd) open "." (must fail)
(dir-rm-cwd) open ".." (must fail)
(dir-rm-cwd) create "x" (must fail)
(dir-rm-cwd) verify "/a" is empty
(dir-rm-cwd) end
EOF
open (CAN_RMDIR_CWD, ">tests/filesys/extended/can-rmdir-cwd")
or die "tests/filesys/extended/can-rmdir-cwd: create: $!\n";
print CAN_RMDIR_CWD "$cwd_removable";
close (CAN_RMDIR_CWD);
pass;
| 10cm | trunk/10cm/pintos/src/tests/filesys/extended/.svn/text-base/dir-rm-cwd.ck.svn-base | Perl | oos | 1,590 |
# -*- perl -*-
use strict;
use warnings;
use tests::tests;
check_expected ([<<'EOF', <<'EOF']);
(dir-open) begin
(dir-open) mkdir "xyzzy"
(dir-open) open "xyzzy"
(dir-open) write "xyzzy"
(dir-open) write "xyzzy" (must return -1, actually -1)
(dir-open) end
dir-open: exit(0)
EOF
(dir-open) begin
(dir-open) mkdir "xyzzy"
(dir-open) open "xyzzy"
(dir-open) write "xyzzy"
dir-open: exit(-1)
EOF
pass;
| 10cm | trunk/10cm/pintos/src/tests/filesys/extended/.svn/text-base/dir-open.ck.svn-base | Perl | oos | 399 |
# -*- perl -*-
use strict;
use warnings;
use tests::tests;
check_expected (IGNORE_EXIT_CODES => 1, [<<'EOF']);
(dir-mk-tree) begin
(dir-mk-tree) creating /0/0/0/0 through /3/2/2/3...
(dir-mk-tree) open "/0/2/0/3"
(dir-mk-tree) close "/0/2/0/3"
(dir-mk-tree) end
EOF
pass;
| 10cm | trunk/10cm/pintos/src/tests/filesys/extended/.svn/text-base/dir-mk-tree.ck.svn-base | Perl | oos | 272 |
# -*- perl -*-
use strict;
use warnings;
use tests::tests;
use tests::random;
check_archive ({"testme" => [random_bytes (72943)]});
pass;
| 10cm | trunk/10cm/pintos/src/tests/filesys/extended/.svn/text-base/grow-seq-lg-persistence.ck.svn-base | Perl | oos | 138 |
# -*- perl -*-
use strict;
use warnings;
use tests::tests;
check_expected (IGNORE_EXIT_CODES => 1, [<<'EOF']);
(dir-under-file) begin
(dir-under-file) create "abc"
(dir-under-file) mkdir "abc" (must return false)
(dir-under-file) end
EOF
pass;
| 10cm | trunk/10cm/pintos/src/tests/filesys/extended/.svn/text-base/dir-under-file.ck.svn-base | Perl | oos | 244 |
# -*- perl -*-
use strict;
use warnings;
use tests::tests;
check_expected (IGNORE_EXIT_CODES => 1, [<<'EOF']);
(dir-rm-root) begin
(dir-rm-root) remove "/" (must fail)
(dir-rm-root) create "/a"
(dir-rm-root) end
EOF
pass;
| 10cm | trunk/10cm/pintos/src/tests/filesys/extended/.svn/text-base/dir-rm-root.ck.svn-base | Perl | oos | 222 |
# -*- perl -*-
use strict;
use warnings;
use tests::tests;
use tests::random;
check_expected (IGNORE_EXIT_CODES => 1, [<<'EOF']);
(grow-root-sm) begin
(grow-root-sm) creating and checking "file0"
(grow-root-sm) creating and checking "file1"
(grow-root-sm) creating and checking "file2"
(grow-root-sm) creating and checking "file3"
(grow-root-sm) creating and checking "file4"
(grow-root-sm) creating and checking "file5"
(grow-root-sm) creating and checking "file6"
(grow-root-sm) creating and checking "file7"
(grow-root-sm) creating and checking "file8"
(grow-root-sm) creating and checking "file9"
(grow-root-sm) creating and checking "file10"
(grow-root-sm) creating and checking "file11"
(grow-root-sm) creating and checking "file12"
(grow-root-sm) creating and checking "file13"
(grow-root-sm) creating and checking "file14"
(grow-root-sm) creating and checking "file15"
(grow-root-sm) creating and checking "file16"
(grow-root-sm) creating and checking "file17"
(grow-root-sm) creating and checking "file18"
(grow-root-sm) creating and checking "file19"
(grow-root-sm) end
EOF
pass;
| 10cm | trunk/10cm/pintos/src/tests/filesys/extended/.svn/text-base/grow-root-sm.ck.svn-base | Perl | oos | 1,090 |
# -*- perl -*-
use strict;
use warnings;
use tests::tests;
check_archive ({"abc" => {}});
pass;
| 10cm | trunk/10cm/pintos/src/tests/filesys/extended/.svn/text-base/dir-over-file-persistence.ck.svn-base | Perl | oos | 96 |
# -*- perl -*-
use strict;
use warnings;
use tests::tests;
check_archive ({"a" => ["\0" x 243]});
pass;
| 10cm | trunk/10cm/pintos/src/tests/filesys/extended/.svn/text-base/dir-rm-root-persistence.ck.svn-base | Perl | oos | 104 |
# -*- perl -*-
use strict;
use warnings;
use tests::tests;
check_expected (IGNORE_EXIT_CODES => 1, [<<'EOF']);
(dir-rm-tree) begin
(dir-rm-tree) creating /0/0/0/0 through /3/2/2/3...
(dir-rm-tree) open "/0/2/0/3"
(dir-rm-tree) close "/0/2/0/3"
(dir-rm-tree) removing /0/0/0/0 through /3/2/2/3...
(dir-rm-tree) open "/3/0/2/0" (must return -1)
(dir-rm-tree) end
EOF
pass;
| 10cm | trunk/10cm/pintos/src/tests/filesys/extended/.svn/text-base/dir-rm-tree.ck.svn-base | Perl | oos | 371 |
# -*- perl -*-
use strict;
use warnings;
use tests::tests;
use tests::random;
check_archive ({"child-syn-rw" => "tests/filesys/extended/child-syn-rw",
"logfile" => [random_bytes (8 * 512)]});
pass;
| 10cm | trunk/10cm/pintos/src/tests/filesys/extended/.svn/text-base/syn-rw-persistence.ck.svn-base | Perl | oos | 200 |
# -*- perl -*-
use strict;
use warnings;
use tests::tests;
check_expected (IGNORE_EXIT_CODES => 1, [<<'EOF']);
(grow-sparse) begin
(grow-sparse) create "testfile"
(grow-sparse) open "testfile"
(grow-sparse) seek "testfile"
(grow-sparse) write "testfile"
(grow-sparse) close "testfile"
(grow-sparse) open "testfile" for verification
(grow-sparse) verified contents of "testfile"
(grow-sparse) close "testfile"
(grow-sparse) end
EOF
pass;
| 10cm | trunk/10cm/pintos/src/tests/filesys/extended/.svn/text-base/grow-sparse.ck.svn-base | Perl | oos | 437 |
/* -*- c -*- */
#include "tests/filesys/seq-test.h"
#include "tests/main.h"
static char buf[TEST_SIZE];
static size_t
return_block_size (void)
{
return 1234;
}
void
test_main (void)
{
seq_test ("testme",
buf, sizeof buf, 0,
return_block_size, NULL);
}
| 10cm | trunk/10cm/pintos/src/tests/filesys/extended/.svn/text-base/grow-seq.inc.svn-base | C | oos | 286 |
# -*- perl -*-
use strict;
use warnings;
use tests::tests;
use tests::random;
check_expected (IGNORE_EXIT_CODES => 1, [<<'EOF']);
(grow-tell) begin
(grow-tell) create "foobar"
(grow-tell) open "foobar"
(grow-tell) writing "foobar"
(grow-tell) close "foobar"
(grow-tell) open "foobar" for verification
(grow-tell) verified contents of "foobar"
(grow-tell) close "foobar"
(grow-tell) end
EOF
pass;
| 10cm | trunk/10cm/pintos/src/tests/filesys/extended/.svn/text-base/grow-tell.ck.svn-base | Perl | oos | 396 |
# -*- perl -*-
use strict;
use warnings;
use tests::tests;
use tests::random;
check_expected (IGNORE_EXIT_CODES => 1, [<<'EOF']);
(syn-rw) begin
(syn-rw) create "logfile"
(syn-rw) open "logfile"
(syn-rw) exec child 1 of 4: "child-syn-rw 0"
(syn-rw) exec child 2 of 4: "child-syn-rw 1"
(syn-rw) exec child 3 of 4: "child-syn-rw 2"
(syn-rw) exec child 4 of 4: "child-syn-rw 3"
(syn-rw) wait for child 1 of 4 returned 0 (expected 0)
(syn-rw) wait for child 2 of 4 returned 1 (expected 1)
(syn-rw) wait for child 3 of 4 returned 2 (expected 2)
(syn-rw) wait for child 4 of 4 returned 3 (expected 3)
(syn-rw) end
EOF
pass;
| 10cm | trunk/10cm/pintos/src/tests/filesys/extended/.svn/text-base/syn-rw.ck.svn-base | Perl | oos | 618 |
# -*- perl -*-
use strict;
use warnings;
use tests::tests;
check_archive ({});
pass;
| 10cm | trunk/10cm/pintos/src/tests/filesys/extended/dir-empty-name-persistence.ck | Perl | oos | 85 |
/* Child process for syn-rw.
Reads from a file created by our parent process, which is
growing it. We loop until we've read the whole file
successfully. Many iterations through the loop will return 0
bytes, because the file has not grown in the meantime. That
is, we are "busy waiting" for the file to grow.
(This test could be improved by adding a "yield" system call
and calling yield whenever we receive a 0-byte read.) */
#include <random.h>
#include <stdlib.h>
#include <syscall.h>
#include "tests/filesys/extended/syn-rw.h"
#include "tests/lib.h"
const char *test_name = "child-syn-rw";
static char buf1[BUF_SIZE];
static char buf2[BUF_SIZE];
int
main (int argc, const char *argv[])
{
int child_idx;
int fd;
size_t ofs;
quiet = true;
CHECK (argc == 2, "argc must be 2, actually %d", argc);
child_idx = atoi (argv[1]);
random_init (0);
random_bytes (buf1, sizeof buf1);
CHECK ((fd = open (file_name)) > 1, "open \"%s\"", file_name);
ofs = 0;
while (ofs < sizeof buf2)
{
int bytes_read = read (fd, buf2 + ofs, sizeof buf2 - ofs);
CHECK (bytes_read >= -1 && bytes_read <= (int) (sizeof buf2 - ofs),
"%zu-byte read on \"%s\" returned invalid value of %d",
sizeof buf2 - ofs, file_name, bytes_read);
if (bytes_read > 0)
{
compare_bytes (buf2 + ofs, buf1 + ofs, bytes_read, ofs, file_name);
ofs += bytes_read;
}
}
close (fd);
return child_idx;
}
| 10cm | trunk/10cm/pintos/src/tests/filesys/extended/child-syn-rw.c | C | oos | 1,497 |
/* Library function for creating a tree of directories. */
#include <stdio.h>
#include <syscall.h>
#include "tests/filesys/extended/mk-tree.h"
#include "tests/lib.h"
static void do_mkdir (const char *format, ...) PRINTF_FORMAT (1, 2);
static void do_touch (const char *format, ...) PRINTF_FORMAT (1, 2);
void
make_tree (int at, int bt, int ct, int dt)
{
char try[128];
int a, b, c, d;
int fd;
msg ("creating /0/0/0/0 through /%d/%d/%d/%d...",
at - 1, bt - 1, ct - 1, dt - 1);
quiet = true;
for (a = 0; a < at; a++)
{
do_mkdir ("/%d", a);
for (b = 0; b < bt; b++)
{
do_mkdir ("/%d/%d", a, b);
for (c = 0; c < ct; c++)
{
do_mkdir ("/%d/%d/%d", a, b, c);
for (d = 0; d < dt; d++)
do_touch ("/%d/%d/%d/%d", a, b, c, d);
}
}
}
quiet = false;
snprintf (try, sizeof try, "/%d/%d/%d/%d", 0, bt - 1, 0, dt - 1);
CHECK ((fd = open (try)) > 1, "open \"%s\"", try);
msg ("close \"%s\"", try);
close (fd);
}
static void
do_mkdir (const char *format, ...)
{
char dir[128];
va_list args;
va_start (args, format);
vsnprintf (dir, sizeof dir, format, args);
va_end (args);
CHECK (mkdir (dir), "mkdir \"%s\"", dir);
}
static void
do_touch (const char *format, ...)
{
char file[128];
va_list args;
va_start (args, format);
vsnprintf (file, sizeof file, format, args);
va_end (args);
CHECK (create (file, 0), "create \"%s\"", file);
}
| 10cm | trunk/10cm/pintos/src/tests/filesys/extended/mk-tree.c | C | oos | 1,508 |
# -*- perl -*-
use strict;
use warnings;
use tests::tests;
use tests::random;
check_archive ({"child-syn-rw" => "tests/filesys/extended/child-syn-rw",
"logfile" => [random_bytes (8 * 512)]});
pass;
| 10cm | trunk/10cm/pintos/src/tests/filesys/extended/syn-rw-persistence.ck | Perl | oos | 200 |
# -*- makefile -*-
raw_tests = dir-empty-name dir-mk-tree dir-mkdir dir-open \
dir-over-file dir-rm-cwd dir-rm-parent dir-rm-root dir-rm-tree \
dir-rmdir dir-under-file dir-vine grow-create grow-dir-lg \
grow-file-size grow-root-lg grow-root-sm grow-seq-lg grow-seq-sm \
grow-sparse grow-tell grow-two-files syn-rw
tests/filesys/extended_TESTS = $(patsubst %,tests/filesys/extended/%,$(raw_tests))
tests/filesys/extended_EXTRA_GRADES = $(patsubst %,tests/filesys/extended/%-persistence,$(raw_tests))
tests/filesys/extended_PROGS = $(tests/filesys/extended_TESTS) \
tests/filesys/extended/child-syn-rw tests/filesys/extended/tar
$(foreach prog,$(tests/filesys/extended_PROGS), \
$(eval $(prog)_SRC += $(prog).c tests/lib.c tests/filesys/seq-test.c))
$(foreach prog,$(tests/filesys/extended_TESTS), \
$(eval $(prog)_SRC += tests/main.c))
$(foreach prog,$(tests/filesys/extended_TESTS), \
$(eval $(prog)_PUTFILES += tests/filesys/extended/tar))
# The version of GNU make 3.80 on vine barfs if this is split at
# the last comma.
$(foreach test,$(tests/filesys/extended_TESTS),$(eval $(test).output: FSDISK = tmp.dsk))
tests/filesys/extended/dir-mk-tree_SRC += tests/filesys/extended/mk-tree.c
tests/filesys/extended/dir-rm-tree_SRC += tests/filesys/extended/mk-tree.c
tests/filesys/extended/syn-rw_PUTFILES += tests/filesys/extended/child-syn-rw
tests/filesys/extended/dir-vine.output: TIMEOUT = 150
GETTIMEOUT = 60
GETCMD = pintos -v -k -T $(GETTIMEOUT)
GETCMD += $(PINTOSOPTS)
GETCMD += $(SIMULATOR)
GETCMD += --fs-disk=$(FSDISK)
GETCMD += -g fs.tar -a $(TEST).tar
ifeq ($(filter vm, $(KERNEL_SUBDIRS)), vm)
GETCMD += --swap-disk=4
endif
GETCMD += -- -q
GETCMD += $(KERNELFLAGS)
GETCMD += run 'tar fs.tar /'
GETCMD += < /dev/null
GETCMD += 2> $(TEST)-persistence.errors $(if $(VERBOSE),|tee,>) $(TEST)-persistence.output
tests/filesys/extended/%.output: os.dsk
rm -f tmp.dsk
pintos-mkdisk tmp.dsk 2
$(TESTCMD)
$(GETCMD)
rm -f tmp.dsk
$(foreach raw_test,$(raw_tests),$(eval tests/filesys/extended/$(raw_test)-persistence.output: tests/filesys/extended/$(raw_test).output))
$(foreach raw_test,$(raw_tests),$(eval tests/filesys/extended/$(raw_test)-persistence.result: tests/filesys/extended/$(raw_test).result))
TARS = $(addsuffix .tar,$(tests/filesys/extended_TESTS))
clean::
rm -f $(TARS)
rm -f tests/filesys/extended/can-rmdir-cwd
| 10cm | trunk/10cm/pintos/src/tests/filesys/extended/Make.tests | Makefile | oos | 2,359 |
# -*- perl -*-
use strict;
use warnings;
use tests::tests;
check_expected (IGNORE_EXIT_CODES => 1, [<<'EOF']);
(dir-rmdir) begin
(dir-rmdir) mkdir "a"
(dir-rmdir) rmdir "a"
(dir-rmdir) chdir "a" (must return false)
(dir-rmdir) end
EOF
pass;
| 10cm | trunk/10cm/pintos/src/tests/filesys/extended/dir-rmdir.ck | Perl | oos | 241 |
/* -*- c -*- */
#include "tests/filesys/seq-test.h"
#include "tests/main.h"
static char buf[TEST_SIZE];
static size_t
return_block_size (void)
{
return 1234;
}
void
test_main (void)
{
seq_test ("testme",
buf, sizeof buf, 0,
return_block_size, NULL);
}
| 10cm | trunk/10cm/pintos/src/tests/filesys/extended/grow-seq.inc | C | oos | 286 |
# -*- perl -*-
use strict;
use warnings;
use tests::tests;
use tests::random;
check_expected (IGNORE_EXIT_CODES => 1, [<<'EOF']);
(syn-rw) begin
(syn-rw) create "logfile"
(syn-rw) open "logfile"
(syn-rw) exec child 1 of 4: "child-syn-rw 0"
(syn-rw) exec child 2 of 4: "child-syn-rw 1"
(syn-rw) exec child 3 of 4: "child-syn-rw 2"
(syn-rw) exec child 4 of 4: "child-syn-rw 3"
(syn-rw) wait for child 1 of 4 returned 0 (expected 0)
(syn-rw) wait for child 2 of 4 returned 1 (expected 1)
(syn-rw) wait for child 3 of 4 returned 2 (expected 2)
(syn-rw) wait for child 4 of 4 returned 3 (expected 3)
(syn-rw) end
EOF
pass;
| 10cm | trunk/10cm/pintos/src/tests/filesys/extended/syn-rw.ck | Perl | oos | 618 |
/* Checks that growing a file updates the file position
correctly. */
#include <syscall.h>
#include "tests/filesys/seq-test.h"
#include "tests/lib.h"
#include "tests/main.h"
static char buf[2134];
static size_t
return_block_size (void)
{
return 37;
}
static void
check_tell (int fd, long ofs)
{
long pos = tell (fd);
if (pos != ofs)
fail ("file position not updated properly: should be %ld, actually %ld",
ofs, pos);
}
void
test_main (void)
{
seq_test ("foobar",
buf, sizeof buf, 0,
return_block_size, check_tell);
}
| 10cm | trunk/10cm/pintos/src/tests/filesys/extended/grow-tell.c | C | oos | 574 |
/* Tries to create a file with the same name as an existing
directory, which must return failure. */
#include <syscall.h>
#include "tests/lib.h"
#include "tests/main.h"
void
test_main (void)
{
CHECK (mkdir ("abc"), "mkdir \"abc\"");
CHECK (!create ("abc", 0), "create \"abc\" (must return false)");
}
| 10cm | trunk/10cm/pintos/src/tests/filesys/extended/dir-over-file.c | C | oos | 311 |
/* -*- c -*- */
#include <syscall.h>
#include <stdio.h>
#include "tests/filesys/seq-test.h"
#include "tests/lib.h"
#include "tests/main.h"
static char buf[512];
static size_t
return_block_size (void)
{
return sizeof buf;
}
void
test_main (void)
{
size_t i;
#ifdef DIRECTORY
CHECK (mkdir (DIRECTORY), "mkdir %s", DIRECTORY);
#define DIR_PREFIX DIRECTORY "/"
#else
#define DIR_PREFIX ""
#endif
for (i = 0; i < FILE_CNT; i++)
{
char file_name[128];
snprintf (file_name, sizeof file_name, "%sfile%zu", DIR_PREFIX, i);
msg ("creating and checking \"%s\"", file_name);
quiet = true;
seq_test (file_name,
buf, sizeof buf, sizeof buf,
return_block_size, NULL);
quiet = false;
}
}
| 10cm | trunk/10cm/pintos/src/tests/filesys/extended/grow-dir.inc | C | oos | 769 |
# -*- perl -*-
use strict;
use warnings;
use tests::tests;
use tests::random;
my ($fs);
$fs->{"file$_"} = [random_bytes (512)] foreach 0...49;
check_archive ($fs);
pass;
| 10cm | trunk/10cm/pintos/src/tests/filesys/extended/grow-root-lg-persistence.ck | Perl | oos | 170 |
/* Try to remove the root directory.
This must fail. */
#include <syscall.h>
#include "tests/lib.h"
#include "tests/main.h"
void
test_main (void)
{
CHECK (!remove ("/"), "remove \"/\" (must fail)");
CHECK (create ("/a", 243), "create \"/a\"");
}
| 10cm | trunk/10cm/pintos/src/tests/filesys/extended/dir-rm-root.c | C | oos | 256 |
# -*- perl -*-
use strict;
use warnings;
use tests::tests;
use tests::random;
check_archive ({"testme" => [random_bytes (5678)]});
pass;
| 10cm | trunk/10cm/pintos/src/tests/filesys/extended/grow-seq-sm-persistence.ck | Perl | oos | 137 |
# -*- perl -*-
use strict;
use warnings;
use tests::tests;
check_archive ({"a" => {"b" => {}}});
pass;
| 10cm | trunk/10cm/pintos/src/tests/filesys/extended/dir-rm-parent-persistence.ck | Perl | oos | 103 |
/* Creates and removes a directory, then makes sure that it's
really gone. */
#include <syscall.h>
#include "tests/lib.h"
#include "tests/main.h"
void
test_main (void)
{
CHECK (mkdir ("a"), "mkdir \"a\"");
CHECK (remove ("a"), "rmdir \"a\"");
CHECK (!chdir ("a"), "chdir \"a\" (must return false)");
}
| 10cm | trunk/10cm/pintos/src/tests/filesys/extended/dir-rmdir.c | C | oos | 314 |
# -*- perl -*-
use strict;
use warnings;
use tests::tests;
check_expected (IGNORE_EXIT_CODES => 1, [<<'EOF']);
(dir-rm-root) begin
(dir-rm-root) remove "/" (must fail)
(dir-rm-root) create "/a"
(dir-rm-root) end
EOF
pass;
| 10cm | trunk/10cm/pintos/src/tests/filesys/extended/dir-rm-root.ck | Perl | oos | 222 |
/* Grows a file from 0 bytes to 5,678 bytes, 1,234 bytes at a
time. */
#define TEST_SIZE 5678
#include "tests/filesys/extended/grow-seq.inc"
| 10cm | trunk/10cm/pintos/src/tests/filesys/extended/grow-seq-sm.c | C | oos | 145 |
# -*- perl -*-
use strict;
use warnings;
use tests::tests;
check_expected ([<<'EOF', <<'EOF']);
(dir-open) begin
(dir-open) mkdir "xyzzy"
(dir-open) open "xyzzy"
(dir-open) write "xyzzy"
(dir-open) write "xyzzy" (must return -1, actually -1)
(dir-open) end
dir-open: exit(0)
EOF
(dir-open) begin
(dir-open) mkdir "xyzzy"
(dir-open) open "xyzzy"
(dir-open) write "xyzzy"
dir-open: exit(-1)
EOF
pass;
| 10cm | trunk/10cm/pintos/src/tests/filesys/extended/dir-open.ck | Perl | oos | 399 |
# -*- perl -*-
use strict;
use warnings;
use tests::tests;
use tests::random;
check_expected (IGNORE_EXIT_CODES => 1, [<<'EOF']);
(grow-file-size) begin
(grow-file-size) create "testfile"
(grow-file-size) open "testfile"
(grow-file-size) writing "testfile"
(grow-file-size) close "testfile"
(grow-file-size) open "testfile" for verification
(grow-file-size) verified contents of "testfile"
(grow-file-size) close "testfile"
(grow-file-size) end
EOF
pass;
| 10cm | trunk/10cm/pintos/src/tests/filesys/extended/grow-file-size.ck | Perl | oos | 455 |
/* Opens a directory, then tries to write to it, which must
fail. */
#include <syscall.h>
#include "tests/lib.h"
#include "tests/main.h"
void
test_main (void)
{
int fd;
int retval;
CHECK (mkdir ("xyzzy"), "mkdir \"xyzzy\"");
CHECK ((fd = open ("xyzzy")) > 1, "open \"xyzzy\"");
msg ("write \"xyzzy\"");
retval = write (fd, "foobar", 6);
CHECK (retval == -1,
"write \"xyzzy\" (must return -1, actually %d)", retval);
}
| 10cm | trunk/10cm/pintos/src/tests/filesys/extended/dir-open.c | C | oos | 451 |
/* Grows a file from 0 bytes to 2,134 bytes, 37 bytes at a time,
and checks that the file's size is reported correctly at each
step. */
#include <syscall.h>
#include "tests/filesys/seq-test.h"
#include "tests/lib.h"
#include "tests/main.h"
static char buf[2134];
static size_t
return_block_size (void)
{
return 37;
}
static void
check_file_size (int fd, long ofs)
{
long size = filesize (fd);
if (size != ofs)
fail ("filesize not updated properly: should be %ld, actually %ld",
ofs, size);
}
void
test_main (void)
{
seq_test ("testfile",
buf, sizeof buf, 0,
return_block_size, check_file_size);
}
| 10cm | trunk/10cm/pintos/src/tests/filesys/extended/grow-file-size.c | C | oos | 657 |
# -*- perl -*-
use strict;
use warnings;
use tests::tests;
use tests::random;
my ($fs);
$fs->{"file$_"} = [random_bytes (512)] foreach 0...19;
check_archive ($fs);
pass;
| 10cm | trunk/10cm/pintos/src/tests/filesys/extended/grow-root-sm-persistence.ck | Perl | oos | 170 |
/* Tests mkdir(). */
#include <syscall.h>
#include "tests/lib.h"
#include "tests/main.h"
void
test_main (void)
{
CHECK (mkdir ("a"), "mkdir \"a\"");
CHECK (create ("a/b", 512), "create \"a/b\"");
CHECK (chdir ("a"), "chdir \"a\"");
CHECK (open ("b") > 1, "open \"b\"");
}
| 10cm | trunk/10cm/pintos/src/tests/filesys/extended/dir-mkdir.c | C | oos | 284 |
# -*- perl -*-
use strict;
use warnings;
use tests::tests;
use tests::random;
check_expected (IGNORE_EXIT_CODES => 1, [<<'EOF']);
(grow-tell) begin
(grow-tell) create "foobar"
(grow-tell) open "foobar"
(grow-tell) writing "foobar"
(grow-tell) close "foobar"
(grow-tell) open "foobar" for verification
(grow-tell) verified contents of "foobar"
(grow-tell) close "foobar"
(grow-tell) end
EOF
pass;
| 10cm | trunk/10cm/pintos/src/tests/filesys/extended/grow-tell.ck | Perl | oos | 396 |
# -*- perl -*-
use strict;
use warnings;
use tests::tests;
check_archive ({'a' => {'b' => ["\0" x 512]}});
pass;
| 10cm | trunk/10cm/pintos/src/tests/filesys/extended/dir-mkdir-persistence.ck | Perl | oos | 113 |
/* -*- c -*- */
#include <syscall.h>
#include "tests/lib.h"
#include "tests/main.h"
static char buf[TEST_SIZE];
void
test_main (void)
{
const char *file_name = "blargle";
CHECK (create (file_name, TEST_SIZE), "create \"%s\"", file_name);
check_file (file_name, buf, TEST_SIZE);
}
| 10cm | trunk/10cm/pintos/src/tests/filesys/.svn/text-base/create.inc.svn-base | C | oos | 290 |
/* Child process for syn-read test.
Reads the contents of a test file a byte at a time, in the
hope that this will take long enough that we can get a
significant amount of contention in the kernel file system
code. */
#include <random.h>
#include <stdio.h>
#include <stdlib.h>
#include <syscall.h>
#include "tests/lib.h"
#include "tests/filesys/base/syn-read.h"
const char *test_name = "child-syn-read";
static char buf[BUF_SIZE];
int
main (int argc, const char *argv[])
{
int child_idx;
int fd;
size_t i;
quiet = true;
CHECK (argc == 2, "argc must be 2, actually %d", argc);
child_idx = atoi (argv[1]);
random_init (0);
random_bytes (buf, sizeof buf);
CHECK ((fd = open (file_name)) > 1, "open \"%s\"", file_name);
for (i = 0; i < sizeof buf; i++)
{
char c;
CHECK (read (fd, &c, 1) > 0, "read \"%s\"", file_name);
compare_bytes (&c, buf + i, 1, i, file_name);
}
close (fd);
return child_idx;
}
| 10cm | trunk/10cm/pintos/src/tests/filesys/base/child-syn-read.c | C | oos | 971 |
/* Tests that create properly zeros out the contents of a fairly
small file. */
#define TEST_SIZE 5678
#include "tests/filesys/create.inc"
| 10cm | trunk/10cm/pintos/src/tests/filesys/base/sm-create.c | C | oos | 143 |
/* Spawns several child processes to write out different parts of
the contents of a file and waits for them to finish. Then
reads back the file and verifies its contents. */
#include <random.h>
#include <stdio.h>
#include <string.h>
#include <syscall.h>
#include "tests/filesys/seq-test.h"
#include "tests/lib.h"
#include "tests/main.h"
static char buf[32*1024];
void
prj5_seq_test (const char *file_name, void *buf, size_t size, size_t initial_size,
size_t (*block_size_func) (void));
static size_t
return_block_size (void)
{
return 16;
}
void
prj5_seq_test (const char *file_name, void *buf, size_t size, size_t initial_size,
size_t (*block_size_func) (void))
{
size_t ofs;
int fd;
remove(file_name);
random_bytes (buf, size);
CHECK (create (file_name, initial_size), "create \"%s\"", file_name);
CHECK ((fd = open (file_name)) > 1, "open \"%s\"", file_name);
ofs = 0;
int start_time = timer();
msg ("writing \"%s\"", file_name);
while (ofs < size)
{
size_t block_size = block_size_func ();
if (block_size > size - ofs)
block_size = size - ofs;
if (write (fd, buf + ofs, block_size) != (int) block_size)
fail ("write %zu bytes at offset %zu in \"%s\" failed",
block_size, ofs, file_name);
ofs += block_size;
}
msg("write end. time consumed in writing is %d.", timer() - start_time);
msg ("close \"%s\"", file_name);
close (fd);
check_file (file_name, buf, size);
}
void
test_main (void)
{
prj5_seq_test ("testfile",
buf, sizeof buf, sizeof buf,
return_block_size);
}
| 10cm | trunk/10cm/pintos/src/tests/filesys/base/2011_prj5_test.c | C | oos | 1,625 |
/* Spawns several child processes to write out different parts of
the contents of a file and waits for them to finish. Then
reads back the file and verifies its contents. */
#include <random.h>
#include <stdio.h>
#include <string.h>
#include <syscall.h>
#include "tests/filesys/base/syn-write.h"
#include "tests/lib.h"
#include "tests/main.h"
char buf1[BUF_SIZE];
char buf2[BUF_SIZE];
void
test_main (void)
{
pid_t children[CHILD_CNT];
int fd;
CHECK (create (file_name, sizeof buf1), "create \"%s\"", file_name);
exec_children ("child-syn-wrt", children, CHILD_CNT);
wait_children (children, CHILD_CNT);
CHECK ((fd = open (file_name)) > 1, "open \"%s\"", file_name);
CHECK (read (fd, buf1, sizeof buf1) > 0, "read \"%s\"", file_name);
random_bytes (buf2, sizeof buf2);
compare_bytes (buf1, buf2, sizeof buf1, 0, file_name);
}
| 10cm | trunk/10cm/pintos/src/tests/filesys/base/syn-write.c | C | oos | 858 |
# -*- perl -*-
use strict;
use warnings;
use tests::tests;
check_expected (IGNORE_EXIT_CODES => 1, [<<'EOF']);
(sm-full) begin
(sm-full) create "quux"
(sm-full) open "quux"
(sm-full) writing "quux"
(sm-full) close "quux"
(sm-full) open "quux" for verification
(sm-full) verified contents of "quux"
(sm-full) close "quux"
(sm-full) end
EOF
pass;
| 10cm | trunk/10cm/pintos/src/tests/filesys/base/sm-full.ck | Perl | oos | 345 |
# -*- perl -*-
use strict;
use warnings;
use tests::tests;
check_expected (IGNORE_EXIT_CODES => 1, [<<'EOF']);
(lg-full) begin
(lg-full) create "quux"
(lg-full) open "quux"
(lg-full) writing "quux"
(lg-full) close "quux"
(lg-full) open "quux" for verification
(lg-full) verified contents of "quux"
(lg-full) close "quux"
(lg-full) end
EOF
pass;
| 10cm | trunk/10cm/pintos/src/tests/filesys/base/lg-full.ck | Perl | oos | 345 |
# -*- perl -*-
use strict;
use warnings;
use tests::tests;
check_expected (IGNORE_EXIT_CODES => 1, [<<'EOF']);
(syn-read) begin
(syn-read) create "data"
(syn-read) open "data"
(syn-read) write "data"
(syn-read) close "data"
(syn-read) exec child 1 of 10: "child-syn-read 0"
(syn-read) exec child 2 of 10: "child-syn-read 1"
(syn-read) exec child 3 of 10: "child-syn-read 2"
(syn-read) exec child 4 of 10: "child-syn-read 3"
(syn-read) exec child 5 of 10: "child-syn-read 4"
(syn-read) exec child 6 of 10: "child-syn-read 5"
(syn-read) exec child 7 of 10: "child-syn-read 6"
(syn-read) exec child 8 of 10: "child-syn-read 7"
(syn-read) exec child 9 of 10: "child-syn-read 8"
(syn-read) exec child 10 of 10: "child-syn-read 9"
(syn-read) wait for child 1 of 10 returned 0 (expected 0)
(syn-read) wait for child 2 of 10 returned 1 (expected 1)
(syn-read) wait for child 3 of 10 returned 2 (expected 2)
(syn-read) wait for child 4 of 10 returned 3 (expected 3)
(syn-read) wait for child 5 of 10 returned 4 (expected 4)
(syn-read) wait for child 6 of 10 returned 5 (expected 5)
(syn-read) wait for child 7 of 10 returned 6 (expected 6)
(syn-read) wait for child 8 of 10 returned 7 (expected 7)
(syn-read) wait for child 9 of 10 returned 8 (expected 8)
(syn-read) wait for child 10 of 10 returned 9 (expected 9)
(syn-read) end
EOF
pass;
| 10cm | trunk/10cm/pintos/src/tests/filesys/base/syn-read.ck | Perl | oos | 1,331 |
# -*- perl -*-
use strict;
use warnings;
use tests::tests;
check_expected (IGNORE_EXIT_CODES => 1, [<<'EOF']);
(lg-seq-random) begin
(lg-seq-random) create "nibble"
(lg-seq-random) open "nibble"
(lg-seq-random) writing "nibble"
(lg-seq-random) close "nibble"
(lg-seq-random) open "nibble" for verification
(lg-seq-random) verified contents of "nibble"
(lg-seq-random) close "nibble"
(lg-seq-random) end
EOF
pass;
| 10cm | trunk/10cm/pintos/src/tests/filesys/base/lg-seq-random.ck | Perl | oos | 413 |
/* Writes out the contents of a fairly small file all at once,
and then reads it back to make sure that it was written
properly. */
#define TEST_SIZE 5678
#include "tests/filesys/base/full.inc"
| 10cm | trunk/10cm/pintos/src/tests/filesys/base/sm-full.c | C | oos | 201 |
#ifndef TESTS_FILESYS_BASE_SYN_READ_H
#define TESTS_FILESYS_BASE_SYN_READ_H
#define BUF_SIZE 1024
static const char file_name[] = "data";
#endif /* tests/filesys/base/syn-read.h */
| 10cm | trunk/10cm/pintos/src/tests/filesys/base/syn-read.h | C | oos | 183 |
/* Writes out the content of a fairly small file in random order,
then reads it back in random order to verify that it was
written properly. */
#define BLOCK_SIZE 13
#define TEST_SIZE (13 * 123)
#include "tests/filesys/base/random.inc"
| 10cm | trunk/10cm/pintos/src/tests/filesys/base/sm-random.c | C | oos | 243 |
/* Child process for syn-read test.
Writes into part of a test file. Other processes will be
writing into other parts at the same time. */
#include <random.h>
#include <stdlib.h>
#include <syscall.h>
#include "tests/lib.h"
#include "tests/filesys/base/syn-write.h"
char buf[BUF_SIZE];
int
main (int argc, char *argv[])
{
int child_idx;
int fd;
quiet = true;
CHECK (argc == 2, "argc must be 2, actually %d", argc);
child_idx = atoi (argv[1]);
random_init (0);
random_bytes (buf, sizeof buf);
CHECK ((fd = open (file_name)) > 1, "open \"%s\"", file_name);
seek (fd, CHUNK_SIZE * child_idx);
CHECK (write (fd, buf + CHUNK_SIZE * child_idx, CHUNK_SIZE) > 0,
"write \"%s\"", file_name);
msg ("close \"%s\"", file_name);
close (fd);
return child_idx;
}
| 10cm | trunk/10cm/pintos/src/tests/filesys/base/child-syn-wrt.c | C | oos | 799 |
/* Writes out a fairly large file sequentially, one fixed-size
block at a time, then reads it back to verify that it was
written properly. */
#define TEST_SIZE 75678
#define BLOCK_SIZE 513
#include "tests/filesys/base/seq-block.inc"
| 10cm | trunk/10cm/pintos/src/tests/filesys/base/lg-seq-block.c | C | oos | 240 |
/* Tests that create properly zeros out the contents of a fairly
large file. */
#define TEST_SIZE 75678
#include "tests/filesys/create.inc"
| 10cm | trunk/10cm/pintos/src/tests/filesys/base/lg-create.c | C | oos | 144 |
# -*- perl -*-
use strict;
use warnings;
use tests::tests;
check_expected (IGNORE_EXIT_CODES => 1, [<<'EOF']);
(syn-write) begin
(syn-write) create "stuff"
(syn-write) exec child 1 of 10: "child-syn-wrt 0"
(syn-write) exec child 2 of 10: "child-syn-wrt 1"
(syn-write) exec child 3 of 10: "child-syn-wrt 2"
(syn-write) exec child 4 of 10: "child-syn-wrt 3"
(syn-write) exec child 5 of 10: "child-syn-wrt 4"
(syn-write) exec child 6 of 10: "child-syn-wrt 5"
(syn-write) exec child 7 of 10: "child-syn-wrt 6"
(syn-write) exec child 8 of 10: "child-syn-wrt 7"
(syn-write) exec child 9 of 10: "child-syn-wrt 8"
(syn-write) exec child 10 of 10: "child-syn-wrt 9"
(syn-write) wait for child 1 of 10 returned 0 (expected 0)
(syn-write) wait for child 2 of 10 returned 1 (expected 1)
(syn-write) wait for child 3 of 10 returned 2 (expected 2)
(syn-write) wait for child 4 of 10 returned 3 (expected 3)
(syn-write) wait for child 5 of 10 returned 4 (expected 4)
(syn-write) wait for child 6 of 10 returned 5 (expected 5)
(syn-write) wait for child 7 of 10 returned 6 (expected 6)
(syn-write) wait for child 8 of 10 returned 7 (expected 7)
(syn-write) wait for child 9 of 10 returned 8 (expected 8)
(syn-write) wait for child 10 of 10 returned 9 (expected 9)
(syn-write) open "stuff"
(syn-write) read "stuff"
(syn-write) end
EOF
pass;
| 10cm | trunk/10cm/pintos/src/tests/filesys/base/syn-write.ck | Perl | oos | 1,324 |
/* Verifies that a deleted file may still be written to and read
from. */
#include <random.h>
#include <string.h>
#include <syscall.h>
#include "tests/lib.h"
#include "tests/main.h"
char buf1[1234];
char buf2[1234];
void
test_main (void)
{
const char *file_name = "deleteme";
int fd;
CHECK (create (file_name, sizeof buf1), "create \"%s\"", file_name);
CHECK ((fd = open (file_name)) > 1, "open \"%s\"", file_name);
CHECK (remove (file_name), "remove \"%s\"", file_name);
random_bytes (buf1, sizeof buf1);
CHECK (write (fd, buf1, sizeof buf1) > 0, "write \"%s\"", file_name);
msg ("seek \"%s\" to 0", file_name);
seek (fd, 0);
CHECK (read (fd, buf2, sizeof buf2) > 0, "read \"%s\"", file_name);
compare_bytes (buf2, buf1, sizeof buf1, 0, file_name);
msg ("close \"%s\"", file_name);
close (fd);
}
| 10cm | trunk/10cm/pintos/src/tests/filesys/base/syn-remove.c | C | oos | 833 |
# -*- perl -*-
use strict;
use warnings;
use tests::tests;
check_expected (IGNORE_EXIT_CODES => 1, [<<'EOF']);
(sm-seq-block) begin
(sm-seq-block) create "noodle"
(sm-seq-block) open "noodle"
(sm-seq-block) writing "noodle"
(sm-seq-block) close "noodle"
(sm-seq-block) open "noodle" for verification
(sm-seq-block) verified contents of "noodle"
(sm-seq-block) close "noodle"
(sm-seq-block) end
EOF
pass;
| 10cm | trunk/10cm/pintos/src/tests/filesys/base/sm-seq-block.ck | Perl | oos | 404 |
/* Writes out the contents of a fairly large file all at once,
and then reads it back to make sure that it was written
properly. */
#define TEST_SIZE 75678
#include "tests/filesys/base/full.inc"
| 10cm | trunk/10cm/pintos/src/tests/filesys/base/lg-full.c | C | oos | 202 |
# -*- perl -*-
use strict;
use warnings;
use tests::tests;
check_expected (IGNORE_EXIT_CODES => 1, [<<'EOF']);
(sm-seq-random) begin
(sm-seq-random) create "nibble"
(sm-seq-random) open "nibble"
(sm-seq-random) writing "nibble"
(sm-seq-random) close "nibble"
(sm-seq-random) open "nibble" for verification
(sm-seq-random) verified contents of "nibble"
(sm-seq-random) close "nibble"
(sm-seq-random) end
EOF
pass;
| 10cm | trunk/10cm/pintos/src/tests/filesys/base/sm-seq-random.ck | Perl | oos | 413 |
# -*- perl -*-
use strict;
use warnings;
use tests::tests;
check_expected (IGNORE_EXIT_CODES => 1, [<<'EOF']);
(lg-seq-random) begin
(lg-seq-random) create "nibble"
(lg-seq-random) open "nibble"
(lg-seq-random) writing "nibble"
(lg-seq-random) close "nibble"
(lg-seq-random) open "nibble" for verification
(lg-seq-random) verified contents of "nibble"
(lg-seq-random) close "nibble"
(lg-seq-random) end
EOF
pass;
| 10cm | trunk/10cm/pintos/src/tests/filesys/base/.svn/text-base/lg-seq-random.ck.svn-base | Perl | oos | 413 |
# -*- perl -*-
use strict;
use warnings;
use tests::tests;
check_expected (IGNORE_EXIT_CODES => 1, [<<'EOF']);
(lg-random) begin
(lg-random) create "bazzle"
(lg-random) open "bazzle"
(lg-random) write "bazzle" in random order
(lg-random) read "bazzle" in random order
(lg-random) close "bazzle"
(lg-random) end
EOF
pass;
| 10cm | trunk/10cm/pintos/src/tests/filesys/base/.svn/text-base/lg-random.ck.svn-base | Perl | oos | 321 |
# -*- perl -*-
use strict;
use warnings;
use tests::tests;
check_expected (IGNORE_EXIT_CODES => 1, [<<'EOF']);
(lg-create) begin
(lg-create) create "blargle"
(lg-create) open "blargle" for verification
(lg-create) verified contents of "blargle"
(lg-create) close "blargle"
(lg-create) end
EOF
pass;
| 10cm | trunk/10cm/pintos/src/tests/filesys/base/.svn/text-base/lg-create.ck.svn-base | Perl | oos | 299 |
# -*- perl -*-
use strict;
use warnings;
use tests::tests;
check_expected (IGNORE_EXIT_CODES => 1, [<<'EOF']);
(sm-full) begin
(sm-full) create "quux"
(sm-full) open "quux"
(sm-full) writing "quux"
(sm-full) close "quux"
(sm-full) open "quux" for verification
(sm-full) verified contents of "quux"
(sm-full) close "quux"
(sm-full) end
EOF
pass;
| 10cm | trunk/10cm/pintos/src/tests/filesys/base/.svn/text-base/sm-full.ck.svn-base | Perl | oos | 345 |
# -*- makefile -*-
tests/filesys/base_TESTS = $(addprefix tests/filesys/base/,lg-create \
lg-full lg-random lg-seq-block lg-seq-random sm-create sm-full \
sm-random sm-seq-block sm-seq-random syn-read syn-remove syn-write 2011_prj5_test)
tests/filesys/base_PROGS = $(tests/filesys/base_TESTS) $(addprefix \
tests/filesys/base/,child-syn-read child-syn-wrt)
$(foreach prog,$(tests/filesys/base_PROGS), \
$(eval $(prog)_SRC += $(prog).c tests/lib.c tests/filesys/seq-test.c))
$(foreach prog,$(tests/filesys/base_TESTS), \
$(eval $(prog)_SRC += tests/main.c))
tests/filesys/base/syn-read_PUTFILES = tests/filesys/base/child-syn-read
tests/filesys/base/syn-write_PUTFILES = tests/filesys/base/child-syn-wrt
tests/filesys/base/syn-read.output: TIMEOUT = 300
| 10cm | trunk/10cm/pintos/src/tests/filesys/base/.svn/text-base/Make.tests.svn-base | Makefile | oos | 766 |
# -*- perl -*-
use strict;
use warnings;
use tests::tests;
check_expected (IGNORE_EXIT_CODES => 1, [<<'EOF']);
(lg-seq-block) begin
(lg-seq-block) create "noodle"
(lg-seq-block) open "noodle"
(lg-seq-block) writing "noodle"
(lg-seq-block) close "noodle"
(lg-seq-block) open "noodle" for verification
(lg-seq-block) verified contents of "noodle"
(lg-seq-block) close "noodle"
(lg-seq-block) end
EOF
pass;
| 10cm | trunk/10cm/pintos/src/tests/filesys/base/.svn/text-base/lg-seq-block.ck.svn-base | Perl | oos | 404 |
# -*- perl -*-
use strict;
use warnings;
use tests::tests;
check_expected (IGNORE_EXIT_CODES => 1, [<<'EOF']);
(sm-create) begin
(sm-create) create "blargle"
(sm-create) open "blargle" for verification
(sm-create) verified contents of "blargle"
(sm-create) close "blargle"
(sm-create) end
EOF
pass;
| 10cm | trunk/10cm/pintos/src/tests/filesys/base/.svn/text-base/sm-create.ck.svn-base | Perl | oos | 299 |
# -*- perl -*-
use strict;
use warnings;
use tests::tests;
check_expected (IGNORE_EXIT_CODES => 1, [<<'EOF']);
(lg-full) begin
(lg-full) create "quux"
(lg-full) open "quux"
(lg-full) writing "quux"
(lg-full) close "quux"
(lg-full) open "quux" for verification
(lg-full) verified contents of "quux"
(lg-full) close "quux"
(lg-full) end
EOF
pass;
| 10cm | trunk/10cm/pintos/src/tests/filesys/base/.svn/text-base/lg-full.ck.svn-base | Perl | oos | 345 |
/* -*- c -*- */
#include <random.h>
#include <stdio.h>
#include <string.h>
#include <syscall.h>
#include "tests/lib.h"
#include "tests/main.h"
#if TEST_SIZE % BLOCK_SIZE != 0
#error TEST_SIZE must be a multiple of BLOCK_SIZE
#endif
#define BLOCK_CNT (TEST_SIZE / BLOCK_SIZE)
char buf[TEST_SIZE];
int order[BLOCK_CNT];
void
test_main (void)
{
const char *file_name = "bazzle";
int fd;
size_t i;
random_init (57);
random_bytes (buf, sizeof buf);
for (i = 0; i < BLOCK_CNT; i++)
order[i] = i;
CHECK (create (file_name, TEST_SIZE), "create \"%s\"", file_name);
CHECK ((fd = open (file_name)) > 1, "open \"%s\"", file_name);
msg ("write \"%s\" in random order", file_name);
shuffle (order, BLOCK_CNT, sizeof *order);
for (i = 0; i < BLOCK_CNT; i++)
{
size_t ofs = BLOCK_SIZE * order[i];
seek (fd, ofs);
if (write (fd, buf + ofs, BLOCK_SIZE) != BLOCK_SIZE)
fail ("write %d bytes at offset %zu failed", (int) BLOCK_SIZE, ofs);
}
msg ("read \"%s\" in random order", file_name);
shuffle (order, BLOCK_CNT, sizeof *order);
for (i = 0; i < BLOCK_CNT; i++)
{
char block[BLOCK_SIZE];
size_t ofs = BLOCK_SIZE * order[i];
seek (fd, ofs);
if (read (fd, block, BLOCK_SIZE) != BLOCK_SIZE)
fail ("read %d bytes at offset %zu failed", (int) BLOCK_SIZE, ofs);
compare_bytes (block, buf + ofs, BLOCK_SIZE, ofs, file_name);
}
msg ("close \"%s\"", file_name);
close (fd);
}
| 10cm | trunk/10cm/pintos/src/tests/filesys/base/.svn/text-base/random.inc.svn-base | C | oos | 1,480 |
# -*- perl -*-
use strict;
use warnings;
use tests::tests;
check_expected (IGNORE_EXIT_CODES => 1, [<<'EOF']);
(syn-read) begin
(syn-read) create "data"
(syn-read) open "data"
(syn-read) write "data"
(syn-read) close "data"
(syn-read) exec child 1 of 10: "child-syn-read 0"
(syn-read) exec child 2 of 10: "child-syn-read 1"
(syn-read) exec child 3 of 10: "child-syn-read 2"
(syn-read) exec child 4 of 10: "child-syn-read 3"
(syn-read) exec child 5 of 10: "child-syn-read 4"
(syn-read) exec child 6 of 10: "child-syn-read 5"
(syn-read) exec child 7 of 10: "child-syn-read 6"
(syn-read) exec child 8 of 10: "child-syn-read 7"
(syn-read) exec child 9 of 10: "child-syn-read 8"
(syn-read) exec child 10 of 10: "child-syn-read 9"
(syn-read) wait for child 1 of 10 returned 0 (expected 0)
(syn-read) wait for child 2 of 10 returned 1 (expected 1)
(syn-read) wait for child 3 of 10 returned 2 (expected 2)
(syn-read) wait for child 4 of 10 returned 3 (expected 3)
(syn-read) wait for child 5 of 10 returned 4 (expected 4)
(syn-read) wait for child 6 of 10 returned 5 (expected 5)
(syn-read) wait for child 7 of 10 returned 6 (expected 6)
(syn-read) wait for child 8 of 10 returned 7 (expected 7)
(syn-read) wait for child 9 of 10 returned 8 (expected 8)
(syn-read) wait for child 10 of 10 returned 9 (expected 9)
(syn-read) end
EOF
pass;
| 10cm | trunk/10cm/pintos/src/tests/filesys/base/.svn/text-base/syn-read.ck.svn-base | Perl | oos | 1,331 |
# -*- perl -*-
use strict;
use warnings;
use tests::tests;
check_expected (IGNORE_EXIT_CODES => 1, [<<'EOF']);
(sm-random) begin
(sm-random) create "bazzle"
(sm-random) open "bazzle"
(sm-random) write "bazzle" in random order
(sm-random) read "bazzle" in random order
(sm-random) close "bazzle"
(sm-random) end
EOF
pass;
| 10cm | trunk/10cm/pintos/src/tests/filesys/base/.svn/text-base/sm-random.ck.svn-base | Perl | oos | 321 |
# -*- perl -*-
use strict;
use warnings;
use tests::tests;
check_expected (IGNORE_EXIT_CODES => 1, [<<'EOF']);
(sm-seq-block) begin
(sm-seq-block) create "noodle"
(sm-seq-block) open "noodle"
(sm-seq-block) writing "noodle"
(sm-seq-block) close "noodle"
(sm-seq-block) open "noodle" for verification
(sm-seq-block) verified contents of "noodle"
(sm-seq-block) close "noodle"
(sm-seq-block) end
EOF
pass;
| 10cm | trunk/10cm/pintos/src/tests/filesys/base/.svn/text-base/sm-seq-block.ck.svn-base | Perl | oos | 404 |
/* -*- c -*- */
#include "tests/filesys/seq-test.h"
#include "tests/main.h"
static char buf[TEST_SIZE];
static size_t
return_block_size (void)
{
return BLOCK_SIZE;
}
void
test_main (void)
{
seq_test ("noodle",
buf, sizeof buf, sizeof buf,
return_block_size, NULL);
}
| 10cm | trunk/10cm/pintos/src/tests/filesys/base/.svn/text-base/seq-block.inc.svn-base | C | oos | 301 |
# -*- perl -*-
use strict;
use warnings;
use tests::tests;
check_expected (IGNORE_EXIT_CODES => 1, [<<'EOF']);
(syn-write) begin
(syn-write) create "stuff"
(syn-write) exec child 1 of 10: "child-syn-wrt 0"
(syn-write) exec child 2 of 10: "child-syn-wrt 1"
(syn-write) exec child 3 of 10: "child-syn-wrt 2"
(syn-write) exec child 4 of 10: "child-syn-wrt 3"
(syn-write) exec child 5 of 10: "child-syn-wrt 4"
(syn-write) exec child 6 of 10: "child-syn-wrt 5"
(syn-write) exec child 7 of 10: "child-syn-wrt 6"
(syn-write) exec child 8 of 10: "child-syn-wrt 7"
(syn-write) exec child 9 of 10: "child-syn-wrt 8"
(syn-write) exec child 10 of 10: "child-syn-wrt 9"
(syn-write) wait for child 1 of 10 returned 0 (expected 0)
(syn-write) wait for child 2 of 10 returned 1 (expected 1)
(syn-write) wait for child 3 of 10 returned 2 (expected 2)
(syn-write) wait for child 4 of 10 returned 3 (expected 3)
(syn-write) wait for child 5 of 10 returned 4 (expected 4)
(syn-write) wait for child 6 of 10 returned 5 (expected 5)
(syn-write) wait for child 7 of 10 returned 6 (expected 6)
(syn-write) wait for child 8 of 10 returned 7 (expected 7)
(syn-write) wait for child 9 of 10 returned 8 (expected 8)
(syn-write) wait for child 10 of 10 returned 9 (expected 9)
(syn-write) open "stuff"
(syn-write) read "stuff"
(syn-write) end
EOF
pass;
| 10cm | trunk/10cm/pintos/src/tests/filesys/base/.svn/text-base/syn-write.ck.svn-base | Perl | oos | 1,324 |
/* -*- c -*- */
#include "tests/filesys/seq-test.h"
#include "tests/main.h"
static char buf[TEST_SIZE];
static size_t
return_test_size (void)
{
return TEST_SIZE;
}
void
test_main (void)
{
seq_test ("quux",
buf, sizeof buf, sizeof buf,
return_test_size, NULL);
}
| 10cm | trunk/10cm/pintos/src/tests/filesys/base/.svn/text-base/full.inc.svn-base | C | oos | 296 |
# -*- perl -*-
use strict;
use warnings;
use tests::tests;
check_expected (IGNORE_EXIT_CODES => 1, [<<'EOF']);
(sm-seq-random) begin
(sm-seq-random) create "nibble"
(sm-seq-random) open "nibble"
(sm-seq-random) writing "nibble"
(sm-seq-random) close "nibble"
(sm-seq-random) open "nibble" for verification
(sm-seq-random) verified contents of "nibble"
(sm-seq-random) close "nibble"
(sm-seq-random) end
EOF
pass;
| 10cm | trunk/10cm/pintos/src/tests/filesys/base/.svn/text-base/sm-seq-random.ck.svn-base | Perl | oos | 413 |
/* -*- c -*- */
#include <random.h>
#include "tests/filesys/seq-test.h"
#include "tests/main.h"
static char buf[TEST_SIZE];
static size_t
return_random (void)
{
return random_ulong () % 1031 + 1;
}
void
test_main (void)
{
random_init (-1);
seq_test ("nibble",
buf, sizeof buf, sizeof buf,
return_random, NULL);
}
| 10cm | trunk/10cm/pintos/src/tests/filesys/base/.svn/text-base/seq-random.inc.svn-base | C | oos | 349 |
# -*- perl -*-
use strict;
use warnings;
use tests::tests;
check_expected (IGNORE_EXIT_CODES => 1, [<<'EOF']);
(syn-remove) begin
(syn-remove) create "deleteme"
(syn-remove) open "deleteme"
(syn-remove) remove "deleteme"
(syn-remove) write "deleteme"
(syn-remove) seek "deleteme" to 0
(syn-remove) read "deleteme"
(syn-remove) close "deleteme"
(syn-remove) end
EOF
pass;
| 10cm | trunk/10cm/pintos/src/tests/filesys/base/.svn/text-base/syn-remove.ck.svn-base | Perl | oos | 371 |
/* -*- c -*- */
#include <random.h>
#include "tests/filesys/seq-test.h"
#include "tests/main.h"
static char buf[TEST_SIZE];
static size_t
return_random (void)
{
return random_ulong () % 1031 + 1;
}
void
test_main (void)
{
random_init (-1);
seq_test ("nibble",
buf, sizeof buf, sizeof buf,
return_random, NULL);
}
| 10cm | trunk/10cm/pintos/src/tests/filesys/base/seq-random.inc | C | oos | 349 |
/* Spawns 10 child processes, all of which read from the same
file and make sure that the contents are what they should
be. */
#include <random.h>
#include <stdio.h>
#include <syscall.h>
#include "tests/lib.h"
#include "tests/main.h"
#include "tests/filesys/base/syn-read.h"
static char buf[BUF_SIZE];
#define CHILD_CNT 10
void
test_main (void)
{
pid_t children[CHILD_CNT];
int fd;
CHECK (create (file_name, sizeof buf), "create \"%s\"", file_name);
CHECK ((fd = open (file_name)) > 1, "open \"%s\"", file_name);
random_bytes (buf, sizeof buf);
CHECK (write (fd, buf, sizeof buf) > 0, "write \"%s\"", file_name);
msg ("close \"%s\"", file_name);
close (fd);
exec_children ("child-syn-read", children, CHILD_CNT);
wait_children (children, CHILD_CNT);
}
| 10cm | trunk/10cm/pintos/src/tests/filesys/base/syn-read.c | C | oos | 785 |
# -*- perl -*-
use strict;
use warnings;
use tests::tests;
check_expected (IGNORE_EXIT_CODES => 1, [<<'EOF']);
(lg-create) begin
(lg-create) create "blargle"
(lg-create) open "blargle" for verification
(lg-create) verified contents of "blargle"
(lg-create) close "blargle"
(lg-create) end
EOF
pass;
| 10cm | trunk/10cm/pintos/src/tests/filesys/base/lg-create.ck | Perl | oos | 299 |
#ifndef TESTS_FILESYS_BASE_SYN_WRITE_H
#define TESTS_FILESYS_BASE_SYN_WRITE_H
#define CHILD_CNT 10
#define CHUNK_SIZE 512
#define BUF_SIZE (CHILD_CNT * CHUNK_SIZE)
static const char file_name[] = "stuff";
#endif /* tests/filesys/base/syn-write.h */
| 10cm | trunk/10cm/pintos/src/tests/filesys/base/syn-write.h | C | oos | 251 |
# -*- perl -*-
use strict;
use warnings;
use tests::tests;
check_expected (IGNORE_EXIT_CODES => 1, [<<'EOF']);
(sm-random) begin
(sm-random) create "bazzle"
(sm-random) open "bazzle"
(sm-random) write "bazzle" in random order
(sm-random) read "bazzle" in random order
(sm-random) close "bazzle"
(sm-random) end
EOF
pass;
| 10cm | trunk/10cm/pintos/src/tests/filesys/base/sm-random.ck | Perl | oos | 321 |
/* -*- c -*- */
#include "tests/filesys/seq-test.h"
#include "tests/main.h"
static char buf[TEST_SIZE];
static size_t
return_test_size (void)
{
return TEST_SIZE;
}
void
test_main (void)
{
seq_test ("quux",
buf, sizeof buf, sizeof buf,
return_test_size, NULL);
}
| 10cm | trunk/10cm/pintos/src/tests/filesys/base/full.inc | C | oos | 296 |
# -*- makefile -*-
tests/filesys/base_TESTS = $(addprefix tests/filesys/base/,lg-create \
lg-full lg-random lg-seq-block lg-seq-random sm-create sm-full \
sm-random sm-seq-block sm-seq-random syn-read syn-remove syn-write 2011_prj5_test)
tests/filesys/base_PROGS = $(tests/filesys/base_TESTS) $(addprefix \
tests/filesys/base/,child-syn-read child-syn-wrt)
$(foreach prog,$(tests/filesys/base_PROGS), \
$(eval $(prog)_SRC += $(prog).c tests/lib.c tests/filesys/seq-test.c))
$(foreach prog,$(tests/filesys/base_TESTS), \
$(eval $(prog)_SRC += tests/main.c))
tests/filesys/base/syn-read_PUTFILES = tests/filesys/base/child-syn-read
tests/filesys/base/syn-write_PUTFILES = tests/filesys/base/child-syn-wrt
tests/filesys/base/syn-read.output: TIMEOUT = 300
| 10cm | trunk/10cm/pintos/src/tests/filesys/base/Make.tests | Makefile | oos | 766 |
# -*- perl -*-
use strict;
use warnings;
use tests::tests;
check_expected (IGNORE_EXIT_CODES => 1, [<<'EOF']);
(lg-seq-block) begin
(lg-seq-block) create "noodle"
(lg-seq-block) open "noodle"
(lg-seq-block) writing "noodle"
(lg-seq-block) close "noodle"
(lg-seq-block) open "noodle" for verification
(lg-seq-block) verified contents of "noodle"
(lg-seq-block) close "noodle"
(lg-seq-block) end
EOF
pass;
| 10cm | trunk/10cm/pintos/src/tests/filesys/base/lg-seq-block.ck | Perl | oos | 404 |
# -*- perl -*-
use strict;
use warnings;
use tests::tests;
check_expected (IGNORE_EXIT_CODES => 1, [<<'EOF']);
(sm-create) begin
(sm-create) create "blargle"
(sm-create) open "blargle" for verification
(sm-create) verified contents of "blargle"
(sm-create) close "blargle"
(sm-create) end
EOF
pass;
| 10cm | trunk/10cm/pintos/src/tests/filesys/base/sm-create.ck | Perl | oos | 299 |
/* Writes out a fairly small file sequentially, one fixed-size
block at a time, then reads it back to verify that it was
written properly. */
#define TEST_SIZE 5678
#define BLOCK_SIZE 513
#include "tests/filesys/base/seq-block.inc"
| 10cm | trunk/10cm/pintos/src/tests/filesys/base/sm-seq-block.c | C | oos | 239 |
/* -*- c -*- */
#include <random.h>
#include <stdio.h>
#include <string.h>
#include <syscall.h>
#include "tests/lib.h"
#include "tests/main.h"
#if TEST_SIZE % BLOCK_SIZE != 0
#error TEST_SIZE must be a multiple of BLOCK_SIZE
#endif
#define BLOCK_CNT (TEST_SIZE / BLOCK_SIZE)
char buf[TEST_SIZE];
int order[BLOCK_CNT];
void
test_main (void)
{
const char *file_name = "bazzle";
int fd;
size_t i;
random_init (57);
random_bytes (buf, sizeof buf);
for (i = 0; i < BLOCK_CNT; i++)
order[i] = i;
CHECK (create (file_name, TEST_SIZE), "create \"%s\"", file_name);
CHECK ((fd = open (file_name)) > 1, "open \"%s\"", file_name);
msg ("write \"%s\" in random order", file_name);
shuffle (order, BLOCK_CNT, sizeof *order);
for (i = 0; i < BLOCK_CNT; i++)
{
size_t ofs = BLOCK_SIZE * order[i];
seek (fd, ofs);
if (write (fd, buf + ofs, BLOCK_SIZE) != BLOCK_SIZE)
fail ("write %d bytes at offset %zu failed", (int) BLOCK_SIZE, ofs);
}
msg ("read \"%s\" in random order", file_name);
shuffle (order, BLOCK_CNT, sizeof *order);
for (i = 0; i < BLOCK_CNT; i++)
{
char block[BLOCK_SIZE];
size_t ofs = BLOCK_SIZE * order[i];
seek (fd, ofs);
if (read (fd, block, BLOCK_SIZE) != BLOCK_SIZE)
fail ("read %d bytes at offset %zu failed", (int) BLOCK_SIZE, ofs);
compare_bytes (block, buf + ofs, BLOCK_SIZE, ofs, file_name);
}
msg ("close \"%s\"", file_name);
close (fd);
}
| 10cm | trunk/10cm/pintos/src/tests/filesys/base/random.inc | C | oos | 1,480 |
/* Writes out a fairly large file sequentially, one random-sized
block at a time, then reads it back to verify that it was
written properly. */
#define TEST_SIZE 75678
#include "tests/filesys/base/seq-random.inc"
| 10cm | trunk/10cm/pintos/src/tests/filesys/base/lg-seq-random.c | C | oos | 220 |
# -*- perl -*-
use strict;
use warnings;
use tests::tests;
check_expected (IGNORE_EXIT_CODES => 1, [<<'EOF']);
(syn-remove) begin
(syn-remove) create "deleteme"
(syn-remove) open "deleteme"
(syn-remove) remove "deleteme"
(syn-remove) write "deleteme"
(syn-remove) seek "deleteme" to 0
(syn-remove) read "deleteme"
(syn-remove) close "deleteme"
(syn-remove) end
EOF
pass;
| 10cm | trunk/10cm/pintos/src/tests/filesys/base/syn-remove.ck | Perl | oos | 371 |
# -*- perl -*-
use strict;
use warnings;
use tests::tests;
check_expected (IGNORE_EXIT_CODES => 1, [<<'EOF']);
(lg-random) begin
(lg-random) create "bazzle"
(lg-random) open "bazzle"
(lg-random) write "bazzle" in random order
(lg-random) read "bazzle" in random order
(lg-random) close "bazzle"
(lg-random) end
EOF
pass;
| 10cm | trunk/10cm/pintos/src/tests/filesys/base/lg-random.ck | Perl | oos | 321 |
/* Writes out a fairly large file sequentially, one random-sized
block at a time, then reads it back to verify that it was
written properly. */
#define TEST_SIZE 5678
#include "tests/filesys/base/seq-random.inc"
| 10cm | trunk/10cm/pintos/src/tests/filesys/base/sm-seq-random.c | C | oos | 219 |