finish value_field_test.cc

test/value_field_test.cc

@@ -30,137 +30,6 @@ protected:
     DB* db_ = nullptr; // 数据库实例指针。
 };
 
-// 测试批量插入和验证
-TEST_F(FieldsTest, TestBulkInsertAndValidation) {
-    const size_t num_fields = 1000;
-    FieldArray fields;
-
-    // 准备大量字段数据（逆序添加以测试排序）
-    for (size_t i = num_fields; i > 0; --i) {
-        fields.emplace_back(std::to_string(i), "value_" + std::to_string(i));
-    }
-
-    // 创建 Fields 对象并添加所有字段
-    Fields f(fields);
-
-    // 验证所有字段都被正确添加
-    EXPECT_EQ(f.size(), num_fields); 
-
-    // 排序字段
-    f.SortFields();
-
-    // 验证每个字段的存在性和值（现在应该按顺序排列）
-    for (size_t i = 1; i <= num_fields; ++i) {
-        auto field_name = std::to_string(i);
-        EXPECT_TRUE(f.HasField(field_name)) << "Missing field: " << field_name;
-        EXPECT_EQ(f.GetField(field_name).second, "value_" + std::to_string(i)) << "Incorrect value for field: " << field_name;
-    }
-
-    // 序列化字段，并将结果插入数据库
-    std::string serialized_value = f.SerializeValue();
-    const std::string key = "bulk_data_key";
-    Status status = db_->Put(WriteOptions(), key, serialized_value);
-    EXPECT_TRUE(status.ok()) << "Failed to put data into database: " << status.ToString();
-
-    // 从数据库中读取并反序列化字段
-    std::string retrieved_value;
-    status = db_->Get(ReadOptions(), key, &retrieved_value);
-    EXPECT_TRUE(status.ok()) << "Failed to get data from database: " << status.ToString();
-    Fields deserialized_fields = Fields::ParseValue(retrieved_value);
-
-    // 验证反序列化的字段是否与原始字段匹配
-    EXPECT_EQ(deserialized_fields.size(), num_fields); 
-    for (size_t i = 1; i <= num_fields; ++i) {
-        auto field_name = std::to_string(i);
-        EXPECT_TRUE(deserialized_fields.HasField(field_name)) << "Deserialized field missing: " << field_name;
-        EXPECT_EQ(deserialized_fields.GetField(field_name).second, "value_" + std::to_string(i)) << "Incorrect deserialized value for field: " << field_name;
-    }
-
-}
-
-// 测试批量删除功能
-TEST_F(FieldsTest, TestBulkDelete) {
-    const size_t num_fields = 1000;
-    FieldArray fields;
-
-    // 准备大量字段数据
-    for (size_t i = 0; i < num_fields; ++i) {
-        fields.emplace_back(std::to_string(i), "value_" + std::to_string(i));
-    }
-
-    // 创建 Fields 对象并添加所有字段
-    Fields f(fields);
-
-    // 批量删除一半的字段
-    std::vector<std::string> delete_field_names;
-    for (size_t i = 0; i < num_fields / 2; ++i) {
-        delete_field_names.push_back(std::to_string(i));
-    }
-    f.DeleteFields(delete_field_names);
-
-    // 验证删除后的字段数量和内容
-    EXPECT_EQ(f.size(), num_fields / 2);
-    for (size_t i = 0; i < num_fields; ++i) {
-        auto field_name = std::to_string(i);
-        if (i < num_fields / 2) {
-            EXPECT_FALSE(f.HasField(field_name)) << "Deleted field still exists: " << field_name;
-        } else {
-            EXPECT_TRUE(f.HasField(field_name)) << "Missing non-deleted field: " << field_name;
-            EXPECT_EQ(f.GetField(field_name).second, "value_" + std::to_string(i)) << "Incorrect value for non-deleted field: " << field_name;
-        }
-    }
-}
-
-// 测试单个更新操作
-TEST_F(FieldsTest, TestSingleUpdate) {
-    FieldArray fields = {{"field1", "old_value"}, {"field2", "value2"}};
-    Fields f(fields);
-    f.UpdateField("field1", "new_value");
-
-    EXPECT_EQ(f.GetField("field1").second, "new_value");
-    EXPECT_EQ(f.GetField("field2").second, "value2");
-
-    // 检查排序是否正确
-    EXPECT_TRUE(std::is_sorted(f.begin(), f.end(),
-                               [](const Field& lhs, const Field& rhs) {
-                                   return lhs.first < rhs.first;
-                               })) << "Fields are not sorted after single update.";
-}
-
-// 测试批量更新操作
-TEST_F(FieldsTest, TestBulkUpdate) {
-    const size_t num_fields = 500;
-    FieldArray fields;
-
-    // 准备大量字段数据
-    for (size_t i = 0; i < num_fields; ++i) {
-        fields.emplace_back(std::to_string(i), "old_value_" + std::to_string(i));
-    }
-
-    // 创建 Fields 对象并添加所有字段
-    Fields f(fields);
-
-    // 批量更新一半的字段
-    FieldArray update_fields;
-    for (size_t i = 0; i < num_fields / 2; ++i) {
-        update_fields.emplace_back(std::to_string(i), "new_value_" + std::to_string(i));
-    }
-    f.UpdateFields(update_fields);
-
-    // 验证更新后的字段值
-    for (size_t i = 0; i < num_fields; ++i) {
-        auto field_name = std::to_string(i);
-        auto expected_value = (i < num_fields / 2) ? ("new_value_" + std::to_string(i)) : ("old_value_" + std::to_string(i));
-        EXPECT_EQ(f.GetField(field_name).second, expected_value) << "Incorrect value for updated field: " << field_name;
-    }
-
-    // 检查排序是否正确
-    EXPECT_TRUE(std::is_sorted(f.begin(), f.end(),
-                               [](const Field& lhs, const Field& rhs) {
-                                   return lhs.first < rhs.first;
-                               })) << "Fields are not sorted after bulk update.";
-}
-
 // 测试各种构造函数
 TEST_F(FieldsTest, TestConstructors) {
     // 单个 Field 构造
@@ -181,6 +50,34 @@ TEST_F(FieldsTest, TestConstructors) {
     EXPECT_EQ(f_names.size(), 2);
 }
 
+// 测试构造函数内的SortFields的实现
+TEST_F(FieldsTest, TestSortFields) {
+    // 准备一组未排序的字段数据
+    FieldArray unsorted_fields = {
+        {"field3", "value3"},
+        {"field1", "value1"},
+        {"field2", "value2"},
+        {"field5", "value5"},
+        {"field4", "value4"}
+    };
+
+    // 创建 Fields 对象，构造函数应该自动调用 SortFields
+    Fields f(unsorted_fields);
+
+    // 验证字段是否已经正确排序
+    EXPECT_TRUE(std::is_sorted(f.begin(), f.end(),
+                               [](const Field& lhs, const Field& rhs) {
+                                   return lhs.first < rhs.first;
+                               })) << "Fields are not sorted after constructor.";
+
+    // 验证排序后的字段顺序是否符合预期
+    std::vector<std::string> expected_order = {"field1", "field2", "field3", "field4", "field5"};
+    size_t index = 0;
+    for (const auto& field : f) {
+        EXPECT_EQ(field.first, expected_order[index++]) << "Field order is incorrect after constructor sorting.";
+    }
+}
+
 // 测试 operator[] 访问功能
 TEST_F(FieldsTest, TestOperatorBracketAccess) {
     // 创建一个 Fields 对象并添加一些字段
@@ -191,7 +88,7 @@ TEST_F(FieldsTest, TestOperatorBracketAccess) {
     EXPECT_EQ(f["field1"], "value1");
     EXPECT_EQ(f["field2"], "value2");
 
-    // 尝试获取不存在的字段，应该返回空字符串并打印错误信息
+    // 尝试获取不存在的字段，应该返回空字符串
     testing::internal::CaptureStderr();
     EXPECT_EQ(f["nonexistent_field"], "");
 }
@@ -219,28 +116,90 @@ TEST_F(FieldsTest, TestOperatorBracketUpdate) {
     EXPECT_EQ(f["field2"], "value2");
     EXPECT_EQ(f["field3"], "value3");
 
-    // 检查排序是否正确
-    EXPECT_TRUE(std::is_sorted(f.begin(), f.end(),
-                               [](const Field& lhs, const Field& rhs) {
-                                   return lhs.first < rhs.first;
-                               })) << "Fields are not sorted after updates.";
 }
 
-// 测试批量插入、排序、序列化/反序列化以及 FindKeysByFields 功能
-TEST_F(FieldsTest, TestBulkInsertSortSerializeAndFindKeys) {
-    const size_t num_entries = 500;
+// 测试批量删除功能
+TEST_F(FieldsTest, TestBulkDelete) {
+    const size_t num_fields = 1000;
     leveldb::WriteBatch batch;
 
-    // 准备大量键值对数据（逆序添加以测试排序）
-    std::map<std::string, Fields> data_to_insert;
-    for (size_t i = num_entries; i > 0; --i) {
+    // 准备大量字段数据，并通过 PutFields 插入到数据库
+    for (size_t i = 0; i < num_fields; ++i) {
+        std::string key = "key_" + std::to_string(i);
+        FieldArray fields = {{"field" + std::to_string(i), "value_" + std::to_string(i)}};
+        Fields f(fields);
+        Status status = db_->PutFields(WriteOptions(), Slice(key), f);
+        EXPECT_TRUE(status.ok()) << "Failed to put fields for key: " << key;
+    }
+
+    // 批量删除一半的字段
+    for (size_t i = 0; i < num_fields / 2; ++i) {
         std::string key = "key_" + std::to_string(i);
-        FieldArray fields = {{"field1", "value1_"}, {"field2", "value2_"}};
-        data_to_insert[key] = Fields(fields);
+        Status status = db_->Delete(WriteOptions(), key);
+        EXPECT_TRUE(status.ok()) << "Failed to delete key: " << key;
+    }
 
-        Fields ffields = Fields(fields);
+    // 验证删除后的字段数量和内容
+    for (size_t i = 0; i < num_fields; ++i) {
+        std::string key = "key_" + std::to_string(i);
+        Fields fields;
+        Status status = db_->GetFields(ReadOptions(), Slice(key), fields);
 
-        // 将序列化后的字段添加到 WriteBatch 中
+        if (i < num_fields / 2) {
+            EXPECT_FALSE(status.ok()) << "Deleted key still exists: " << key;
+        } else {
+            EXPECT_TRUE(status.ok()) << "Missing non-deleted key: " << key;
+            auto field_value = fields.GetField("field" + std::to_string(i));
+            EXPECT_EQ(field_value.second, "value_" + std::to_string(i)) << "Incorrect value for non-deleted field: " << key;
+        }
+    }
+}
+
+// 测试批量更新操作
+TEST_F(FieldsTest, TestBulkUpdate) {
+    const size_t num_fields = 500;
+    leveldb::WriteBatch batch;
+
+    // 准备大量字段数据，并通过 PutFields 插入到数据库
+    for (size_t i = 0; i < num_fields; ++i) {
+        std::string key = "key_" + std::to_string(i);
+        FieldArray fields = {{"field" + std::to_string(i), "old_value_" + std::to_string(i)}};
+        Fields f(fields);
+        Status status = db_->PutFields(WriteOptions(), Slice(key), f);
+        EXPECT_TRUE(status.ok()) << "Failed to put fields for key: " << key;
+    }
+
+    // 批量更新一半的字段
+    for (size_t i = 0; i < num_fields / 2; ++i) {
+        std::string key = "key_" + std::to_string(i);
+        FieldArray update_fields = {{"field" + std::to_string(i), "new_value_" + std::to_string(i)}};
+        Fields f(update_fields);
+        Status status = db_->PutFields(WriteOptions(), Slice(key), f);
+        EXPECT_TRUE(status.ok()) << "Failed to update fields for key: " << key;
+    }
+
+    // 验证更新后的字段值
+    for (size_t i = 0; i < num_fields; ++i) {
+        std::string key = "key_" + std::to_string(i);
+        Fields fields;
+        Status status = db_->GetFields(ReadOptions(), Slice(key), fields);
+        EXPECT_TRUE(status.ok()) << "Failed to read key: " << key;
+
+        auto field_value = fields.GetField("field" + std::to_string(i));
+        auto expected_value = (i < num_fields / 2) ? ("new_value_" + std::to_string(i)) : ("old_value_" + std::to_string(i));
+        EXPECT_EQ(field_value.second, expected_value) << "Incorrect value for updated field: " << key;
+    }
+}
+
+// 测试批量插入、序列化/反序列化、删除以及 FindKeysByFields 功能
+TEST_F(FieldsTest, TestBulkInsertSerializeDeleteAndFindKeys) {
+    const size_t num_entries = 500;
+
+    // 准备大量键值对数据，并通过 PutFields 插入到数据库
+    for (size_t i = num_entries; i > 0; --i) {
+        std::string key = "key_" + std::to_string(i);
+        FieldArray fields = {{"field1", "value1_" + std::to_string(i)}, {"field2", "value2_"}};
+        Fields ffields(fields);
         Status status = db_->PutFields(WriteOptions(), Slice(key), ffields);
         EXPECT_TRUE(status.ok()) << "Failed to put fields for key: " << key << ", error: " << status.ToString();
     }
@@ -248,25 +207,29 @@ TEST_F(FieldsTest, TestBulkInsertSortSerializeAndFindKeys) {
     // 验证插入的数据是否正确
     for (size_t i = 1; i <= num_entries; ++i) {
         std::string key = "key_" + std::to_string(i);
-        std::string value;
-        Status status = db_->Get(ReadOptions(), key, &value);
+        Fields fields;
+        Status status = db_->GetFields(ReadOptions(), Slice(key), fields);
         EXPECT_TRUE(status.ok()) << "Failed to read key: " << key << ", error: " << status.ToString();
 
-        // 反序列化并验证字段值
-        Fields f = Fields::ParseValue(value);
-//        EXPECT_EQ(f["field1"], "value1_" + std::to_string(i)) << "Incorrect value for field1 in key: " << key;
-//        EXPECT_EQ(f["field2"], "value2_" + std::to_string(i)) << "Incorrect value for field2 in key: " << key;
+        // 使用 GetField 方法验证字段值
+        auto field1_value = fields.GetField("field1");
+        auto field2_value = fields.GetField("field2");
+
+        EXPECT_EQ(field1_value.second, "value1_" + std::to_string(i)) << "Incorrect value for field1 in key: " << key;
+        EXPECT_EQ(field2_value.second, "value2_") << "Incorrect value for field2 in key: " << key;
     }
 
+    // 使用 Delete 删除第一个键值对
     Status status = db_->Delete(WriteOptions(), "key_1");
+    EXPECT_TRUE(status.ok()) << "Failed to delete key: key_1, error: " << status.ToString();
 
     // 使用 FindKeysByFields 查找包含特定字段的键
     FieldArray fields_to_find = {{"field2", "value2_"}};
     std::vector<std::string> found_keys = Fields::FindKeysByFields(db_, fields_to_find);
 
     // 验证找到的键是否正确
-    EXPECT_EQ(found_keys.size(), num_entries) << "Expected " << num_entries << " keys but found " << found_keys.size();
-    for (size_t i = 1; i <= num_entries; ++i) {
+    EXPECT_EQ(found_keys.size(), num_entries - 1) << "Expected " << num_entries - 1 << " keys but found " << found_keys.size();
+    for (size_t i = 2; i <= num_entries; ++i) {
         std::string expected_key = "key_" + std::to_string(i);
         EXPECT_TRUE(std::find(found_keys.begin(), found_keys.end(), expected_key) != found_keys.end())
             << "Key not found: " << expected_key;
@@ -276,8 +239,6 @@ TEST_F(FieldsTest, TestBulkInsertSortSerializeAndFindKeys) {
     FieldArray no_match_fields = {{"nonexistent_field", ""}};
     found_keys = Fields::FindKeysByFields(db_, no_match_fields);
     EXPECT_TRUE(found_keys.empty()) << "Expected an empty result for non-matching fields.";
-
-    
 }
 
 int main(int argc, char** argv) {