129 lines
4.6 KiB
C++
129 lines
4.6 KiB
C++
/**
|
|
* Copyright (c) 2021 OceanBase
|
|
* OceanBase CE is licensed under Mulan PubL v2.
|
|
* You can use this software according to the terms and conditions of the Mulan PubL v2.
|
|
* You may obtain a copy of Mulan PubL v2 at:
|
|
* http://license.coscl.org.cn/MulanPubL-2.0
|
|
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
|
|
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
|
|
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
|
|
* See the Mulan PubL v2 for more details.
|
|
*/
|
|
|
|
#include <gtest/gtest.h>
|
|
#include "clog/ob_log_entry_header.h"
|
|
#include "share/ob_proposal_id.h"
|
|
|
|
using namespace oceanbase::common;
|
|
namespace oceanbase {
|
|
using namespace clog;
|
|
namespace unittest {
|
|
class TestObLogEntryHeader : public ::testing::Test {
|
|
public:
|
|
virtual void SetUp()
|
|
{}
|
|
virtual void TearDown()
|
|
{}
|
|
};
|
|
|
|
TEST_F(TestObLogEntryHeader, test_ob_log_entry_header)
|
|
{
|
|
const int64_t BUFSIZE = 1 << 11;
|
|
ObLogEntryHeader header;
|
|
ObLogEntryHeader header2;
|
|
ObLogType ltype = OB_LOG_SUBMIT;
|
|
ObPartitionKey partition_key;
|
|
uint64_t log_id = 4;
|
|
int64_t data_len = BUFSIZE >> 1;
|
|
int64_t gts = ::oceanbase::common::ObTimeUtility::current_time();
|
|
int64_t tts = ::oceanbase::common::ObTimeUtility::current_time();
|
|
ObProposalID rts;
|
|
rts.ts_ = ::oceanbase::common::ObTimeUtility::current_time();
|
|
uint64_t tid = 2;
|
|
int32_t pid = 3;
|
|
int32_t p_count = 10;
|
|
int64_t pos = 0;
|
|
char data[data_len];
|
|
char buf[BUFSIZE];
|
|
|
|
memset(data, 'A', data_len);
|
|
partition_key.init(tid, pid, p_count);
|
|
|
|
// test_generate_entry_header
|
|
EXPECT_EQ(OB_SUCCESS,
|
|
header.generate_header(
|
|
OB_LOG_SUBMIT, partition_key, log_id, data, data_len, gts, tts, rts, 0, ObVersion(0), true));
|
|
header2.shallow_copy(header);
|
|
EXPECT_EQ(header.get_data_checksum(), header2.get_data_checksum());
|
|
EXPECT_EQ(header.get_header_checksum(), header2.get_header_checksum());
|
|
EXPECT_TRUE(header == header2);
|
|
|
|
// test_check
|
|
EXPECT_TRUE(header.check_data_checksum(data, data_len));
|
|
EXPECT_TRUE(header.check_integrity(data, data_len));
|
|
|
|
EXPECT_FALSE(header.check_data_checksum(data, 0));
|
|
EXPECT_FALSE(header.check_data_checksum(NULL, data_len));
|
|
EXPECT_FALSE(header.check_integrity(data, -1)); // check data checksum fail
|
|
|
|
// test_get_and_set
|
|
EXPECT_EQ(header2.get_magic_num(), header.get_magic_num());
|
|
EXPECT_EQ(header2.get_version(), header.get_version());
|
|
EXPECT_EQ(ltype, header.get_log_type());
|
|
EXPECT_EQ(tid, header.get_partition_key().table_id_);
|
|
EXPECT_EQ(pid, header.get_partition_key().get_partition_id());
|
|
EXPECT_EQ(log_id, header.get_log_id());
|
|
EXPECT_EQ(gts, header.get_generation_timestamp());
|
|
EXPECT_EQ(tts, header.get_epoch_id());
|
|
EXPECT_EQ(rts, header.get_proposal_id());
|
|
EXPECT_EQ(data_len, header.get_data_len());
|
|
EXPECT_EQ(data_len + header.get_serialize_size(), header.get_total_len());
|
|
|
|
int64_t ts = ::oceanbase::common::ObTimeUtility::current_time();
|
|
rts.ts_ = ts;
|
|
header.set_epoch_id(ts);
|
|
header.set_proposal_id(rts);
|
|
EXPECT_EQ(ts, header.get_epoch_id());
|
|
EXPECT_EQ(ts, header.get_proposal_id().ts_);
|
|
|
|
// test_serialize_and_deserialize
|
|
CLOG_LOG(INFO, "before serialize", "header", to_cstring(header2));
|
|
EXPECT_EQ(OB_INVALID_ARGUMENT, header2.serialize(buf, 0, pos));
|
|
EXPECT_EQ(OB_INVALID_ARGUMENT, header2.serialize(NULL, 0, pos));
|
|
EXPECT_EQ(OB_SERIALIZE_ERROR, header2.serialize(buf, 1, pos)); // buf is too small
|
|
EXPECT_EQ(OB_SUCCESS, header2.serialize(buf, BUFSIZE, pos));
|
|
header2.reset();
|
|
EXPECT_TRUE(header2.check_data_checksum(NULL, 0));
|
|
EXPECT_FALSE(header2.check_integrity(buf, data_len)); // magic = 0
|
|
EXPECT_NE(header.get_header_checksum(), header2.get_header_checksum());
|
|
|
|
pos = 0;
|
|
CLOG_LOG(INFO, "after reset", "header", to_cstring(header2));
|
|
EXPECT_EQ(OB_INVALID_ARGUMENT, header2.deserialize(NULL, data_len, pos));
|
|
EXPECT_EQ(OB_INVALID_ARGUMENT, header2.deserialize(buf, -1, pos));
|
|
EXPECT_EQ(OB_DESERIALIZE_ERROR, header2.deserialize(buf, 1, pos)); // buf is too small
|
|
EXPECT_EQ(OB_SUCCESS, header2.deserialize(buf, data_len, pos));
|
|
CLOG_LOG(INFO, "after serialize", "header", to_cstring(header2));
|
|
|
|
EXPECT_TRUE(header2.check_integrity(data, data_len));
|
|
|
|
buf[3] = 'B';
|
|
pos = 0;
|
|
EXPECT_EQ(OB_SUCCESS, header2.deserialize(buf, data_len, pos));
|
|
EXPECT_FALSE(header2.check_integrity(data, data_len)); // data checksum fail
|
|
|
|
header2.to_string(buf, data_len);
|
|
}
|
|
|
|
} // end namespace unittest
|
|
} // end namespace oceanbase
|
|
|
|
int main(int argc, char** argv)
|
|
{
|
|
OB_LOGGER.set_file_name("test_ob_log_entry_header.log", true);
|
|
OB_LOGGER.set_log_level("INFO");
|
|
CLOG_LOG(INFO, "begin unittest::test_ob_log_entry_header");
|
|
testing::InitGoogleTest(&argc, argv);
|
|
return RUN_ALL_TESTS();
|
|
}
|