static void
test_refill(TestBatchRunner *runner) {
RAMFile *file = RAMFile_new(NULL, false);
OutStream *outstream = OutStream_open((Obj*)file);
InStream *instream;
char scratch[5];
InStreamIVARS *ivars;
for (int32_t i = 0; i < 1023; i++) {
OutStream_Write_U8(outstream, 'x');
}
OutStream_Write_U8(outstream, 'y');
OutStream_Write_U8(outstream, 'z');
OutStream_Close(outstream);
instream = InStream_open((Obj*)file);
ivars = InStream_IVARS(instream);
InStream_Refill(instream);
TEST_INT_EQ(runner, ivars->limit - ivars->buf, IO_STREAM_BUF_SIZE,
"Refill");
TEST_INT_EQ(runner, (long)InStream_Tell(instream), 0,
"Correct file pos after standing-start Refill()");
DECREF(instream);
instream = InStream_open((Obj*)file);
ivars = InStream_IVARS(instream);
InStream_Fill(instream, 30);
TEST_INT_EQ(runner, ivars->limit - ivars->buf, 30, "Fill()");
TEST_INT_EQ(runner, (long)InStream_Tell(instream), 0,
"Correct file pos after standing-start Fill()");
DECREF(instream);
instream = InStream_open((Obj*)file);
ivars = InStream_IVARS(instream);
InStream_Read_Bytes(instream, scratch, 5);
TEST_INT_EQ(runner, ivars->limit - ivars->buf,
IO_STREAM_BUF_SIZE - 5, "small read triggers refill");
DECREF(instream);
instream = InStream_open((Obj*)file);
ivars = InStream_IVARS(instream);
TEST_INT_EQ(runner, InStream_Read_U8(instream), 'x', "Read_U8");
InStream_Seek(instream, 1023);
TEST_INT_EQ(runner, (long)FileWindow_IVARS(ivars->window)->offset, 0,
"no unnecessary refill on Seek");
TEST_INT_EQ(runner, (long)InStream_Tell(instream), 1023, "Seek/Tell");
TEST_INT_EQ(runner, InStream_Read_U8(instream), 'y',
"correct data after in-buffer Seek()");
TEST_INT_EQ(runner, InStream_Read_U8(instream), 'z', "automatic Refill");
TEST_TRUE(runner, (FileWindow_IVARS(ivars->window)->offset != 0),
"refilled");
DECREF(instream);
DECREF(outstream);
DECREF(file);
}
void
LeafQuery_Serialize_IMP(LeafQuery *self, OutStream *outstream) {
LeafQueryIVARS *const ivars = LeafQuery_IVARS(self);
if (ivars->field) {
OutStream_Write_U8(outstream, true);
Freezer_serialize_string(ivars->field, outstream);
}
else {
OutStream_Write_U8(outstream, false);
}
Freezer_serialize_string(ivars->text, outstream);
OutStream_Write_F32(outstream, ivars->boost);
}
int64_t
OutStream_Align_IMP(OutStream *self, int64_t modulus) {
int64_t len = OutStream_Tell(self);
int64_t filler_bytes = (modulus - (len % modulus)) % modulus;
while (filler_bytes--) { OutStream_Write_U8(self, 0); }
return OutStream_Tell(self);
}
void
MatchDoc_serialize(MatchDoc *self, OutStream *outstream)
{
OutStream_Write_C32(outstream, self->doc_id);
OutStream_Write_Float(outstream, self->score);
OutStream_Write_U8(outstream, self->values ? 1 : 0);
if (self->values) { VA_Serialize(self->values, outstream); }
}
void
Freezer_serialize(Obj *obj, OutStream *outstream) {
if (Obj_is_a(obj, STRING)) {
Freezer_serialize_string((String*)obj, outstream);
}
else if (Obj_is_a(obj, BLOB)) {
Freezer_serialize_blob((Blob*)obj, outstream);
}
else if (Obj_is_a(obj, VECTOR)) {
Freezer_serialize_varray((Vector*)obj, outstream);
}
else if (Obj_is_a(obj, HASH)) {
Freezer_serialize_hash((Hash*)obj, outstream);
}
else if (Obj_is_a(obj, INTEGER)) {
int64_t val = Int_Get_Value((Integer*)obj);
OutStream_Write_C64(outstream, (uint64_t)val);
}
else if (Obj_is_a(obj, FLOAT)) {
double val = Float_Get_Value((Float*)obj);
OutStream_Write_F64(outstream, val);
}
else if (Obj_is_a(obj, BOOLEAN)) {
bool val = Bool_Get_Value((Boolean*)obj);
OutStream_Write_U8(outstream, (uint8_t)val);
}
else if (Obj_is_a(obj, QUERY)) {
Query_Serialize((Query*)obj, outstream);
}
else if (Obj_is_a(obj, DOC)) {
Doc_Serialize((Doc*)obj, outstream);
}
else if (Obj_is_a(obj, DOCVECTOR)) {
DocVec_Serialize((DocVector*)obj, outstream);
}
else if (Obj_is_a(obj, TERMVECTOR)) {
TV_Serialize((TermVector*)obj, outstream);
}
else if (Obj_is_a(obj, SIMILARITY)) {
Sim_Serialize((Similarity*)obj, outstream);
}
else if (Obj_is_a(obj, MATCHDOC)) {
MatchDoc_Serialize((MatchDoc*)obj, outstream);
}
else if (Obj_is_a(obj, TOPDOCS)) {
TopDocs_Serialize((TopDocs*)obj, outstream);
}
else if (Obj_is_a(obj, SORTSPEC)) {
SortSpec_Serialize((SortSpec*)obj, outstream);
}
else if (Obj_is_a(obj, SORTRULE)) {
SortRule_Serialize((SortRule*)obj, outstream);
}
else {
THROW(ERR, "Don't know how to serialize a %o",
Obj_get_class_name(obj));
}
}
static void
test_Align(TestBatchRunner *runner) {
RAMFile *file = RAMFile_new(NULL, false);
OutStream *outstream = OutStream_open((Obj*)file);
for (int32_t i = 1; i < 32; i++) {
int64_t random_bytes = TestUtils_random_u64() % 32;
while (random_bytes--) { OutStream_Write_U8(outstream, 0); }
TEST_TRUE(runner, (OutStream_Align(outstream, i) % i) == 0,
"Align to %ld", (long)i);
}
DECREF(file);
DECREF(outstream);
}
static void
test_Clone_and_Reopen(TestBatchRunner *runner) {
String *foo = SSTR_WRAP_C("foo");
String *bar = SSTR_WRAP_C("bar");
RAMFile *file = RAMFile_new(NULL, false);
OutStream *outstream = OutStream_open((Obj*)file);
RAMFileHandle *fh;
InStream *instream;
InStream *clone;
InStream *reopened;
for (uint8_t i = 0; i < 26; i++) {
OutStream_Write_U8(outstream, 'a' + i);
}
OutStream_Close(outstream);
fh = RAMFH_open(foo, FH_READ_ONLY, file);
instream = InStream_open((Obj*)fh);
InStream_Seek(instream, 1);
TEST_TRUE(runner, Str_Equals(InStream_Get_Filename(instream), (Obj*)foo),
"Get_Filename");
clone = InStream_Clone(instream);
TEST_TRUE(runner, Str_Equals(InStream_Get_Filename(clone), (Obj*)foo),
"Clones have same filename");
TEST_TRUE(runner, InStream_Length(instream) == InStream_Length(clone),
"Clones have same length");
TEST_TRUE(runner, InStream_Read_U8(instream) == InStream_Read_U8(clone),
"Clones start at same file position");
reopened = InStream_Reopen(instream, bar, 25, 1);
TEST_TRUE(runner, Str_Equals(InStream_Get_Filename(reopened), (Obj*)bar),
"Reopened InStreams take new filename");
TEST_TRUE(runner, InStream_Read_U8(reopened) == 'z',
"Reopened stream starts at supplied offset");
TEST_TRUE(runner, InStream_Length(reopened) == 1,
"Reopened stream uses supplied length");
TEST_TRUE(runner, InStream_Tell(reopened) == 1,
"Tell() uses supplied offset for reopened stream");
InStream_Seek(reopened, 0);
TEST_TRUE(runner, InStream_Read_U8(reopened) == 'z',
"Seek() uses supplied offset for reopened stream");
DECREF(reopened);
DECREF(clone);
DECREF(instream);
DECREF(outstream);
DECREF(fh);
DECREF(file);
}
static void
test_Buf(TestBatchRunner *runner) {
RAMFile *file = RAMFile_new(NULL, false);
OutStream *outstream = OutStream_open((Obj*)file);
size_t size = IO_STREAM_BUF_SIZE * 2 + 5;
InStream *instream;
char *buf;
for (uint32_t i = 0; i < size; i++) {
OutStream_Write_U8(outstream, 'a');
}
OutStream_Close(outstream);
instream = InStream_open((Obj*)file);
InStreamIVARS *const ivars = InStream_IVARS(instream);
buf = InStream_Buf(instream, 5);
TEST_INT_EQ(runner, ivars->limit - buf, IO_STREAM_BUF_SIZE,
"Small request bumped up");
buf += IO_STREAM_BUF_SIZE - 10; // 10 bytes left in buffer.
InStream_Advance_Buf(instream, buf);
buf = InStream_Buf(instream, 10);
TEST_INT_EQ(runner, ivars->limit - buf, 10,
"Exact request doesn't trigger refill");
buf = InStream_Buf(instream, 11);
TEST_INT_EQ(runner, ivars->limit - buf, IO_STREAM_BUF_SIZE,
"Requesting over limit triggers refill");
int64_t expected = InStream_Length(instream) - InStream_Tell(instream);
char *buff = InStream_Buf(instream, 100000);
int64_t got = PTR_TO_I64(ivars->limit) - PTR_TO_I64(buff);
TEST_TRUE(runner, got == expected,
"Requests greater than file size get pared down");
DECREF(instream);
DECREF(outstream);
DECREF(file);
}
void
RangeQuery_serialize(RangeQuery *self, OutStream *outstream) {
OutStream_Write_F32(outstream, self->boost);
CB_Serialize(self->field, outstream);
if (self->lower_term) {
OutStream_Write_U8(outstream, true);
FREEZE(self->lower_term, outstream);
}
else {
OutStream_Write_U8(outstream, false);
}
if (self->upper_term) {
OutStream_Write_U8(outstream, true);
FREEZE(self->upper_term, outstream);
}
else {
OutStream_Write_U8(outstream, false);
}
OutStream_Write_U8(outstream, self->include_lower);
OutStream_Write_U8(outstream, self->include_upper);
}
void
RangeQuery_Serialize_IMP(RangeQuery *self, OutStream *outstream) {
RangeQueryIVARS *const ivars = RangeQuery_IVARS(self);
OutStream_Write_F32(outstream, ivars->boost);
Freezer_serialize_string(ivars->field, outstream);
if (ivars->lower_term) {
OutStream_Write_U8(outstream, true);
FREEZE(ivars->lower_term, outstream);
}
else {
OutStream_Write_U8(outstream, false);
}
if (ivars->upper_term) {
OutStream_Write_U8(outstream, true);
FREEZE(ivars->upper_term, outstream);
}
else {
OutStream_Write_U8(outstream, false);
}
OutStream_Write_U8(outstream, ivars->include_lower);
OutStream_Write_U8(outstream, ivars->include_upper);
}
