susumu.yata
null+****@clear*****
Tue Sep 2 11:32:50 JST 2014
susumu.yata 2014-09-02 11:32:50 +0900 (Tue, 02 Sep 2014) New Revision: 69b726e84ab07618b1207e8dd1d9edd5f45518b7 https://github.com/groonga/grnxx/commit/69b726e84ab07618b1207e8dd1d9edd5f45518b7 Message: Add tests for GeoPoint and Vector<GeoPoint>. Modified files: test/test_column.cpp test/test_expression.cpp Modified: test/test_column.cpp (+45 -0) =================================================================== --- test/test_column.cpp 2014-09-02 11:32:38 +0900 (d84b667) +++ test/test_column.cpp 2014-09-02 11:32:50 +0900 (d49b619) @@ -74,6 +74,17 @@ void test_column() { assert(!float_column->has_key_attribute()); assert(float_column->num_indexes() == 0); + // Create a column named "GeoPointColumn". + // The column stores GeoPoint values. + auto geo_point_column = table->create_column(&error, "GeoPointColumn", + grnxx::GEO_POINT_DATA); + assert(geo_point_column); + assert(geo_point_column->table() == table); + assert(geo_point_column->name() == "GeoPointColumn"); + assert(geo_point_column->data_type() == grnxx::GEO_POINT_DATA); + assert(!geo_point_column->has_key_attribute()); + assert(geo_point_column->num_indexes() == 0); + // Create a column named "TextColumn". // The column stores Text values. auto text_column = table->create_column(&error, "TextColumn", @@ -118,6 +129,17 @@ void test_column() { assert(!float_vector_column->has_key_attribute()); assert(float_vector_column->num_indexes() == 0); + // Create a column named "GeoPointVectorColumn". + // The column stores Text values. + auto geo_point_vector_column = table->create_column( + &error, "GeoPointVectorColumn", grnxx::GEO_POINT_VECTOR_DATA); + assert(geo_point_vector_column); + assert(geo_point_vector_column->table() == table); + assert(geo_point_vector_column->name() == "GeoPointVectorColumn"); + assert(geo_point_vector_column->data_type() == grnxx::GEO_POINT_VECTOR_DATA); + assert(!geo_point_vector_column->has_key_attribute()); + assert(geo_point_vector_column->num_indexes() == 0); + grnxx::Datum datum; // Check that the default values are stored. @@ -133,6 +155,10 @@ void test_column() { assert(datum.type() == grnxx::FLOAT_DATA); assert(datum.force_float() == 0.0); + assert(geo_point_column->get(&error, 1, &datum)); + assert(datum.type() == grnxx::GEO_POINT_DATA); + assert(datum.force_geo_point() == grnxx::GeoPoint(0, 0)); + assert(text_column->get(&error, 1, &datum)); assert(datum.type() == grnxx::TEXT_DATA); assert(datum.force_text() == ""); @@ -149,10 +175,15 @@ void test_column() { assert(datum.type() == grnxx::FLOAT_VECTOR_DATA); assert(datum.force_float_vector() == grnxx::FloatVector(nullptr, 0)); + assert(geo_point_vector_column->get(&error, 1, &datum)); + assert(datum.type() == grnxx::GEO_POINT_VECTOR_DATA); + assert(datum.force_geo_point_vector() == grnxx::GeoPointVector(nullptr, 0)); + // Set and get values. assert(bool_column->set(&error, 1, grnxx::Bool(true))); assert(int_column->set(&error, 1, grnxx::Int(123))); assert(float_column->set(&error, 1, grnxx::Float(0.25))); + assert(geo_point_column->set(&error, 1, grnxx::GeoPoint(123, 456))); assert(text_column->set(&error, 1, grnxx::Text("Hello, world!"))); assert(bool_vector_column->set(&error, 1, grnxx::BoolVector{ true, false, true })); @@ -162,6 +193,11 @@ void test_column() { grnxx::Float float_vector_value[] = { 1.23, -4.56, 7.89 }; assert(float_vector_column->set(&error, 1, grnxx::FloatVector(float_vector_value, 3))); + grnxx::GeoPoint geo_point_vector_value[] = { + { 123, 456 }, { 789, 123 }, { 456, 789 } + }; + assert(geo_point_vector_column->set( + &error, 1, grnxx::GeoPointVector(geo_point_vector_value, 3))); assert(bool_column->get(&error, 1, &datum)); assert(datum.type() == grnxx::BOOL_DATA); @@ -175,6 +211,10 @@ void test_column() { assert(datum.type() == grnxx::FLOAT_DATA); assert(datum.force_float() == 0.25); + assert(geo_point_column->get(&error, 1, &datum)); + assert(datum.type() == grnxx::GEO_POINT_DATA); + assert(datum.force_geo_point() == grnxx::GeoPoint(123, 456)); + assert(text_column->get(&error, 1, &datum)); assert(datum.type() == grnxx::TEXT_DATA); assert(datum.force_text() == "Hello, world!"); @@ -193,6 +233,11 @@ void test_column() { assert(datum.type() == grnxx::FLOAT_VECTOR_DATA); assert(datum.force_float_vector() == grnxx::FloatVector(float_vector_value, 3)); + + assert(geo_point_vector_column->get(&error, 1, &datum)); + assert(datum.type() == grnxx::GEO_POINT_VECTOR_DATA); + assert(datum.force_geo_point_vector() == + grnxx::GeoPointVector(geo_point_vector_value, 3)); } int main() { Modified: test/test_expression.cpp (+269 -1) =================================================================== --- test/test_expression.cpp 2014-09-02 11:32:38 +0900 (f6ba3fc) +++ test/test_expression.cpp 2014-09-02 11:32:50 +0900 (54ee4c9) @@ -36,6 +36,8 @@ struct { grnxx::Array<grnxx::Int> int2_values; grnxx::Array<grnxx::Float> float_values; grnxx::Array<grnxx::Float> float2_values; + grnxx::Array<grnxx::GeoPoint> geo_point_values; + grnxx::Array<grnxx::GeoPoint> geo_point2_values; grnxx::Array<grnxx::Text> text_values; grnxx::Array<grnxx::Text> text2_values; grnxx::Array<std::string> text_bodies; @@ -50,6 +52,10 @@ struct { grnxx::Array<grnxx::FloatVector> float_vector2_values; grnxx::Array<grnxx::Array<grnxx::Float>> float_vector_bodies; grnxx::Array<grnxx::Array<grnxx::Float>> float_vector2_bodies; + grnxx::Array<grnxx::GeoPointVector> geo_point_vector_values; + grnxx::Array<grnxx::GeoPointVector> geo_point_vector2_values; + grnxx::Array<grnxx::Array<grnxx::GeoPoint>> geo_point_vector_bodies; + grnxx::Array<grnxx::Array<grnxx::GeoPoint>> geo_point_vector2_bodies; } test; void init_test() { @@ -82,6 +88,14 @@ void init_test() { assert(float_column); assert(float2_column); + data_type = grnxx::GEO_POINT_DATA; + auto geo_point_column = + test.table->create_column(&error, "GeoPoint", data_type); + auto geo_point2_column = + test.table->create_column(&error, "GeoPoint2", data_type); + assert(geo_point_column); + assert(geo_point2_column); + data_type = grnxx::TEXT_DATA; auto text_column = test.table->create_column(&error, "Text", data_type); auto text2_column = test.table->create_column(&error, "Text2", data_type); @@ -112,14 +126,24 @@ void init_test() { assert(float_vector_column); assert(float_vector2_column); + data_type = grnxx::GEO_POINT_VECTOR_DATA; + auto geo_point_vector_column = + test.table->create_column(&error, "GeoPointVector", data_type); + auto geo_point_vector2_column = + test.table->create_column(&error, "GeoPointVector2", data_type); + assert(geo_point_vector_column); + assert(geo_point_vector2_column); + // Generate random values. // Bool: true or false. // Int: [0, 100). // Float: [0.0, 1.0]. + // GeoPoint: { [0, 100), [0, 100) }. // Text: byte = ['0', '9'], length = [1, 4]. // BoolVector: value = true or false, size = [0, 58]. // IntVector: value = [0, 100), size = [0, 4]. // FloatVector: value = [0.0, 1.0), size = [0, 4]. + // GeoPointVector: value = { [0, 100), [0, 100) }, size = [0, 4]. constexpr grnxx::Int NUM_ROWS = 1 << 16; constexpr grnxx::Int MIN_LENGTH = 1; constexpr grnxx::Int MAX_LENGTH = 4; @@ -131,6 +155,8 @@ void init_test() { assert(test.int2_values.resize(&error, NUM_ROWS + 1)); assert(test.float_values.resize(&error, NUM_ROWS + 1)); assert(test.float2_values.resize(&error, NUM_ROWS + 1)); + assert(test.geo_point_values.resize(&error, NUM_ROWS + 1)); + assert(test.geo_point2_values.resize(&error, NUM_ROWS + 1)); assert(test.text_values.resize(&error, NUM_ROWS + 1)); assert(test.text2_values.resize(&error, NUM_ROWS + 1)); assert(test.text_bodies.resize(&error, NUM_ROWS + 1)); @@ -145,6 +171,10 @@ void init_test() { assert(test.float_vector2_values.resize(&error, NUM_ROWS + 1)); assert(test.float_vector_bodies.resize(&error, NUM_ROWS + 1)); assert(test.float_vector2_bodies.resize(&error, NUM_ROWS + 1)); + assert(test.geo_point_vector_values.resize(&error, NUM_ROWS + 1)); + assert(test.geo_point_vector2_values.resize(&error, NUM_ROWS + 1)); + assert(test.geo_point_vector_bodies.resize(&error, NUM_ROWS + 1)); + assert(test.geo_point_vector2_bodies.resize(&error, NUM_ROWS + 1)); for (grnxx::Int i = 1; i <= NUM_ROWS; ++i) { test.bool_values.set(i, (mersenne_twister() & 1) != 0); test.bool2_values.set(i, (mersenne_twister() & 1) != 0); @@ -156,6 +186,11 @@ void init_test() { test.float_values.set(i, 1.0 * mersenne_twister() / MAX_VALUE); test.float2_values.set(i, 1.0 * mersenne_twister() / MAX_VALUE); + test.geo_point_values.set( + i, grnxx::GeoPoint(mersenne_twister() % 100, mersenne_twister() % 100)); + test.geo_point2_values.set( + i, grnxx::GeoPoint(mersenne_twister() % 100, mersenne_twister() % 100)); + grnxx::Int length = (mersenne_twister() % (MAX_LENGTH - MIN_LENGTH)) + MIN_LENGTH; test.text_bodies[i].resize(length); @@ -207,6 +242,23 @@ void init_test() { } test.float_vector2_values.set( i, grnxx::FloatVector(test.float_vector2_bodies[i].data(), size)); + + size = mersenne_twister() % (MAX_SIZE + 1); + assert(test.geo_point_vector_bodies[i].resize(&error, size)); + for (grnxx::Int j = 0; j < size; ++j) { + test.geo_point_vector_bodies[i][j] = + grnxx::GeoPoint(mersenne_twister() % 100, mersenne_twister() % 100); + } + test.geo_point_vector_values.set( + i, grnxx::GeoPointVector(test.geo_point_vector_bodies[i].data(), size)); + size = mersenne_twister() % (MAX_SIZE + 1); + assert(test.geo_point_vector2_bodies[i].resize(&error, size)); + for (grnxx::Int j = 0; j < size; ++j) { + test.geo_point_vector2_bodies[i][j] = + grnxx::GeoPoint(mersenne_twister() % 100, mersenne_twister() % 100); + } + test.geo_point_vector2_values.set( + i, grnxx::GeoPointVector(test.geo_point_vector2_bodies[i].data(), size)); } // Store generated values into columns. @@ -220,6 +272,8 @@ void init_test() { assert(int2_column->set(&error, row_id, test.int2_values[i])); assert(float_column->set(&error, row_id, test.float_values[i])); assert(float2_column->set(&error, row_id, test.float2_values[i])); + assert(geo_point_column->set(&error, row_id, test.geo_point_values[i])); + assert(geo_point2_column->set(&error, row_id, test.geo_point2_values[i])); assert(text_column->set(&error, row_id, test.text_values[i])); assert(text2_column->set(&error, row_id, test.text2_values[i])); assert(bool_vector_column->set(&error, row_id, @@ -234,6 +288,10 @@ void init_test() { test.float_vector_values[i])); assert(float_vector2_column->set(&error, row_id, test.float_vector2_values[i])); + assert(geo_point_vector_column->set(&error, row_id, + test.geo_point_vector_values[i])); + assert(geo_point_vector2_column->set(&error, row_id, + test.geo_point_vector2_values[i])); } } @@ -313,6 +371,18 @@ void test_constant() { assert(records.get_score(i) == 1.25); } + // Test an expression ({ 123, 456 }). + assert(builder->push_datum(&error, grnxx::GeoPoint(123, 456))); + expression = builder->release(&error); + assert(expression); + + grnxx::Array<grnxx::GeoPoint> geo_point_results; + assert(expression->evaluate(&error, records, &geo_point_results)); + assert(geo_point_results.size() == test.table->num_rows()); + for (grnxx::Int i = 0; i < geo_point_results.size(); ++i) { + assert(geo_point_results[i] == grnxx::GeoPoint(123, 456)); + } + // Test an expression ("ABC"). assert(builder->push_datum(&error, grnxx::Text("ABC"))); expression = builder->release(&error); @@ -364,6 +434,23 @@ void test_constant() { for (grnxx::Int i = 0; i < float_vector_results.size(); ++i) { assert(float_vector_results[i] == grnxx::FloatVector(float_values, 3)); } + + // Test an expression ({{ 123, 456 }, { 789, 123 }, { 456, 789 }}). + grnxx::GeoPoint geo_point_values[] = { + { 123, 456 }, { 789, 123 }, { 456, 789 } + }; + assert(builder->push_datum( + &error, grnxx::GeoPointVector(geo_point_values, 3))); + expression = builder->release(&error); + assert(expression); + + grnxx::Array<grnxx::GeoPointVector> geo_point_vector_results; + assert(expression->evaluate(&error, records, &geo_point_vector_results)); + assert(geo_point_vector_results.size() == test.table->num_rows()); + for (grnxx::Int i = 0; i < geo_point_vector_results.size(); ++i) { + assert(geo_point_vector_results[i] == + grnxx::GeoPointVector(geo_point_values, 3)); + } } void test_column() { @@ -439,6 +526,19 @@ void test_column() { assert(records.get_score(i) == test.float_values[row_id]); } + // Test an expression (GeoPoint). + assert(builder->push_column(&error, "GeoPoint")); + expression = builder->release(&error); + assert(expression); + + grnxx::Array<grnxx::GeoPoint> geo_point_results; + assert(expression->evaluate(&error, records, &geo_point_results)); + assert(geo_point_results.size() == test.table->num_rows()); + for (grnxx::Int i = 0; i < geo_point_results.size(); ++i) { + grnxx::Int row_id = records.get_row_id(i); + assert(geo_point_results[i] == test.geo_point_values[row_id]); + } + // Test an expression (Text). assert(builder->push_column(&error, "Text")); expression = builder->release(&error); @@ -511,6 +611,24 @@ void test_column() { assert(float_vector_results[i] == test.float_vector_values[row_id]); } + // Test an expression (GeoPointVector). + assert(builder->push_column(&error, "GeoPointVector")); + expression = builder->release(&error); + assert(expression); + + records.clear(); + cursor = test.table->create_cursor(&error); + assert(cursor); + assert(cursor->read_all(&error, &records) == test.table->num_rows()); + + grnxx::Array<grnxx::GeoPointVector> geo_point_vector_results; + assert(expression->evaluate(&error, records, &geo_point_vector_results)); + assert(geo_point_vector_results.size() == test.table->num_rows()); + for (grnxx::Int i = 0; i < geo_point_vector_results.size(); ++i) { + grnxx::Int row_id = records.get_row_id(i); + assert(geo_point_vector_results[i] == test.geo_point_vector_values[row_id]); + } + // Test and expression (_id). assert(builder->push_column(&error, "_id")); expression = builder->release(&error); @@ -983,6 +1101,37 @@ void test_equal() { } assert(records.size() == count); + // Test an expression (GeoPoint == GeoPoint2). + assert(builder->push_column(&error, "GeoPoint")); + assert(builder->push_column(&error, "GeoPoint2")); + assert(builder->push_operator(&error, grnxx::EQUAL_OPERATOR)); + expression = builder->release(&error); + assert(expression); + + records.clear(); + cursor = test.table->create_cursor(&error); + assert(cursor); + assert(cursor->read_all(&error, &records) == test.table->num_rows()); + + results.clear(); + assert(expression->evaluate(&error, records, &results)); + assert(results.size() == test.table->num_rows()); + for (grnxx::Int i = 0; i < results.size(); ++i) { + grnxx::Int row_id = records.get_row_id(i); + assert(results[i] == + (test.geo_point_values[row_id] == test.geo_point2_values[row_id])); + } + + assert(expression->filter(&error, &records)); + count = 0; + for (grnxx::Int i = 1; i < test.geo_point_values.size(); ++i) { + if (test.geo_point_values[i] == test.geo_point2_values[i]) { + assert(records.get_row_id(count) == i); + ++count; + } + } + assert(records.size() == count); + // Test an expression (Text == Text2). assert(builder->push_column(&error, "Text")); assert(builder->push_column(&error, "Text2")); @@ -1106,6 +1255,37 @@ void test_equal() { } } assert(records.size() == count); + + // Test an expression (GeoPointVector == GeoPointVector2). + assert(builder->push_column(&error, "GeoPointVector")); + assert(builder->push_column(&error, "GeoPointVector2")); + assert(builder->push_operator(&error, grnxx::EQUAL_OPERATOR)); + expression = builder->release(&error); + assert(expression); + + records.clear(); + cursor = test.table->create_cursor(&error); + assert(cursor); + assert(cursor->read_all(&error, &records) == test.table->num_rows()); + + results.clear(); + assert(expression->evaluate(&error, records, &results)); + assert(results.size() == test.table->num_rows()); + for (grnxx::Int i = 0; i < results.size(); ++i) { + grnxx::Int row_id = records.get_row_id(i); + assert(results[i] == (test.geo_point_vector_values[row_id] == + test.geo_point_vector2_values[row_id])); + } + + assert(expression->filter(&error, &records)); + count = 0; + for (grnxx::Int i = 1; i < test.geo_point_vector_values.size(); ++i) { + if (test.geo_point_vector_values[i] == test.geo_point_vector2_values[i]) { + assert(records.get_row_id(count) == i); + ++count; + } + } + assert(records.size() == count); } void test_not_equal() { @@ -1208,6 +1388,37 @@ void test_not_equal() { } assert(records.size() == count); + // Test an expression (GeoPoint != GeoPoint2). + assert(builder->push_column(&error, "GeoPoint")); + assert(builder->push_column(&error, "GeoPoint2")); + assert(builder->push_operator(&error, grnxx::NOT_EQUAL_OPERATOR)); + expression = builder->release(&error); + assert(expression); + + records.clear(); + cursor = test.table->create_cursor(&error); + assert(cursor); + assert(cursor->read_all(&error, &records) == test.table->num_rows()); + + results.clear(); + assert(expression->evaluate(&error, records, &results)); + assert(results.size() == test.table->num_rows()); + for (grnxx::Int i = 0; i < results.size(); ++i) { + grnxx::Int row_id = records.get_row_id(i); + assert(results[i] == (test.geo_point_values[row_id] != + test.geo_point2_values[row_id])); + } + + assert(expression->filter(&error, &records)); + count = 0; + for (grnxx::Int i = 1; i < test.geo_point_values.size(); ++i) { + if (test.geo_point_values[i] != test.geo_point2_values[i]) { + assert(records.get_row_id(count) == i); + ++count; + } + } + assert(records.size() == count); + // Test an expression (Text != Text2). assert(builder->push_column(&error, "Text")); assert(builder->push_column(&error, "Text2")); @@ -1331,6 +1542,37 @@ void test_not_equal() { } } assert(records.size() == count); + + // Test an expression (GeoPointVector != GeoPointVector2). + assert(builder->push_column(&error, "GeoPointVector")); + assert(builder->push_column(&error, "GeoPointVector2")); + assert(builder->push_operator(&error, grnxx::NOT_EQUAL_OPERATOR)); + expression = builder->release(&error); + assert(expression); + + records.clear(); + cursor = test.table->create_cursor(&error); + assert(cursor); + assert(cursor->read_all(&error, &records) == test.table->num_rows()); + + results.clear(); + assert(expression->evaluate(&error, records, &results)); + assert(results.size() == test.table->num_rows()); + for (grnxx::Int i = 0; i < results.size(); ++i) { + grnxx::Int row_id = records.get_row_id(i); + assert(results[i] == (test.geo_point_vector_values[row_id] != + test.geo_point_vector2_values[row_id])); + } + + assert(expression->filter(&error, &records)); + count = 0; + for (grnxx::Int i = 1; i < test.geo_point_vector_values.size(); ++i) { + if (test.geo_point_vector_values[i] != test.geo_point_vector2_values[i]) { + assert(records.get_row_id(count) == i); + ++count; + } + } + assert(records.size() == count); } void test_less() { @@ -2384,7 +2626,33 @@ void test_subscript() { if (int_value < float_vector_value.size()) { assert(records.get_score(i) == float_vector_value[int_value]); } else { - assert(records.get_score(i) == 0); + assert(records.get_score(i) == 0.0); + } + } + + // Test an expression (GeoPointVector[Int]). + assert(builder->push_column(&error, "GeoPointVector")); + assert(builder->push_column(&error, "Int")); + assert(builder->push_operator(&error, grnxx::SUBSCRIPT_OPERATOR)); + expression = builder->release(&error); + assert(expression); + + records.clear(); + cursor = test.table->create_cursor(&error); + assert(cursor); + assert(cursor->read_all(&error, &records) == test.table->num_rows()); + + grnxx::Array<grnxx::GeoPoint> geo_point_results; + assert(expression->evaluate(&error, records, &geo_point_results)); + assert(geo_point_results.size() == test.table->num_rows()); + for (grnxx::Int i = 0; i < geo_point_results.size(); ++i) { + grnxx::Int row_id = records.get_row_id(i); + const auto int_value = test.int_values[row_id]; + const auto &geo_point_vector_value = test.geo_point_vector_values[row_id]; + if (int_value < geo_point_vector_value.size()) { + assert(geo_point_results[i] == geo_point_vector_value[int_value]); + } else { + assert(geo_point_results[i] == grnxx::GeoPoint(0, 0)); } } } -------------- next part -------------- HTML����������������������������...Download