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_Set_and_Get(TestBatch *batch) {
unsigned i, max;
const uint32_t three = 3;
const uint32_t seventeen = 17;
BitVector *bit_vec = BitVec_new(8);
BitVec_Set(bit_vec, three);
TEST_TRUE(batch, BitVec_Get_Capacity(bit_vec) < seventeen,
"set below cap");
BitVec_Set(bit_vec, seventeen);
TEST_TRUE(batch, BitVec_Get_Capacity(bit_vec) > seventeen,
"set above cap causes BitVector to grow");
for (i = 0, max = BitVec_Get_Capacity(bit_vec); i < max; i++) {
if (i == three || i == seventeen) {
TEST_TRUE(batch, BitVec_Get(bit_vec, i), "set/get %d", i);
}
else {
TEST_FALSE(batch, BitVec_Get(bit_vec, i), "get %d", i);
}
}
TEST_FALSE(batch, BitVec_Get(bit_vec, i), "out of range get");
DECREF(bit_vec);
}
static void
test_Set_and_Get(TestBatchRunner *runner) {
const size_t three = 3;
const size_t seventeen = 17;
BitVector *bit_vec = BitVec_new(8);
BitVec_Set(bit_vec, three);
TEST_TRUE(runner, BitVec_Get_Capacity(bit_vec) < seventeen,
"set below cap");
BitVec_Set(bit_vec, seventeen);
TEST_TRUE(runner, BitVec_Get_Capacity(bit_vec) > seventeen,
"set above cap causes BitVector to grow");
size_t i, max;
for (i = 0, max = BitVec_Get_Capacity(bit_vec); i < max; i++) {
if (i == three || i == seventeen) {
TEST_TRUE(runner, BitVec_Get(bit_vec, i), "set/get %u", (unsigned)i);
}
else {
TEST_FALSE(runner, BitVec_Get(bit_vec, i), "get %u", (unsigned)i);
}
}
TEST_FALSE(runner, BitVec_Get(bit_vec, i), "out of range get");
DECREF(bit_vec);
}
static void
test_Dump_Load_and_Equals(TestBatchRunner *runner) {
Query *a_leaf = (Query*)TestUtils_make_leaf_query(NULL, "a");
Query *b_leaf = (Query*)TestUtils_make_leaf_query(NULL, "b");
NOTQuery *query = NOTQuery_new(a_leaf);
NOTQuery *kids_differ = NOTQuery_new(b_leaf);
NOTQuery *boost_differs = NOTQuery_new(a_leaf);
Obj *dump = (Obj*)NOTQuery_Dump(query);
NOTQuery *clone = (NOTQuery*)Obj_Load(dump, dump);
TEST_FALSE(runner, NOTQuery_Equals(query, (Obj*)kids_differ),
"Different kids spoil Equals");
TEST_TRUE(runner, NOTQuery_Equals(query, (Obj*)boost_differs),
"Equals with identical boosts");
NOTQuery_Set_Boost(boost_differs, 1.5);
TEST_FALSE(runner, NOTQuery_Equals(query, (Obj*)boost_differs),
"Different boost spoils Equals");
TEST_TRUE(runner, NOTQuery_Equals(query, (Obj*)clone),
"Dump => Load round trip");
DECREF(a_leaf);
DECREF(b_leaf);
DECREF(query);
DECREF(kids_differ);
DECREF(boost_differs);
DECREF(dump);
DECREF(clone);
}
static void
test_Equals(TestBatchRunner *runner) {
ByteBuf *bb = BB_new_bytes("foo", 4); // Include terminating NULL.
{
ByteBuf *other = BB_new_bytes("foo", 4);
TEST_TRUE(runner, BB_Equals(bb, (Obj*)other), "Equals");
DECREF(other);
}
TEST_TRUE(runner, BB_Equals_Bytes(bb, "foo", 4), "Equals_Bytes");
TEST_FALSE(runner, BB_Equals_Bytes(bb, "foo", 3),
"Equals_Bytes spoiled by different size");
TEST_FALSE(runner, BB_Equals_Bytes(bb, "bar", 4),
"Equals_Bytes spoiled by different content");
{
ByteBuf *other = BB_new_bytes("foo", 3);
TEST_FALSE(runner, BB_Equals(bb, (Obj*)other),
"Different size spoils Equals");
DECREF(other);
}
{
ByteBuf *other = BB_new_bytes("bar", 4);
TEST_UINT_EQ(runner, BB_Get_Size(bb), BB_Get_Size(other),
"same length");
TEST_FALSE(runner, BB_Equals(bb, (Obj*)other),
"Different content spoils Equals");
DECREF(other);
}
DECREF(bb);
}
static void
test_Contains_and_Find(TestBatchRunner *runner) {
String *string;
String *substring = S_get_str("foo");
string = S_get_str("");
TEST_FALSE(runner, Str_Contains(string, substring),
"Not contained in empty string");
TEST_INT_EQ(runner, S_find(string, substring), -1,
"Not found in empty string");
DECREF(string);
string = S_get_str("foo");
TEST_TRUE(runner, Str_Contains(string, substring),
"Contained in complete string");
TEST_INT_EQ(runner, S_find(string, substring), 0, "Find complete string");
DECREF(string);
string = S_get_str("afoo");
TEST_TRUE(runner, Str_Contains(string, substring),
"Contained after first");
TEST_INT_EQ(runner, S_find(string, substring), 1, "Find after first");
String *prefix = Str_SubString(string, 0, 3);
TEST_FALSE(runner, Str_Contains(prefix, substring), "Don't overrun");
DECREF(prefix);
DECREF(string);
string = S_get_str("afood");
TEST_TRUE(runner, Str_Contains(string, substring), "Contained in middle");
TEST_INT_EQ(runner, S_find(string, substring), 1, "Find in middle");
DECREF(string);
DECREF(substring);
}
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_Dump_Load_and_Equals(TestBatchRunner *runner) {
TermQuery *query = TestUtils_make_term_query("content", "foo");
TermQuery *field_differs = TestUtils_make_term_query("stuff", "foo");
TermQuery *term_differs = TestUtils_make_term_query("content", "bar");
TermQuery *boost_differs = TestUtils_make_term_query("content", "foo");
Obj *dump = (Obj*)TermQuery_Dump(query);
TermQuery *clone = (TermQuery*)TermQuery_Load(term_differs, dump);
TEST_FALSE(runner, TermQuery_Equals(query, (Obj*)field_differs),
"Equals() false with different field");
TEST_FALSE(runner, TermQuery_Equals(query, (Obj*)term_differs),
"Equals() false with different term");
TermQuery_Set_Boost(boost_differs, 0.5);
TEST_FALSE(runner, TermQuery_Equals(query, (Obj*)boost_differs),
"Equals() false with different boost");
TEST_TRUE(runner, TermQuery_Equals(query, (Obj*)clone),
"Dump => Load round trip");
DECREF(query);
DECREF(term_differs);
DECREF(field_differs);
DECREF(boost_differs);
DECREF(dump);
DECREF(clone);
}
static void
test_Equals(TestBatchRunner *runner) {
ByteBuf *wanted = BB_new_bytes("foo", 4); // Include terminating NULL.
ByteBuf *got = BB_new_bytes("foo", 4);
TEST_TRUE(runner, BB_Equals(wanted, (Obj*)got), "Equals");
TEST_INT_EQ(runner, BB_Hash_Sum(got), BB_Hash_Sum(wanted), "Hash_Sum");
TEST_TRUE(runner, BB_Equals_Bytes(got, "foo", 4), "Equals_Bytes");
TEST_FALSE(runner, BB_Equals_Bytes(got, "foo", 3),
"Equals_Bytes spoiled by different size");
TEST_FALSE(runner, BB_Equals_Bytes(got, "bar", 4),
"Equals_Bytes spoiled by different content");
BB_Set_Size(got, 3);
TEST_FALSE(runner, BB_Equals(wanted, (Obj*)got),
"Different size spoils Equals");
TEST_FALSE(runner, BB_Hash_Sum(got) == BB_Hash_Sum(wanted),
"Different size spoils Hash_Sum (probably -- at least this one)");
BB_Mimic_Bytes(got, "bar", 4);
TEST_INT_EQ(runner, BB_Get_Size(wanted), BB_Get_Size(got),
"same length");
TEST_FALSE(runner, BB_Equals(wanted, (Obj*)got),
"Different content spoils Equals");
DECREF(got);
DECREF(wanted);
}
static void
test_Dump_Load_and_Equals(TestBatchRunner *runner) {
Normalizer *normalizer[4];
String *NFC = SSTR_WRAP_C("NFC");
String *NFKC = SSTR_WRAP_C("NFKC");
normalizer[0] = Normalizer_new(NFKC, true, false);
normalizer[1] = Normalizer_new(NFC, true, false);
normalizer[2] = Normalizer_new(NFKC, false, false);
normalizer[3] = Normalizer_new(NFKC, true, true);
TEST_FALSE(runner,
Normalizer_Equals(normalizer[0], (Obj*)normalizer[1]),
"Equals() false with different normalization form");
TEST_FALSE(runner,
Normalizer_Equals(normalizer[0], (Obj*)normalizer[2]),
"Equals() false with different case_fold flag");
TEST_FALSE(runner,
Normalizer_Equals(normalizer[0], (Obj*)normalizer[3]),
"Equals() false with different strip_accents flag");
for (int i = 0; i < 4; ++i) {
Obj *dump = (Obj*)Normalizer_Dump(normalizer[i]);
Normalizer *clone = (Normalizer*)Normalizer_Load(normalizer[i], dump);
TEST_TRUE(runner,
Normalizer_Equals(normalizer[i], (Obj*)clone),
"Dump => Load round trip");
DECREF(normalizer[i]);
DECREF(dump);
DECREF(clone);
}
}
static void
test_Dump_Load_and_Equals(TestBatch *batch)
{
Query *a_leaf = (Query*)TestUtils_make_leaf_query(NULL, "a");
Query *b_leaf = (Query*)TestUtils_make_leaf_query(NULL, "b");
Query *c_leaf = (Query*)TestUtils_make_leaf_query(NULL, "c");
RequiredOptionalQuery *query = ReqOptQuery_new(a_leaf, b_leaf);
RequiredOptionalQuery *kids_differ = ReqOptQuery_new(a_leaf, c_leaf);
RequiredOptionalQuery *boost_differs = ReqOptQuery_new(a_leaf, b_leaf);
Obj *dump = (Obj*)ReqOptQuery_Dump(query);
RequiredOptionalQuery *clone
= (RequiredOptionalQuery*)Obj_Load(dump, dump);
TEST_FALSE(batch, ReqOptQuery_Equals(query, (Obj*)kids_differ),
"Different kids spoil Equals");
TEST_TRUE(batch, ReqOptQuery_Equals(query, (Obj*)boost_differs),
"Equals with identical boosts");
ReqOptQuery_Set_Boost(boost_differs, 1.5);
TEST_FALSE(batch, ReqOptQuery_Equals(query, (Obj*)boost_differs),
"Different boost spoils Equals");
TEST_TRUE(batch, ReqOptQuery_Equals(query, (Obj*)clone),
"Dump => Load round trip");
DECREF(a_leaf);
DECREF(b_leaf);
DECREF(c_leaf);
DECREF(query);
DECREF(kids_differ);
DECREF(boost_differs);
DECREF(dump);
DECREF(clone);
}
static void
test_Consolidate(TestBatchRunner *runner) {
Folder *folder = S_folder_with_contents();
FileHandle *fh;
// Fake up detritus from failed consolidation.
fh = Folder_Open_FileHandle(folder, cf_file,
FH_CREATE | FH_WRITE_ONLY | FH_EXCLUSIVE);
DECREF(fh);
fh = Folder_Open_FileHandle(folder, cfmeta_temp,
FH_CREATE | FH_WRITE_ONLY | FH_EXCLUSIVE);
DECREF(fh);
CompoundFileWriter *cf_writer = CFWriter_new(folder);
CFWriter_Consolidate(cf_writer);
PASS(runner, "Consolidate completes despite leftover files");
DECREF(cf_writer);
TEST_TRUE(runner, Folder_Exists(folder, cf_file),
"cf.dat file written");
TEST_TRUE(runner, Folder_Exists(folder, cfmeta_file),
"cfmeta.json file written");
TEST_FALSE(runner, Folder_Exists(folder, foo),
"original file zapped");
TEST_FALSE(runner, Folder_Exists(folder, cfmeta_temp),
"detritus from failed consolidation zapped");
DECREF(folder);
}
void
test_parent (void)
{
void *ptr1;
void *ptr2;
void *ptr3;
TEST_FUNCTION ("nih_alloc_parent");
/* Check that nih_alloc_parent returns TRUE when the passed object
* is a child of the passed parent.
*/
TEST_FEATURE ("with child and parent");
ptr1 = nih_alloc (NULL, 10);
ptr2 = nih_alloc (ptr1, 10);
TEST_TRUE (nih_alloc_parent (ptr2, ptr1));
nih_free (ptr1);
/* Check that nih_alloc_parent returns TRUE when the passed object
* is a child of the NULL parent.
*/
TEST_FEATURE ("with child and NULL parent");
ptr1 = nih_alloc (NULL, 10);
TEST_TRUE (nih_alloc_parent (ptr1, NULL));
nih_free (ptr1);
/* Check that nih_alloc_parent returns FALSE when the passed object
* is a child but not of the passed parent.
*/
TEST_FEATURE ("with child and wrong parent");
ptr1 = nih_alloc (NULL, 10);
ptr2 = nih_alloc (ptr1, 10);
ptr3 = nih_alloc (NULL, 10);
TEST_FALSE (nih_alloc_parent (ptr2, ptr3));
nih_free (ptr1);
nih_free (ptr3);
/* Check that nih_alloc_parent returns FALSE when the passed object
* is an orphan.
*/
TEST_FEATURE ("with orphan");
ptr1 = nih_alloc (NULL, 10);
ptr2 = nih_alloc (NULL, 10);
TEST_FALSE (nih_alloc_parent (ptr2, ptr1));
nih_free (ptr1);
nih_free (ptr2);
}
static void
test_Read_Write(TestBatchRunner *runner) {
FSFileHandle *fh;
const char *foo = "foo";
const char *bar = "bar";
char buffer[12];
char *buf = buffer;
String *test_filename = SSTR_WRAP_C("_fstest");
S_remove(test_filename);
fh = FSFH_open(test_filename,
FH_CREATE | FH_WRITE_ONLY | FH_EXCLUSIVE);
TEST_TRUE(runner, FSFH_Length(fh) == INT64_C(0), "Length initially 0");
TEST_TRUE(runner, FSFH_Write(fh, foo, 3), "Write returns success");
TEST_TRUE(runner, FSFH_Length(fh) == INT64_C(3), "Length after Write");
TEST_TRUE(runner, FSFH_Write(fh, bar, 3), "Write returns success");
TEST_TRUE(runner, FSFH_Length(fh) == INT64_C(6), "Length after 2 Writes");
Err_set_error(NULL);
TEST_FALSE(runner, FSFH_Read(fh, buf, 0, 2),
"Reading from a write-only handle returns false");
TEST_TRUE(runner, Err_get_error() != NULL,
"Reading from a write-only handle sets error");
if (!FSFH_Close(fh)) { RETHROW(INCREF(Err_get_error())); }
DECREF(fh);
// Reopen for reading.
Err_set_error(NULL);
fh = FSFH_open(test_filename, FH_READ_ONLY);
TEST_TRUE(runner, FSFH_Length(fh) == INT64_C(6), "Length on Read");
TEST_TRUE(runner, FSFH_Read(fh, buf, 0, 6), "Read returns success");
TEST_TRUE(runner, strncmp(buf, "foobar", 6) == 0, "Read/Write");
TEST_TRUE(runner, FSFH_Read(fh, buf, 2, 3), "Read returns success");
TEST_TRUE(runner, strncmp(buf, "oba", 3) == 0, "Read with offset");
Err_set_error(NULL);
TEST_FALSE(runner, FSFH_Read(fh, buf, -1, 4),
"Read() with a negative offset returns false");
TEST_TRUE(runner, Err_get_error() != NULL,
"Read() with a negative offset sets error");
Err_set_error(NULL);
TEST_FALSE(runner, FSFH_Read(fh, buf, 6, 1),
"Read() past EOF returns false");
TEST_TRUE(runner, Err_get_error() != NULL,
"Read() past EOF sets error");
Err_set_error(NULL);
TEST_FALSE(runner, FSFH_Write(fh, foo, 3),
"Writing to a read-only handle returns false");
TEST_TRUE(runner, Err_get_error() != NULL,
"Writing to a read-only handle sets error");
DECREF(fh);
S_remove(test_filename);
}
static void
test_protect_symlinks(TestBatchRunner *runner) {
#ifdef ENABLE_SYMLINK_TESTS
FSFolder *folder = (FSFolder*)S_set_up();
String *foo = (String*)SSTR_WRAP_UTF8("foo", 3);
String *bar = (String*)SSTR_WRAP_UTF8("bar", 3);
String *foo_boffo = (String*)SSTR_WRAP_UTF8("foo/boffo", 9);
FSFolder_MkDir(folder, foo);
FSFolder_MkDir(folder, bar);
OutStream *outstream = FSFolder_Open_Out(folder, foo_boffo);
DECREF(outstream);
if (!S_create_test_symlinks()) {
FAIL(runner, "symlink creation failed");
FAIL(runner, "symlink creation failed");
FAIL(runner, "symlink creation failed");
FAIL(runner, "symlink creation failed");
FAIL(runner, "symlink creation failed");
// Try to clean up anyway.
FSFolder_Delete_Tree(folder, foo);
FSFolder_Delete_Tree(folder, bar);
}
else {
VArray *list = FSFolder_List_R(folder, NULL);
bool saw_bazooka_boffo = false;
for (uint32_t i = 0, max = VA_Get_Size(list); i < max; i++) {
String *entry = (String*)VA_Fetch(list, i);
if (Str_Ends_With_Utf8(entry, "bazooka/boffo", 13)) {
saw_bazooka_boffo = true;
}
}
TEST_FALSE(runner, saw_bazooka_boffo,
"List_R() shouldn't follow symlinks");
DECREF(list);
TEST_TRUE(runner, FSFolder_Delete_Tree(folder, bar),
"Delete_Tree() returns true");
TEST_FALSE(runner, FSFolder_Exists(folder, bar),
"Tree is really gone");
TEST_TRUE(runner, FSFolder_Exists(folder, foo),
"Original folder sill there");
TEST_TRUE(runner, FSFolder_Exists(folder, foo_boffo),
"Delete_Tree() did not follow directory symlink");
FSFolder_Delete_Tree(folder, foo);
}
DECREF(folder);
S_tear_down();
#else
SKIP(runner, "Tests requiring symlink() disabled");
SKIP(runner, "Tests requiring symlink() disabled");
SKIP(runner, "Tests requiring symlink() disabled");
SKIP(runner, "Tests requiring symlink() disabled");
SKIP(runner, "Tests requiring symlink() disabled");
#endif // ENABLE_SYMLINK_TESTS
}
static void
test_Window(TestBatchRunner *runner) {
String *test_filename = SSTR_WRAP_C("_fstest");
FSFileHandle *fh;
FileWindow *window = FileWindow_new();
uint32_t i;
S_remove(test_filename);
fh = FSFH_open(test_filename,
FH_CREATE | FH_WRITE_ONLY | FH_EXCLUSIVE);
for (i = 0; i < 1024; i++) {
FSFH_Write(fh, "foo ", 4);
}
if (!FSFH_Close(fh)) { RETHROW(INCREF(Err_get_error())); }
// Reopen for reading.
DECREF(fh);
fh = FSFH_open(test_filename, FH_READ_ONLY);
if (!fh) { RETHROW(INCREF(Err_get_error())); }
Err_set_error(NULL);
TEST_FALSE(runner, FSFH_Window(fh, window, -1, 4),
"Window() with a negative offset returns false");
TEST_TRUE(runner, Err_get_error() != NULL,
"Window() with a negative offset sets error");
Err_set_error(NULL);
TEST_FALSE(runner, FSFH_Window(fh, window, 4000, 1000),
"Window() past EOF returns false");
TEST_TRUE(runner, Err_get_error() != NULL,
"Window() past EOF sets error");
TEST_TRUE(runner, FSFH_Window(fh, window, 1021, 2),
"Window() returns true");
const char *buf = FileWindow_Get_Buf(window);
int64_t offset = FileWindow_Get_Offset(window);
TEST_TRUE(runner,
strncmp(buf - offset + 1021, "oo", 2) == 0,
"Window()");
TEST_TRUE(runner, FSFH_Release_Window(fh, window),
"Release_Window() returns true");
TEST_TRUE(runner, FileWindow_Get_Buf(window) == NULL,
"Release_Window() resets buf");
TEST_INT_EQ(runner, FileWindow_Get_Offset(window), 0,
"Release_Window() resets offset");
TEST_INT_EQ(runner, FileWindow_Get_Len(window), 0,
"Release_Window() resets len");
DECREF(window);
DECREF(fh);
S_remove(test_filename);
}
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 void
test_Dump_Load_and_Equals(TestBatchRunner *runner) {
StandardTokenizer *tokenizer = StandardTokenizer_new();
Normalizer *normalizer = Normalizer_new(NULL, true, false);
FullTextType *type = FullTextType_new((Analyzer*)tokenizer);
FullTextType *other = FullTextType_new((Analyzer*)normalizer);
FullTextType *boost_differs = FullTextType_new((Analyzer*)tokenizer);
FullTextType *not_indexed = FullTextType_new((Analyzer*)tokenizer);
FullTextType *not_stored = FullTextType_new((Analyzer*)tokenizer);
FullTextType *highlightable = FullTextType_new((Analyzer*)tokenizer);
Obj *dump = (Obj*)FullTextType_Dump(type);
Obj *clone = Freezer_load(dump);
Obj *another_dump = (Obj*)FullTextType_Dump_For_Schema(type);
FullTextType_Set_Boost(boost_differs, 1.5);
FullTextType_Set_Indexed(not_indexed, false);
FullTextType_Set_Stored(not_stored, false);
FullTextType_Set_Highlightable(highlightable, true);
// (This step is normally performed by Schema_Load() internally.)
Hash_Store_Utf8((Hash*)another_dump, "analyzer", 8, INCREF(tokenizer));
FullTextType *another_clone = FullTextType_Load(type, another_dump);
TEST_FALSE(runner, FullTextType_Equals(type, (Obj*)boost_differs),
"Equals() false with different boost");
TEST_FALSE(runner, FullTextType_Equals(type, (Obj*)other),
"Equals() false with different Analyzer");
TEST_FALSE(runner, FullTextType_Equals(type, (Obj*)not_indexed),
"Equals() false with indexed => false");
TEST_FALSE(runner, FullTextType_Equals(type, (Obj*)not_stored),
"Equals() false with stored => false");
TEST_FALSE(runner, FullTextType_Equals(type, (Obj*)highlightable),
"Equals() false with highlightable => true");
TEST_TRUE(runner, FullTextType_Equals(type, (Obj*)clone),
"Dump => Load round trip");
TEST_TRUE(runner, FullTextType_Equals(type, (Obj*)another_clone),
"Dump_For_Schema => Load round trip");
DECREF(another_clone);
DECREF(dump);
DECREF(clone);
DECREF(another_dump);
DECREF(highlightable);
DECREF(not_stored);
DECREF(not_indexed);
DECREF(boost_differs);
DECREF(other);
DECREF(type);
DECREF(normalizer);
DECREF(tokenizer);
}
static void
test_is_whitespace(TestBatchRunner *runner) {
TEST_TRUE(runner, StrHelp_is_whitespace(' '), "space is whitespace");
TEST_TRUE(runner, StrHelp_is_whitespace('\n'), "newline is whitespace");
TEST_TRUE(runner, StrHelp_is_whitespace('\t'), "tab is whitespace");
TEST_TRUE(runner, StrHelp_is_whitespace('\v'),
"vertical tab is whitespace");
TEST_TRUE(runner, StrHelp_is_whitespace(0x180E),
"Mongolian vowel separator is whitespace");
TEST_FALSE(runner, StrHelp_is_whitespace('a'), "'a' isn't whitespace");
TEST_FALSE(runner, StrHelp_is_whitespace(0), "NULL isn't whitespace");
TEST_FALSE(runner, StrHelp_is_whitespace(0x263A),
"Smiley isn't whitespace");
}
static void
test_Window(TestBatchRunner *runner) {
String *test_filename = (String*)SSTR_WRAP_UTF8("_fstest", 7);
FSFileHandle *fh;
FileWindow *window = FileWindow_new();
FileWindowIVARS *const window_ivars = FileWindow_IVARS(window);
uint32_t i;
remove(Str_Get_Ptr8(test_filename));
fh = FSFH_open(test_filename,
FH_CREATE | FH_WRITE_ONLY | FH_EXCLUSIVE);
for (i = 0; i < 1024; i++) {
FSFH_Write(fh, "foo ", 4);
}
if (!FSFH_Close(fh)) { RETHROW(INCREF(Err_get_error())); }
// Reopen for reading.
DECREF(fh);
fh = FSFH_open(test_filename, FH_READ_ONLY);
if (!fh) { RETHROW(INCREF(Err_get_error())); }
Err_set_error(NULL);
TEST_FALSE(runner, FSFH_Window(fh, window, -1, 4),
"Window() with a negative offset returns false");
TEST_TRUE(runner, Err_get_error() != NULL,
"Window() with a negative offset sets error");
Err_set_error(NULL);
TEST_FALSE(runner, FSFH_Window(fh, window, 4000, 1000),
"Window() past EOF returns false");
TEST_TRUE(runner, Err_get_error() != NULL,
"Window() past EOF sets error");
TEST_TRUE(runner, FSFH_Window(fh, window, 1021, 2),
"Window() returns true");
TEST_TRUE(runner,
strncmp(window_ivars->buf - window_ivars->offset + 1021, "oo", 2) == 0,
"Window()");
TEST_TRUE(runner, FSFH_Release_Window(fh, window),
"Release_Window() returns true");
TEST_TRUE(runner, window_ivars->buf == NULL, "Release_Window() resets buf");
TEST_TRUE(runner, window_ivars->offset == 0, "Release_Window() resets offset");
TEST_TRUE(runner, window_ivars->len == 0, "Release_Window() resets len");
DECREF(window);
DECREF(fh);
remove(Str_Get_Ptr8(test_filename));
}
static void
test_all(TestBatchRunner *runner) {
LockFreeRegistry *registry = LFReg_new(10);
StupidHashCharBuf *foo = StupidHashCharBuf_new("foo");
StupidHashCharBuf *bar = StupidHashCharBuf_new("bar");
StupidHashCharBuf *baz = StupidHashCharBuf_new("baz");
StupidHashCharBuf *foo_dupe = StupidHashCharBuf_new("foo");
TEST_TRUE(runner, LFReg_Register(registry, (Obj*)foo, (Obj*)foo),
"Register() returns true on success");
TEST_FALSE(runner,
LFReg_Register(registry, (Obj*)foo_dupe, (Obj*)foo_dupe),
"Can't Register() keys that test equal");
TEST_TRUE(runner, LFReg_Register(registry, (Obj*)bar, (Obj*)bar),
"Register() key with the same Hash_Sum but that isn't Equal");
TEST_TRUE(runner, LFReg_Fetch(registry, (Obj*)foo_dupe) == (Obj*)foo,
"Fetch()");
TEST_TRUE(runner, LFReg_Fetch(registry, (Obj*)bar) == (Obj*)bar,
"Fetch() again");
TEST_TRUE(runner, LFReg_Fetch(registry, (Obj*)baz) == NULL,
"Fetch() non-existent key returns NULL");
DECREF(foo_dupe);
DECREF(baz);
DECREF(bar);
DECREF(foo);
DECREF(registry);
}
void
test_freqfilepos(TestBatch *batch) {
TermInfo* tinfo = TInfo_new(10);
TInfo_Set_Post_FilePos(tinfo, 20);
TInfo_Set_Skip_FilePos(tinfo, 40);
TInfo_Set_Lex_FilePos(tinfo, 50);
TermInfo* cloned_tinfo = TInfo_Clone(tinfo);
TEST_FALSE(batch, Lucy_TInfo_Equals(tinfo, (lucy_Obj*)cloned_tinfo),"the clone should be a separate C struct");
TEST_INT_EQ(batch, TInfo_Get_Doc_Freq(tinfo), 10, "new sets doc_freq correctly" );
TEST_INT_EQ(batch, TInfo_Get_Doc_Freq(tinfo), 10, "... doc_freq cloned" );
TEST_INT_EQ(batch, TInfo_Get_Post_FilePos(tinfo), 20, "... post_filepos cloned" );
TEST_INT_EQ(batch, TInfo_Get_Skip_FilePos(tinfo), 40, "... skip_filepos cloned" );
TEST_INT_EQ(batch, TInfo_Get_Lex_FilePos(tinfo), 50, "... lex_filepos cloned" );
TInfo_Set_Doc_Freq(tinfo, 5);
TEST_INT_EQ(batch, TInfo_Get_Doc_Freq(tinfo), 5, "set/get doc_freq" );
TEST_INT_EQ(batch, TInfo_Get_Doc_Freq(cloned_tinfo), 10, "setting orig doesn't affect clone" );
TInfo_Set_Post_FilePos(tinfo, 15);
TEST_INT_EQ(batch, TInfo_Get_Post_FilePos(tinfo), 15, "set/get post_filepos" );
TInfo_Set_Skip_FilePos(tinfo, 35);
TEST_INT_EQ(batch, TInfo_Get_Skip_FilePos(tinfo), 35, "set/get skip_filepos" );
TInfo_Set_Lex_FilePos(tinfo, 45);
TEST_INT_EQ(batch, TInfo_Get_Lex_FilePos(tinfo), 45, "set/get lex_filepos" );
DECREF(tinfo);
DECREF(cloned_tinfo);
}
static void
test_Close(TestBatchRunner *runner) {
String *test_filename = SSTR_WRAP_C("_fstest");
FSFileHandle *fh;
S_remove(test_filename);
fh = FSFH_open(test_filename,
FH_CREATE | FH_WRITE_ONLY | FH_EXCLUSIVE);
TEST_TRUE(runner, FSFH_Close(fh), "Close returns true for write-only");
DECREF(fh);
// Simulate an OS error when closing the file descriptor. This
// approximates what would happen if, say, we run out of disk space.
S_remove(test_filename);
fh = FSFH_open(test_filename,
FH_CREATE | FH_WRITE_ONLY | FH_EXCLUSIVE);
#ifdef _MSC_VER
SKIP(runner, 2, "LUCY-155");
#else
int saved_fd = FSFH_Set_FD(fh, -1);
Err_set_error(NULL);
bool result = FSFH_Close(fh);
TEST_FALSE(runner, result, "Failed Close() returns false");
TEST_TRUE(runner, Err_get_error() != NULL,
"Failed Close() sets global error");
FSFH_Set_FD(fh, saved_fd);
#endif /* _MSC_VER */
DECREF(fh);
fh = FSFH_open(test_filename, FH_READ_ONLY);
TEST_TRUE(runner, FSFH_Close(fh), "Close returns true for read-only");
DECREF(fh);
S_remove(test_filename);
}
static void
test_Dump_Load_and_Equals(TestBatch *batch)
{
CharBuf *EN = (CharBuf*)ZCB_WRAP_STR("en", 2);
CharBuf *ES = (CharBuf*)ZCB_WRAP_STR("es", 2);
Stemmer *stemmer = Stemmer_new(EN);
Stemmer *other = Stemmer_new(ES);
Obj *dump = (Obj*)Stemmer_Dump(stemmer);
Obj *other_dump = (Obj*)Stemmer_Dump(other);
Stemmer *clone = (Stemmer*)Stemmer_Load(other, dump);
Stemmer *other_clone = (Stemmer*)Stemmer_Load(other, other_dump);
TEST_FALSE(batch, Stemmer_Equals(stemmer,
(Obj*)other), "Equals() false with different language");
TEST_TRUE(batch, Stemmer_Equals(stemmer,
(Obj*)clone), "Dump => Load round trip");
TEST_TRUE(batch, Stemmer_Equals(other,
(Obj*)other_clone), "Dump => Load round trip");
DECREF(stemmer);
DECREF(dump);
DECREF(clone);
DECREF(other);
DECREF(other_dump);
DECREF(other_clone);
}
static void
test_Dump_Load_and_Equals(TestBatchRunner *runner) {
String *EN = (String*)SSTR_WRAP_UTF8("en", 2);
String *ES = (String*)SSTR_WRAP_UTF8("es", 2);
SnowballStemmer *stemmer = SnowStemmer_new(EN);
SnowballStemmer *other = SnowStemmer_new(ES);
Obj *dump = (Obj*)SnowStemmer_Dump(stemmer);
Obj *other_dump = (Obj*)SnowStemmer_Dump(other);
SnowballStemmer *clone = (SnowballStemmer*)SnowStemmer_Load(other, dump);
SnowballStemmer *other_clone = (SnowballStemmer*)SnowStemmer_Load(other, other_dump);
TEST_FALSE(runner,
SnowStemmer_Equals(stemmer, (Obj*)other),
"Equals() false with different language");
TEST_TRUE(runner,
SnowStemmer_Equals(stemmer, (Obj*)clone),
"Dump => Load round trip");
TEST_TRUE(runner,
SnowStemmer_Equals(other, (Obj*)other_clone),
"Dump => Load round trip");
DECREF(stemmer);
DECREF(dump);
DECREF(clone);
DECREF(other);
DECREF(other_dump);
DECREF(other_clone);
}
static void
test_cas_ptr(TestBatch *batch) {
int foo = 1;
int bar = 2;
int *foo_pointer = &foo;
int *bar_pointer = &bar;
int *target = NULL;
TEST_TRUE(batch,
Atomic_cas_ptr((void**)&target, NULL, foo_pointer),
"cas_ptr returns true on success");
TEST_TRUE(batch, target == foo_pointer, "cas_ptr sets target");
target = NULL;
TEST_FALSE(batch,
Atomic_cas_ptr((void**)&target, bar_pointer, foo_pointer),
"cas_ptr returns false when it old_value doesn't match");
TEST_TRUE(batch, target == NULL,
"cas_ptr doesn't do anything to target when old_value doesn't match");
target = foo_pointer;
TEST_TRUE(batch,
Atomic_cas_ptr((void**)&target, foo_pointer, bar_pointer),
"cas_ptr from one value to another");
TEST_TRUE(batch, target == bar_pointer, "cas_ptr sets target");
}
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 int
child_destructor_test (Child *child)
{
TEST_FALSE (list_head_free);
return 0;
}
static void
test_Local_Is_Directory(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_FALSE(runner, RAMFolder_Local_Is_Directory(folder, boffo),
"Local_Is_Directory() returns false for file");
TEST_TRUE(runner, RAMFolder_Local_Is_Directory(folder, foo),
"Local_Is_Directory() returns true for dir");
TEST_FALSE(runner, RAMFolder_Local_Is_Directory(folder, bar),
"Local_Is_Directory() returns false for non-existent entry");
DECREF(folder);
}
static void
test_Flip(TestBatch *batch) {
BitVector *bit_vec = BitVec_new(0);
int i;
for (i = 0; i <= 20; i++) { BitVec_Flip(bit_vec, i); }
for (i = 0; i <= 20; i++) {
TEST_TRUE(batch, BitVec_Get(bit_vec, i), "flip on %d", i);
}
TEST_FALSE(batch, BitVec_Get(bit_vec, i), "no flip %d", i);
for (i = 0; i <= 20; i++) { BitVec_Flip(bit_vec, i); }
for (i = 0; i <= 20; i++) {
TEST_FALSE(batch, BitVec_Get(bit_vec, i), "flip off %d", i);
}
TEST_FALSE(batch, BitVec_Get(bit_vec, i), "still no flip %d", i);
DECREF(bit_vec);
}
