bool
NumPriQ_Less_Than_IMP(NumPriorityQueue *self, Obj *a, Obj *b) {
Float64 *num_a = (Float64*)a;
Float64 *num_b = (Float64*)b;
UNUSED_VAR(self);
return Float64_Get_Value(num_a) < Float64_Get_Value(num_b) ? true : false;
}
static void
S_round_trip_float(TestBatch *batch, double value, double max_diff) {
Float64 *num = Float64_new(value);
VArray *array = VA_new(1);
VA_Store(array, 0, (Obj*)num);
CharBuf *json = Json_to_json((Obj*)array);
Obj *dump = CERTIFY(Json_from_json(json), VARRAY);
Float64 *got = (Float64*)CERTIFY(VA_Fetch((VArray*)dump, 0), FLOAT64);
double diff = Float64_Get_Value(num) - Float64_Get_Value(got);
if (diff < 0) { diff = 0 - diff; }
TEST_TRUE(batch, diff <= max_diff, "Round trip float %f", value);
DECREF(dump);
DECREF(json);
DECREF(array);
}
static int32_t
S_pop_num(NumPriorityQueue *pq) {
Float64 *num = (Float64*)NumPriQ_Pop(pq);
int32_t retval;
if (!num) { THROW(ERR, "Queue is empty"); }
retval = (int32_t)Float64_Get_Value(num);
DECREF(num);
return retval;
}
static void
test_Peek_and_Pop_All(TestBatchRunner *runner) {
NumPriorityQueue *pq = NumPriQ_new(5);
Float64 *val;
S_insert_num(pq, 3);
S_insert_num(pq, 1);
S_insert_num(pq, 2);
S_insert_num(pq, 20);
S_insert_num(pq, 10);
val = (Float64*)CERTIFY(NumPriQ_Peek(pq), FLOAT64);
TEST_INT_EQ(runner, (long)Float64_Get_Value(val), 1,
"peek at the least item in the queue");
VArray *got = NumPriQ_Pop_All(pq);
val = (Float64*)CERTIFY(VA_Fetch(got, 0), FLOAT64);
TEST_INT_EQ(runner, (long)Float64_Get_Value(val), 20, "pop_all");
val = (Float64*)CERTIFY(VA_Fetch(got, 1), FLOAT64);
TEST_INT_EQ(runner, (long)Float64_Get_Value(val), 10, "pop_all");
val = (Float64*)CERTIFY(VA_Fetch(got, 2), FLOAT64);
TEST_INT_EQ(runner, (long)Float64_Get_Value(val), 3, "pop_all");
val = (Float64*)CERTIFY(VA_Fetch(got, 3), FLOAT64);
TEST_INT_EQ(runner, (long)Float64_Get_Value(val), 2, "pop_all");
val = (Float64*)CERTIFY(VA_Fetch(got, 4), FLOAT64);
TEST_INT_EQ(runner, (long)Float64_Get_Value(val), 1, "pop_all");
DECREF(got);
DECREF(pq);
}
void
DocWriter_Add_Inverted_Doc_IMP(DocWriter *self, Inverter *inverter,
int32_t doc_id) {
DocWriterIVARS *const ivars = DocWriter_IVARS(self);
OutStream *dat_out = S_lazy_init(self);
OutStream *ix_out = ivars->ix_out;
uint32_t num_stored = 0;
int64_t start = OutStream_Tell(dat_out);
int64_t expected = OutStream_Tell(ix_out) / 8;
// Verify doc id.
if (doc_id != expected) {
THROW(ERR, "Expected doc id %i64 but got %i32", expected, doc_id);
}
// Write the number of stored fields.
Inverter_Iterate(inverter);
while (Inverter_Next(inverter)) {
FieldType *type = Inverter_Get_Type(inverter);
if (FType_Stored(type)) { num_stored++; }
}
OutStream_Write_C32(dat_out, num_stored);
Inverter_Iterate(inverter);
while (Inverter_Next(inverter)) {
// Only store fields marked as "stored".
FieldType *type = Inverter_Get_Type(inverter);
if (FType_Stored(type)) {
String *field = Inverter_Get_Field_Name(inverter);
Obj *value = Inverter_Get_Value(inverter);
Freezer_serialize_string(field, dat_out);
switch (FType_Primitive_ID(type) & FType_PRIMITIVE_ID_MASK) {
case FType_TEXT: {
const char *buf = Str_Get_Ptr8((String*)value);
size_t size = Str_Get_Size((String*)value);
OutStream_Write_C32(dat_out, size);
OutStream_Write_Bytes(dat_out, buf, size);
break;
}
case FType_BLOB: {
char *buf = BB_Get_Buf((ByteBuf*)value);
size_t size = BB_Get_Size((ByteBuf*)value);
OutStream_Write_C32(dat_out, size);
OutStream_Write_Bytes(dat_out, buf, size);
break;
}
case FType_INT32: {
int32_t val = Int32_Get_Value((Integer32*)value);
OutStream_Write_C32(dat_out, val);
break;
}
case FType_INT64: {
int64_t val = Int64_Get_Value((Integer64*)value);
OutStream_Write_C64(dat_out, val);
break;
}
case FType_FLOAT32: {
float val = Float32_Get_Value((Float32*)value);
OutStream_Write_F32(dat_out, val);
break;
}
case FType_FLOAT64: {
double val = Float64_Get_Value((Float64*)value);
OutStream_Write_F64(dat_out, val);
break;
}
default:
THROW(ERR, "Unrecognized type: %o", type);
}
}
}
// Write file pointer.
OutStream_Write_I64(ix_out, start);
}
static void
test_accessors(TestBatch *batch) {
Float32 *f32 = Float32_new(1.0);
Float64 *f64 = Float64_new(1.0);
Integer32 *i32 = Int32_new(1);
Integer64 *i64 = Int64_new(1);
float wanted32 = 1.33f;
double wanted64 = 1.33;
float got32;
double got64;
Float32_Set_Value(f32, 1.33f);
TEST_FLOAT_EQ(batch, Float32_Get_Value(f32), 1.33f,
"F32 Set_Value Get_Value");
Float64_Set_Value(f64, 1.33);
got64 = Float64_Get_Value(f64);
TEST_TRUE(batch, *(int64_t*)&got64 == *(int64_t*)&wanted64,
"F64 Set_Value Get_Value");
TEST_TRUE(batch, Float32_To_I64(f32) == 1, "Float32_To_I64");
TEST_TRUE(batch, Float64_To_I64(f64) == 1, "Float64_To_I64");
got32 = (float)Float32_To_F64(f32);
TEST_TRUE(batch, *(int32_t*)&got32 == *(int32_t*)&wanted32,
"Float32_To_F64");
got64 = Float64_To_F64(f64);
TEST_TRUE(batch, *(int64_t*)&got64 == *(int64_t*)&wanted64,
"Float64_To_F64");
Int32_Set_Value(i32, I32_MIN);
TEST_INT_EQ(batch, Int32_Get_Value(i32), I32_MIN,
"I32 Set_Value Get_Value");
Int64_Set_Value(i64, I64_MIN);
TEST_TRUE(batch, Int64_Get_Value(i64) == I64_MIN,
"I64 Set_Value Get_Value");
Int32_Set_Value(i32, -1);
Int64_Set_Value(i64, -1);
TEST_TRUE(batch, Int32_To_F64(i32) == -1, "Int32_To_F64");
TEST_TRUE(batch, Int64_To_F64(i64) == -1, "Int64_To_F64");
TEST_INT_EQ(batch, Bool_Get_Value(CFISH_TRUE), true,
"Bool_Get_Value [true]");
TEST_INT_EQ(batch, Bool_Get_Value(CFISH_FALSE), false,
"Bool_Get_Value [false]");
TEST_TRUE(batch, Bool_To_I64(CFISH_TRUE) == true,
"Bool_To_I64 [true]");
TEST_TRUE(batch, Bool_To_I64(CFISH_FALSE) == false,
"Bool_To_I64 [false]");
TEST_TRUE(batch, Bool_To_F64(CFISH_TRUE) == 1.0,
"Bool_To_F64 [true]");
TEST_TRUE(batch, Bool_To_F64(CFISH_FALSE) == 0.0,
"Bool_To_F64 [false]");
DECREF(i64);
DECREF(i32);
DECREF(f64);
DECREF(f32);
}
