static void
test_Open_Dir(TestBatch *batch)
{
Folder *folder = (Folder*)RAMFolder_new(NULL);
DirHandle *dh;
Folder_MkDir(folder, &foo);
Folder_MkDir(folder, &foo_bar);
dh = Folder_Open_Dir(folder, &foo);
TEST_TRUE(batch, dh && DH_Is_A(dh, DIRHANDLE), "Open_Dir");
DECREF(dh);
dh = Folder_Open_Dir(folder, &foo_bar);
TEST_TRUE(batch, dh && DH_Is_A(dh, DIRHANDLE), "Open_Dir nested dir");
DECREF(dh);
Err_set_error(NULL);
dh = Folder_Open_Dir(folder, &bar);
TEST_TRUE(batch, dh == NULL,
"Open_Dir on non-existent entry fails");
TEST_TRUE(batch, Err_get_error() != NULL,
"Open_Dir on non-existent entry sets Err_error");
Err_set_error(NULL);
dh = Folder_Open_Dir(folder, &foo_foo);
TEST_TRUE(batch, dh == NULL,
"Open_Dir on non-existent nested entry fails");
TEST_TRUE(batch, Err_get_error() != NULL,
"Open_Dir on non-existent nested entry sets Err_error");
DECREF(folder);
}
static void
test_Read_File_and_Write_File(TestBatchRunner *runner) {
Snapshot *snapshot = Snapshot_new();
Folder *folder = (Folder*)RAMFolder_new(NULL);
String *snap = (String*)SSTR_WRAP_UTF8("snap", 4);
String *foo = (String*)SSTR_WRAP_UTF8("foo", 3);
Snapshot_Add_Entry(snapshot, foo);
Snapshot_Write_File(snapshot, folder, snap);
Snapshot *dupe = Snapshot_new();
Snapshot *read_retval = Snapshot_Read_File(dupe, folder, snap);
TEST_TRUE(runner, dupe == read_retval, "Read_File() returns the object");
Vector *orig_list = Snapshot_List(snapshot);
Vector *dupe_list = Snapshot_List(dupe);
TEST_TRUE(runner, Vec_Equals(orig_list, (Obj*)dupe_list),
"Round trip through Write_File() and Read_File()");
DECREF(orig_list);
DECREF(dupe_list);
DECREF(dupe);
DECREF(snapshot);
DECREF(folder);
}
static void
test_Local_MkDir(TestBatchRunner *runner) {
RAMFolder *folder = RAMFolder_new(NULL);
bool result;
result = RAMFolder_Local_MkDir(folder, foo);
TEST_TRUE(runner, result, "Local_MkDir succeeds and returns true");
Err_set_error(NULL);
result = RAMFolder_Local_MkDir(folder, foo);
TEST_FALSE(runner, result,
"Local_MkDir returns false when a dir already exists");
TEST_TRUE(runner, Err_get_error() != NULL,
"Local_MkDir sets Err_error when a dir already exists");
TEST_TRUE(runner, RAMFolder_Exists(folder, foo),
"Existing dir untouched after failed Local_MkDir");
FileHandle *fh = RAMFolder_Open_FileHandle(folder, boffo,
FH_CREATE | FH_WRITE_ONLY);
DECREF(fh);
Err_set_error(NULL);
result = RAMFolder_Local_MkDir(folder, foo);
TEST_FALSE(runner, result,
"Local_MkDir returns false when a file already exists");
TEST_TRUE(runner, Err_get_error() != NULL,
"Local_MkDir sets Err_error when a file already exists");
TEST_TRUE(runner, RAMFolder_Exists(folder, boffo) &&
!RAMFolder_Local_Is_Directory(folder, boffo),
"Existing file untouched after failed Local_MkDir");
DECREF(folder);
}
static void
test_Open_FileHandle(TestBatch *batch)
{
Folder *folder = (Folder*)RAMFolder_new(NULL);
FileHandle *fh;
Folder_MkDir(folder, &foo);
fh = Folder_Open_FileHandle(folder, &boffo, FH_CREATE | FH_WRITE_ONLY);
TEST_TRUE(batch, fh && FH_Is_A(fh, FILEHANDLE), "Open_FileHandle");
DECREF(fh);
fh = Folder_Open_FileHandle(folder, &foo_boffo,
FH_CREATE | FH_WRITE_ONLY);
TEST_TRUE(batch, fh && FH_Is_A(fh, FILEHANDLE),
"Open_FileHandle for nested file");
DECREF(fh);
Err_set_error(NULL);
fh = Folder_Open_FileHandle(folder, &foo, FH_CREATE | FH_WRITE_ONLY);
TEST_TRUE(batch, fh == NULL,
"Open_FileHandle on existing dir path fails");
TEST_TRUE(batch, Err_get_error() != NULL,
"Open_FileHandle on existing dir name sets Err_error");
Err_set_error(NULL);
fh = Folder_Open_FileHandle(folder, &foo_bar_baz_boffo,
FH_CREATE | FH_WRITE_ONLY);
TEST_TRUE(batch, fh == NULL,
"Open_FileHandle for entry within non-existent dir fails");
TEST_TRUE(batch, Err_get_error() != NULL,
"Open_FileHandle for entry within non-existent dir sets Err_error");
DECREF(folder);
}
static void
test_Write_File_and_Read_File(TestBatchRunner *runner) {
RAMFolder *folder = RAMFolder_new(NULL);
Segment *segment = Seg_new(100);
Segment *got = Seg_new(100);
String *meta;
String *flotsam = (String*)SSTR_WRAP_UTF8("flotsam", 7);
String *jetsam = (String*)SSTR_WRAP_UTF8("jetsam", 6);
Seg_Set_Count(segment, 111);
Seg_Store_Metadata_Utf8(segment, "foo", 3, (Obj*)Str_newf("bar"));
Seg_Add_Field(segment, flotsam);
Seg_Add_Field(segment, jetsam);
RAMFolder_MkDir(folder, Seg_Get_Name(segment));
Seg_Write_File(segment, (Folder*)folder);
Seg_Read_File(got, (Folder*)folder);
TEST_TRUE(runner, Seg_Get_Count(got) == Seg_Get_Count(segment),
"Round-trip count through file");
TEST_TRUE(runner,
Seg_Field_Num(got, jetsam) == Seg_Field_Num(segment, jetsam),
"Round trip field names through file");
meta = (String*)Seg_Fetch_Metadata_Utf8(got, "foo", 3);
TEST_TRUE(runner,
meta
&& Str_Is_A(meta, STRING)
&& Str_Equals_Utf8(meta, "bar", 3),
"Round trip metadata through file");
DECREF(got);
DECREF(segment);
DECREF(folder);
}
static Folder*
S_create_index()
{
Schema *schema = (Schema*)TestSchema_new();
RAMFolder *folder = RAMFolder_new(NULL);
VArray *doc_set = TestUtils_doc_set();
Indexer *indexer = Indexer_new(schema, (Obj*)folder, NULL, NULL, 0);
u32_t i, max;
for (i = 0, max = VA_Get_Size(doc_set); i < max; i++) {
static CharBuf field = ZCB_LITERAL("content");
Doc *doc = Doc_new(NULL, 0);
Doc_Store(doc, &field, VA_Fetch(doc_set, i));
Indexer_Add_Doc(indexer, doc, 1.0f);
DECREF(doc);
}
Indexer_Commit(indexer);
DECREF(doc_set);
DECREF(indexer);
DECREF(schema);
return (Folder*)folder;
}
static void
test_Local_Delete(TestBatchRunner *runner) {
RAMFolder *folder = RAMFolder_new(NULL);
FileHandle *fh;
fh = RAMFolder_Open_FileHandle(folder, boffo, FH_CREATE | FH_WRITE_ONLY);
DECREF(fh);
TEST_TRUE(runner, RAMFolder_Local_Delete(folder, boffo),
"Local_Delete on file succeeds");
RAMFolder_Local_MkDir(folder, foo);
fh = RAMFolder_Open_FileHandle(folder, foo_boffo,
FH_CREATE | FH_WRITE_ONLY);
DECREF(fh);
Err_set_error(NULL);
TEST_FALSE(runner, RAMFolder_Local_Delete(folder, foo),
"Local_Delete on non-empty dir fails");
RAMFolder_Delete(folder, foo_boffo);
TEST_TRUE(runner, RAMFolder_Local_Delete(folder, foo),
"Local_Delete on empty dir succeeds");
DECREF(folder);
}
static void
test_Write_File_and_Read_File(TestBatch *batch)
{
RAMFolder *folder = RAMFolder_new(NULL);
Segment *segment = Seg_new(100);
Segment *got = Seg_new(100);
CharBuf *meta;
CharBuf *flotsam = (CharBuf*)ZCB_WRAP_STR("flotsam", 7);
CharBuf *jetsam = (CharBuf*)ZCB_WRAP_STR("jetsam", 6);
Seg_Set_Count(segment, 111);
Seg_Store_Metadata_Str(segment, "foo", 3, (Obj*)CB_newf("bar"));
Seg_Add_Field(segment, flotsam);
Seg_Add_Field(segment, jetsam);
RAMFolder_MkDir(folder, Seg_Get_Name(segment));
Seg_Write_File(segment, (Folder*)folder);
Seg_Read_File(got, (Folder*)folder);
TEST_TRUE(batch, Seg_Get_Count(got) == Seg_Get_Count(segment),
"Round-trip count through file");
TEST_TRUE(batch,
Seg_Field_Num(got, jetsam) == Seg_Field_Num(segment, jetsam),
"Round trip field names through file");
meta = (CharBuf*)Seg_Fetch_Metadata_Str(got, "foo", 3);
TEST_TRUE(batch, meta && CB_Is_A(meta, CHARBUF)
&& CB_Equals_Str(meta, "bar", 3), "Round trip metadata through file");
DECREF(got);
DECREF(segment);
DECREF(folder);
}
static void
test_Exists(TestBatch *batch)
{
Folder *folder = (Folder*)RAMFolder_new(NULL);
FileHandle *fh;
Folder_MkDir(folder, &foo);
Folder_MkDir(folder, &foo_bar);
fh = Folder_Open_FileHandle(folder, &boffo, FH_CREATE | FH_WRITE_ONLY);
DECREF(fh);
fh = Folder_Open_FileHandle(folder, &foo_boffo,
FH_CREATE | FH_WRITE_ONLY);
DECREF(fh);
TEST_TRUE(batch, Folder_Exists(folder, &foo), "Dir exists");
TEST_TRUE(batch, Folder_Exists(folder, &boffo), "File exists");
TEST_TRUE(batch, Folder_Exists(folder, &foo_bar),
"Nested dir exists");
TEST_TRUE(batch, Folder_Exists(folder, &foo_boffo),
"Nested file exists");
TEST_FALSE(batch, Folder_Exists(folder, &banana),
"Non-existent entry");
TEST_FALSE(batch, Folder_Exists(folder, &foo_foo),
"Non-existent nested entry");
DECREF(folder);
}
static void
test_Initialize_and_Check(TestBatchRunner *runner) {
RAMFolder *folder = RAMFolder_new(NULL);
RAMFolder_Initialize(folder);
PASS(runner, "Initialized concludes without incident");
TEST_TRUE(runner, RAMFolder_Check(folder), "Check succeeds");
DECREF(folder);
}
static void
test_highlighting(TestBatchRunner *runner) {
Schema *schema = Schema_new();
StandardTokenizer *tokenizer = StandardTokenizer_new();
FullTextType *plain_type = FullTextType_new((Analyzer*)tokenizer);
FullTextType_Set_Highlightable(plain_type, true);
FullTextType *dunked_type = FullTextType_new((Analyzer*)tokenizer);
FullTextType_Set_Highlightable(dunked_type, true);
FullTextType_Set_Boost(dunked_type, 0.1f);
String *content = (String*)SSTR_WRAP_UTF8("content", 7);
Schema_Spec_Field(schema, content, (FieldType*)plain_type);
String *alt = (String*)SSTR_WRAP_UTF8("alt", 3);
Schema_Spec_Field(schema, alt, (FieldType*)dunked_type);
DECREF(plain_type);
DECREF(dunked_type);
DECREF(tokenizer);
RAMFolder *folder = RAMFolder_new(NULL);
Indexer *indexer = Indexer_new(schema, (Obj*)folder, NULL, 0);
Doc *doc = Doc_new(NULL, 0);
String *string = (String *)SSTR_WRAP_UTF8(TEST_STRING, TEST_STRING_LEN);
Doc_Store(doc, content, (Obj*)string);
Indexer_Add_Doc(indexer, doc, 1.0f);
DECREF(doc);
doc = Doc_new(NULL, 0);
string = (String *)SSTR_WRAP_UTF8("\"I see,\" said the blind man.", 28);
Doc_Store(doc, content, (Obj*)string);
Indexer_Add_Doc(indexer, doc, 1.0f);
DECREF(doc);
doc = Doc_new(NULL, 0);
string = (String *)SSTR_WRAP_UTF8("x but not why or 2ee", 20);
Doc_Store(doc, content, (Obj*)string);
string = (String *)SSTR_WRAP_UTF8(TEST_STRING
" and extra stuff so it scores lower",
TEST_STRING_LEN + 35);
Doc_Store(doc, alt, (Obj*)string);
Indexer_Add_Doc(indexer, doc, 1.0f);
DECREF(doc);
Indexer_Commit(indexer);
DECREF(indexer);
Searcher *searcher = (Searcher*)IxSearcher_new((Obj*)folder);
Obj *query = (Obj*)SSTR_WRAP_UTF8("\"x y z\" AND " PHI, 14);
Hits *hits = Searcher_Hits(searcher, query, 0, 10, NULL);
test_Raw_Excerpt(runner, searcher, query);
test_Highlight_Excerpt(runner, searcher, query);
test_Create_Excerpt(runner, searcher, query, hits);
DECREF(hits);
DECREF(searcher);
DECREF(folder);
DECREF(schema);
}
static void
test_Local_Open_Dir(TestBatchRunner *runner) {
RAMFolder *folder = RAMFolder_new(NULL);
DirHandle *dh = RAMFolder_Local_Open_Dir(folder);
TEST_TRUE(runner, dh && DH_Is_A(dh, RAMDIRHANDLE),
"Local_Open_Dir returns a RAMDirHandle");
DECREF(dh);
DECREF(folder);
}
static void
test_hl_selection(TestBatchRunner *runner) {
Schema *schema = Schema_new();
StandardTokenizer *tokenizer = StandardTokenizer_new();
FullTextType *plain_type = FullTextType_new((Analyzer*)tokenizer);
FullTextType_Set_Highlightable(plain_type, true);
String *content = (String*)SSTR_WRAP_UTF8("content", 7);
Schema_Spec_Field(schema, content, (FieldType*)plain_type);
DECREF(plain_type);
DECREF(tokenizer);
RAMFolder *folder = RAMFolder_new(NULL);
Indexer *indexer = Indexer_new(schema, (Obj*)folder, NULL, 0);
static char test_string[] =
"bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla. "
"bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla. "
"bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla. "
"bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla. "
"bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla. "
"bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla NNN bla. "
"bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla. "
"bla bla bla MMM bla bla bla bla bla bla bla bla bla bla bla bla. "
"bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla. "
"bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla. "
"bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla. "
"bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla. "
"bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla. ";
Doc *doc = Doc_new(NULL, 0);
String *string = (String *)SSTR_WRAP_UTF8(test_string, strlen(test_string));
Doc_Store(doc, content, (Obj*)string);
Indexer_Add_Doc(indexer, doc, 1.0f);
DECREF(doc);
Indexer_Commit(indexer);
DECREF(indexer);
Searcher *searcher = (Searcher*)IxSearcher_new((Obj*)folder);
Obj *query = (Obj*)SSTR_WRAP_UTF8("NNN MMM", 7);
Highlighter *highlighter = Highlighter_new(searcher, query, content, 200);
Hits *hits = Searcher_Hits(searcher, query, 0, 10, NULL);
HitDoc *hit = Hits_Next(hits);
String *excerpt = Highlighter_Create_Excerpt(highlighter, hit);
String *mmm = (String*)SSTR_WRAP_UTF8("MMM", 3);
String *nnn = (String*)SSTR_WRAP_UTF8("NNN", 3);
TEST_TRUE(runner, Str_Find(excerpt, mmm) >= 0 || Str_Find(excerpt, nnn) >= 0,
"Sentence boundary algo doesn't chop terms");
DECREF(excerpt);
DECREF(hit);
DECREF(hits);
DECREF(highlighter);
DECREF(searcher);
DECREF(folder);
DECREF(schema);
}
static void
test_Close(TestBatchRunner *runner) {
RAMFolder *folder = RAMFolder_new(NULL);
RAMFolder_Close(folder);
PASS(runner, "Close() concludes without incident");
RAMFolder_Close(folder);
RAMFolder_Close(folder);
PASS(runner, "Calling Close() multiple times is safe");
DECREF(folder);
}
static void
test_Set_Path_and_Get_Path(TestBatch *batch)
{
Folder *folder = (Folder*)RAMFolder_new(&foo);
TEST_TRUE(batch, CB_Equals(Folder_Get_Path(folder), (Obj*)&foo),
"Get_Path");
Folder_Set_Path(folder, &bar);
TEST_TRUE(batch, CB_Equals(Folder_Get_Path(folder), (Obj*)&bar),
"Set_Path");
DECREF(folder);
}
static void
test_Delete_Tree(TestBatch *batch)
{
Folder *folder = (Folder*)RAMFolder_new(NULL);
FileHandle *fh;
bool_t result;
// Create tree to be deleted.
Folder_MkDir(folder, &foo);
Folder_MkDir(folder, &foo_bar);
Folder_MkDir(folder, &foo_bar_baz);
fh = Folder_Open_FileHandle(folder, &foo_bar_baz_boffo,
FH_CREATE | FH_WRITE_ONLY);
DECREF(fh);
// Create bystanders.
Folder_MkDir(folder, &bar);
fh = Folder_Open_FileHandle(folder, &baz, FH_CREATE | FH_WRITE_ONLY);
DECREF(fh);
result = Folder_Delete_Tree(folder, &foo);
TEST_TRUE(batch, result, "Delete_Tree() succeeded");
TEST_FALSE(batch, Folder_Exists(folder, &foo), "Tree really gone");
TEST_TRUE(batch, Folder_Exists(folder, &bar),
"local dir with same name as nested dir left intact");
TEST_TRUE(batch, Folder_Exists(folder, &baz),
"local file with same name as nested dir left intact");
// Kill off the bystanders.
result = Folder_Delete_Tree(folder, &bar);
TEST_TRUE(batch, result, "Delete_Tree() on empty dir");
result = Folder_Delete_Tree(folder, &baz);
TEST_TRUE(batch, result, "Delete_Tree() on file");
// Create new tree to be deleted.
Folder_MkDir(folder, &foo);
Folder_MkDir(folder, &foo_bar);
Folder_MkDir(folder, &foo_bar_baz);
fh = Folder_Open_FileHandle(folder, &foo_bar_baz_boffo,
FH_CREATE | FH_WRITE_ONLY);
DECREF(fh);
// Remove tree in subdir.
result = Folder_Delete_Tree(folder, &foo_bar);
TEST_TRUE(batch, result, "Delete_Tree() of subdir succeeded");
TEST_FALSE(batch, Folder_Exists(folder, &foo_bar),
"subdir really gone");
TEST_TRUE(batch, Folder_Exists(folder, &foo),
"enclosing dir left intact");
DECREF(folder);
}
static Folder*
S_folder_with_contents() {
RAMFolder *folder = RAMFolder_new(seg_1);
OutStream *foo_out = RAMFolder_Open_Out(folder, foo);
OutStream *bar_out = RAMFolder_Open_Out(folder, bar);
OutStream_Write_Bytes(foo_out, "foo", 3);
OutStream_Write_Bytes(bar_out, "bar", 3);
OutStream_Close(foo_out);
OutStream_Close(bar_out);
DECREF(foo_out);
DECREF(bar_out);
return (Folder*)folder;
}
static void
test_all(TestBatchRunner *runner) {
RAMFolder *folder = RAMFolder_new(NULL);
String *foo = SSTR_WRAP_C("foo");
String *boffo = SSTR_WRAP_C("boffo");
String *foo_boffo = SSTR_WRAP_C("foo/boffo");
bool saw_foo = false;
bool saw_boffo = false;
bool foo_was_dir = false;
bool boffo_was_dir = false;
int count = 0;
// Set up folder contents.
RAMFolder_MkDir(folder, foo);
FileHandle *fh = RAMFolder_Open_FileHandle(folder, boffo,
FH_CREATE | FH_WRITE_ONLY);
DECREF(fh);
fh = RAMFolder_Open_FileHandle(folder, foo_boffo,
FH_CREATE | FH_WRITE_ONLY);
DECREF(fh);
RAMDirHandle *dh = RAMDH_new(folder);
while (RAMDH_Next(dh)) {
count++;
String *entry = RAMDH_Get_Entry(dh);
if (Str_Equals(entry, (Obj*)foo)) {
saw_foo = true;
foo_was_dir = RAMDH_Entry_Is_Dir(dh);
}
else if (Str_Equals(entry, (Obj*)boffo)) {
saw_boffo = true;
boffo_was_dir = RAMDH_Entry_Is_Dir(dh);
}
DECREF(entry);
}
TEST_INT_EQ(runner, 2, count, "correct number of entries");
TEST_TRUE(runner, saw_foo, "Directory was iterated over");
TEST_TRUE(runner, foo_was_dir,
"Dir correctly identified by Entry_Is_Dir");
TEST_TRUE(runner, saw_boffo, "File was iterated over");
TEST_FALSE(runner, boffo_was_dir,
"File correctly identified by Entry_Is_Dir");
uint32_t refcount = REFCOUNT_NN(folder);
RAMDH_Close(dh);
TEST_INT_EQ(runner, REFCOUNT_NN(folder), refcount - 1,
"Folder reference released by Close()");
DECREF(dh);
DECREF(folder);
}
static Folder*
S_folder_with_contents() {
RAMFolder *folder = RAMFolder_new(seg_1);
OutStream *foo_out = RAMFolder_Open_Out(folder, foo);
OutStream *bar_out = RAMFolder_Open_Out(folder, bar);
OutStream_Write_Bytes(foo_out, "foo", 3);
OutStream_Write_Bytes(bar_out, "bar", 3);
OutStream_Close(foo_out);
OutStream_Close(bar_out);
DECREF(foo_out);
DECREF(bar_out);
String *empty = SSTR_BLANK();
RAMFolder_Consolidate(folder, empty);
return (Folder*)folder;
}
static void
test_spew_and_slurp(TestBatch *batch) {
Obj *dump = S_make_dump();
Folder *folder = (Folder*)RAMFolder_new(NULL);
CharBuf *foo = (CharBuf*)ZCB_WRAP_STR("foo", 3);
bool_t result = Json_spew_json(dump, folder, foo);
TEST_TRUE(batch, result, "spew_json returns true on success");
TEST_TRUE(batch, Folder_Exists(folder, foo),
"spew_json wrote file");
Obj *got = Json_slurp_json(folder, foo);
TEST_TRUE(batch, got && Obj_Equals(dump, got),
"Round trip through spew_json and slurp_json");
DECREF(got);
Err_set_error(NULL);
result = Json_spew_json(dump, folder, foo);
TEST_FALSE(batch, result, "Can't spew_json when file exists");
TEST_TRUE(batch, Err_get_error() != NULL,
"Failed spew_json sets Err_error");
Err_set_error(NULL);
CharBuf *bar = (CharBuf*)ZCB_WRAP_STR("bar", 3);
got = Json_slurp_json(folder, bar);
TEST_TRUE(batch, got == NULL,
"slurp_json returns NULL when file doesn't exist");
TEST_TRUE(batch, Err_get_error() != NULL,
"Failed slurp_json sets Err_error");
CharBuf *boffo = (CharBuf*)ZCB_WRAP_STR("boffo", 5);
FileHandle *fh
= Folder_Open_FileHandle(folder, boffo, FH_CREATE | FH_WRITE_ONLY);
FH_Write(fh, "garbage", 7);
DECREF(fh);
Err_set_error(NULL);
got = Json_slurp_json(folder, boffo);
TEST_TRUE(batch, got == NULL,
"slurp_json returns NULL when file doesn't contain valid JSON");
TEST_TRUE(batch, Err_get_error() != NULL,
"Failed slurp_json sets Err_error");
DECREF(got);
DECREF(dump);
DECREF(folder);
}
bool_t
RAMFolder_local_mkdir(RAMFolder *self, const CharBuf *name)
{
if (Hash_Fetch(self->entries, (Obj*)name)) {
Err_set_error(Err_new(CB_newf(
"Can't MkDir, '%o' already exists", name)));
return false;
}
else {
CharBuf *fullpath = S_fullpath(self, name);
Hash_Store(self->entries, (Obj*)name,
(Obj*)RAMFolder_new(fullpath));
DECREF(fullpath);
return true;
}
}
static void
test_Local_Exists(TestBatchRunner *runner) {
RAMFolder *folder = RAMFolder_new(NULL);
FileHandle *fh = RAMFolder_Open_FileHandle(folder, boffo,
FH_CREATE | FH_WRITE_ONLY);
DECREF(fh);
RAMFolder_Local_MkDir(folder, foo);
TEST_TRUE(runner, RAMFolder_Local_Exists(folder, boffo),
"Local_Exists() returns true for file");
TEST_TRUE(runner, RAMFolder_Local_Exists(folder, foo),
"Local_Exists() returns true for dir");
TEST_FALSE(runner, RAMFolder_Local_Exists(folder, bar),
"Local_Exists() returns false for non-existent entry");
DECREF(folder);
}
static void
test_MkDir_and_Is_Directory(TestBatch *batch)
{
Folder *folder = (Folder*)RAMFolder_new(NULL);
FileHandle *fh;
TEST_FALSE(batch, Folder_Is_Directory(folder, &foo),
"Is_Directory() false for non-existent entry");
TEST_TRUE(batch, Folder_MkDir(folder, &foo),
"MkDir returns true on success");
TEST_TRUE(batch, Folder_Is_Directory(folder, &foo),
"Is_Directory() true for local folder");
TEST_FALSE(batch, Folder_Is_Directory(folder, &foo_bar_baz),
"Is_Directory() false for non-existent deeply nested dir");
Err_set_error(NULL);
TEST_FALSE(batch, Folder_MkDir(folder, &foo_bar_baz),
"MkDir for deeply nested dir fails");
TEST_TRUE(batch, Err_get_error() != NULL,
"MkDir for deeply nested dir sets Err_error");
TEST_TRUE(batch, Folder_MkDir(folder, &foo_bar),
"MkDir for nested dir");
TEST_TRUE(batch, Folder_Is_Directory(folder, &foo_bar),
"Is_Directory() true for nested dir");
Err_set_error(NULL);
TEST_FALSE(batch, Folder_MkDir(folder, &foo_bar),
"Overwrite dir with MkDir fails");
TEST_TRUE(batch, Err_get_error() != NULL,
"Overwrite dir with MkDir sets Err_error");
fh = Folder_Open_FileHandle(folder, &foo_boffo,
FH_CREATE | FH_WRITE_ONLY);
DECREF(fh);
Err_set_error(NULL);
TEST_FALSE(batch, Folder_MkDir(folder, &foo_boffo),
"Overwrite file with MkDir fails");
TEST_TRUE(batch, Err_get_error() != NULL,
"Overwrite file with MkDir sets Err_error");
TEST_FALSE(batch, Folder_Is_Directory(folder, &foo_boffo),
"Is_Directory() false for nested file");
DECREF(folder);
}
static void
test_Slurp_File(TestBatch *batch)
{
Folder *folder = (Folder*)RAMFolder_new(NULL);
FileHandle *fh = Folder_Open_FileHandle(folder, &foo,
FH_CREATE | FH_WRITE_ONLY);
ByteBuf *contents;
FH_Write(fh, "stuff", 5);
FH_Close(fh);
DECREF(fh);
contents = Folder_Slurp_File(folder, &foo);
TEST_TRUE(batch, BB_Equals_Bytes(contents, "stuff", 5), "Slurp_File");
DECREF(contents);
DECREF(folder);
}
static void
test_Local_Find_Folder(TestBatchRunner *runner) {
RAMFolder *folder = RAMFolder_new(NULL);
RAMFolder *local;
FileHandle *fh;
RAMFolder_MkDir(folder, foo);
RAMFolder_MkDir(folder, foo_bar);
fh = RAMFolder_Open_FileHandle(folder, boffo,
FH_CREATE | FH_WRITE_ONLY);
DECREF(fh);
fh = RAMFolder_Open_FileHandle(folder, foo_boffo,
FH_CREATE | FH_WRITE_ONLY);
DECREF(fh);
local = (RAMFolder*)RAMFolder_Local_Find_Folder(folder, nope);
TEST_TRUE(runner, local == NULL, "Non-existent entry yields NULL");
ZombieCharBuf *empty = ZCB_BLANK();
local = (RAMFolder*)RAMFolder_Local_Find_Folder(folder, (CharBuf*)empty);
TEST_TRUE(runner, local == NULL, "Empty string yields NULL");
local = (RAMFolder*)RAMFolder_Local_Find_Folder(folder, foo_bar);
TEST_TRUE(runner, local == NULL, "nested folder yields NULL");
local = (RAMFolder*)RAMFolder_Local_Find_Folder(folder, foo_boffo);
TEST_TRUE(runner, local == NULL, "nested file yields NULL");
local = (RAMFolder*)RAMFolder_Local_Find_Folder(folder, boffo);
TEST_TRUE(runner, local == NULL, "local file yields NULL");
local = (RAMFolder*)RAMFolder_Local_Find_Folder(folder, bar);
TEST_TRUE(runner, local == NULL, "name of nested folder yields NULL");
local = (RAMFolder*)RAMFolder_Local_Find_Folder(folder, foo);
TEST_TRUE(runner,
local
&& RAMFolder_Is_A(local, RAMFOLDER)
&& CB_Equals_Str(RAMFolder_Get_Path(local), "foo", 3),
"Find local directory");
DECREF(folder);
}
static void
test_Open_Out(TestBatch *batch)
{
Folder *folder = (Folder*)RAMFolder_new(NULL);
OutStream *outstream;
Folder_MkDir(folder, &foo);
outstream = Folder_Open_Out(folder, &boffo);
TEST_TRUE(batch, outstream && OutStream_Is_A(outstream, OUTSTREAM),
"Open_Out");
DECREF(outstream);
outstream = Folder_Open_Out(folder, &foo_boffo);
TEST_TRUE(batch, outstream && OutStream_Is_A(outstream, OUTSTREAM),
"Open_Out for nested file");
DECREF(outstream);
Err_set_error(NULL);
outstream = Folder_Open_Out(folder, &boffo);
TEST_TRUE(batch, outstream == NULL,
"Open_OutStream on existing file fails");
TEST_TRUE(batch, Err_get_error() != NULL,
"Open_Out on existing file sets Err_error");
Err_set_error(NULL);
outstream = Folder_Open_Out(folder, &foo);
TEST_TRUE(batch, outstream == NULL,
"Open_OutStream on existing dir path fails");
TEST_TRUE(batch, Err_get_error() != NULL,
"Open_Out on existing dir name sets Err_error");
Err_set_error(NULL);
outstream = Folder_Open_Out(folder, &foo_bar_baz_boffo);
TEST_TRUE(batch, outstream == NULL,
"Open_Out for entry within non-existent dir fails");
TEST_TRUE(batch, Err_get_error() != NULL,
"Open_Out for entry within non-existent dir sets Err_error");
DECREF(folder);
}
static void
test_Open_In(TestBatch *batch)
{
Folder *folder = (Folder*)RAMFolder_new(NULL);
FileHandle *fh;
InStream *instream;
Folder_MkDir(folder, &foo);
Folder_MkDir(folder, &foo_bar);
fh = Folder_Open_FileHandle(folder, &boffo, FH_CREATE | FH_WRITE_ONLY);
DECREF(fh);
fh = Folder_Open_FileHandle(folder, &foo_boffo, FH_CREATE | FH_WRITE_ONLY);
DECREF(fh);
instream = Folder_Open_In(folder, &boffo);
TEST_TRUE(batch, instream && InStream_Is_A(instream, INSTREAM),
"Open_In");
DECREF(instream);
instream = Folder_Open_In(folder, &foo_boffo);
TEST_TRUE(batch, instream && InStream_Is_A(instream, INSTREAM),
"Open_In for nested file");
DECREF(instream);
Err_set_error(NULL);
instream = Folder_Open_In(folder, &foo);
TEST_TRUE(batch, instream == NULL,
"Open_InStream on existing dir path fails");
TEST_TRUE(batch, Err_get_error() != NULL,
"Open_In on existing dir name sets Err_error");
Err_set_error(NULL);
instream = Folder_Open_In(folder, &foo_bar_baz_boffo);
TEST_TRUE(batch, instream == NULL,
"Open_In for entry within non-existent dir fails");
TEST_TRUE(batch, Err_get_error() != NULL,
"Open_In for entry within non-existent dir sets Err_error");
DECREF(folder);
}
static void
test_Local_Open_FileHandle(TestBatchRunner *runner) {
RAMFolder *folder = RAMFolder_new(NULL);
FileHandle *fh;
fh = RAMFolder_Local_Open_FileHandle(folder, boffo,
FH_CREATE | FH_WRITE_ONLY);
TEST_TRUE(runner, fh && FH_Is_A(fh, RAMFILEHANDLE),
"opened FileHandle");
DECREF(fh);
fh = RAMFolder_Local_Open_FileHandle(folder, boffo,
FH_CREATE | FH_WRITE_ONLY);
TEST_TRUE(runner, fh && FH_Is_A(fh, RAMFILEHANDLE),
"opened FileHandle for append");
DECREF(fh);
Err_set_error(NULL);
fh = RAMFolder_Local_Open_FileHandle(folder, boffo,
FH_CREATE | FH_WRITE_ONLY | FH_EXCLUSIVE);
TEST_TRUE(runner, fh == NULL, "FH_EXLUSIVE flag prevents open");
TEST_TRUE(runner, Err_get_error() != NULL,
"failure due to FH_EXLUSIVE flag sets Err_error");
fh = RAMFolder_Local_Open_FileHandle(folder, boffo, FH_READ_ONLY);
TEST_TRUE(runner, fh && FH_Is_A(fh, RAMFILEHANDLE),
"opened FileHandle for reading");
DECREF(fh);
Err_set_error(NULL);
fh = RAMFolder_Local_Open_FileHandle(folder, nope, FH_READ_ONLY);
TEST_TRUE(runner, fh == NULL,
"Can't open non-existent file for reading");
TEST_TRUE(runner, Err_get_error() != NULL,
"Opening non-existent file for reading sets Err_error");
DECREF(folder);
}
static void
test_List(TestBatch *batch)
{
Folder *folder = (Folder*)RAMFolder_new(NULL);
FileHandle *fh;
VArray *list;
CharBuf *elem;
Folder_MkDir(folder, &foo);
Folder_MkDir(folder, &foo_bar);
Folder_MkDir(folder, &foo_bar_baz);
fh = Folder_Open_FileHandle(folder, &boffo, FH_CREATE | FH_WRITE_ONLY);
DECREF(fh);
fh = Folder_Open_FileHandle(folder, &banana, FH_CREATE | FH_WRITE_ONLY);
DECREF(fh);
list = Folder_List(folder, NULL);
VA_Sort(list, NULL, NULL);
TEST_INT_EQ(batch, VA_Get_Size(list), 3, "List");
elem = (CharBuf*)DOWNCAST(VA_Fetch(list, 0), CHARBUF);
TEST_TRUE(batch, elem && CB_Equals(elem, (Obj*)&banana),
"List first file");
elem = (CharBuf*)DOWNCAST(VA_Fetch(list, 1), CHARBUF);
TEST_TRUE(batch, elem && CB_Equals(elem, (Obj*)&boffo),
"List second file");
elem = (CharBuf*)DOWNCAST(VA_Fetch(list, 2), CHARBUF);
TEST_TRUE(batch, elem && CB_Equals(elem, (Obj*)&foo), "List dir");
DECREF(list);
list = Folder_List(folder, &foo_bar);
TEST_INT_EQ(batch, VA_Get_Size(list), 1, "List subdirectory contents");
elem = (CharBuf*)DOWNCAST(VA_Fetch(list, 0), CHARBUF);
TEST_TRUE(batch, elem && CB_Equals(elem, (Obj*)&baz),
"Just the filename");
DECREF(list);
DECREF(folder);
}
static void
test_path_handling(TestBatchRunner *runner) {
Snapshot *snapshot = Snapshot_new();
Folder *folder = (Folder*)RAMFolder_new(NULL);
String *snap = (String*)SSTR_WRAP_UTF8("snap", 4);
String *crackle = (String*)SSTR_WRAP_UTF8("crackle", 7);
Snapshot_Write_File(snapshot, folder, snap);
TEST_TRUE(runner, Str_Equals(snap, (Obj*)Snapshot_Get_Path(snapshot)),
"Write_File() sets path as a side effect");
Folder_Rename(folder, snap, crackle);
Snapshot_Read_File(snapshot, folder, crackle);
TEST_TRUE(runner, Str_Equals(crackle, (Obj*)Snapshot_Get_Path(snapshot)),
"Read_File() sets path as a side effect");
Snapshot_Set_Path(snapshot, snap);
TEST_TRUE(runner, Str_Equals(snap, (Obj*)Snapshot_Get_Path(snapshot)),
"Set_Path()");
DECREF(folder);
DECREF(snapshot);
}
