tests/test_row.cpp - master - smychkov/SStorage

tests/test_row.cpp
156 строк3 KB
Андрей Смычков
Initial commit: SStorage database implementation
19 апр 2026, 15:53
19 апр 2026, 15:5327e7e35
#include <gtest/gtest.h>
#include "core/row.hpp"

using namespace sstorage;

TEST(RowTest, DefaultConstructor) {
    Row row;
    EXPECT_EQ(row.getTimestamp(), 0);
    EXPECT_TRUE(row.isValid() == false);
}

TEST(RowTest, ConstructorWithTimestampAndData) {
    uint64_t ts = 123456789;
    std::string data = "Test data";
    Row row(ts, data, Encoding::UTF_16);

    EXPECT_EQ(row.getTimestamp(), ts);
    EXPECT_TRUE(row.isValid());
    EXPECT_EQ(row.getData(), data);
}

TEST(RowTest, ConstructorWithU16String) {
    uint64_t ts = 123456789;
    std::u16string data = u"Тест данные";
    Row row(ts, data);

    EXPECT_EQ(row.getTimestamp(), ts);
    EXPECT_TRUE(row.isValid());
}

TEST(RowTest, ConstructorWithU32String) {
    uint64_t ts = 123456789;
    std::u32string data = U"Test data";
    Row row(ts, data);

    EXPECT_EQ(row.getTimestamp(), ts);
    EXPECT_TRUE(row.isValid());
}

TEST(RowTest, SetTimestamp) {
    Row row;
    row.setTimestamp(999999);

    EXPECT_EQ(row.getTimestamp(), 999999);
}

TEST(RowTest, SetData) {
    Row row;
    row.setTimestamp(100);
    row.setData("New data", Encoding::UTF_16);

    EXPECT_EQ(row.getData(), "New data");
    EXPECT_TRUE(row.isValid());
}

TEST(RowTest, SetData16) {
    Row row;
    row.setTimestamp(100);
    std::u16string data = u"Unicode data";
    row.setData16(data);

    EXPECT_EQ(row.getData16(), data);
    EXPECT_TRUE(row.isValid());
}

TEST(RowTest, SetData32) {
    Row row;
    row.setTimestamp(100);
    std::u32string data = U"Unicode data";
    row.setData32(data);

    EXPECT_EQ(row.getData32(), data);
    EXPECT_TRUE(row.isValid());
}

TEST(RowTest, GetSizeInBytes) {
    std::string data = "Test";
    Row row(123, data, Encoding::UTF_16);

    size_t size = row.getSizeInBytes();
    EXPECT_GT(size, 0);
}

TEST(RowTest, IsValid) {
    Row invalidRow;
    EXPECT_FALSE(invalidRow.isValid());

    Row validRow(123, "Test", Encoding::UTF_16);
    EXPECT_TRUE(validRow.isValid());
}

TEST(RowTest, ComparisonOperators) {
    Row row1(100, "Data1", Encoding::UTF_16);
    Row row2(200, "Data2", Encoding::UTF_16);

    EXPECT_TRUE(row1 < row2);
    EXPECT_FALSE(row1 == row2);
    EXPECT_TRUE(row1 != row2);
}

TEST(RowTest, ComparisonOperatorsEqual) {
    Row row1(100, "Data", Encoding::UTF_16);
    Row row2(100, "Data", Encoding::UTF_16);

    EXPECT_FALSE(row1 < row2);
    EXPECT_TRUE(row1 == row2);
    EXPECT_FALSE(row1 != row2);
}

TEST(RowTest, ConvertToU16) {
    std::string data = "Test";
    auto u16 = Row::convertToU16(data);

    EXPECT_FALSE(u16.empty());
}

TEST(RowTest, ConvertToU32) {
    std::string data = "Test";
    auto u32 = Row::convertToU32(data);

    EXPECT_FALSE(u32.empty());
}

TEST(RowTest, ConvertFromU16) {
    std::u16string data = u"Test";
    auto result = Row::convertFromU16(data);

    EXPECT_EQ(result, "Test");
}

TEST(RowTest, ConvertFromU32) {
    std::u32string data = U"Test";
    auto result = Row::convertFromU32(data);

    EXPECT_EQ(result, "Test");
}

TEST(RowTest, CalculateEncodedSize) {
    std::string data = "Test";

    size_t size16 = Row::calculateEncodedSize(data, Encoding::UTF_16);
    size_t size32 = Row::calculateEncodedSize(data, Encoding::UTF_32);
    size_t size8 = Row::calculateEncodedSize(data, Encoding::UTF_8);

    EXPECT_GT(size16, 0);
    EXPECT_GT(size32, 0);
    EXPECT_GT(size8, 0);
}

TEST(RowTest, ChineseCharacters) {
    std::string chinese = "你好世界";
    Row row(123, chinese, Encoding::UTF_16);

    EXPECT_TRUE(row.isValid());
    EXPECT_FALSE(row.getData().empty());
}