[rhmessaging-commits] rhmessaging commits: r1333 - in store/trunk/cpp: tests/jrnl and 1 other directory.
rhmessaging-commits at lists.jboss.org
rhmessaging-commits at lists.jboss.org
Mon Nov 19 00:46:53 EST 2007
Author: kpvdr
Date: 2007-11-19 00:46:53 -0500 (Mon, 19 Nov 2007)
New Revision: 1333
Added:
store/trunk/cpp/tests/jrnl/unit_test_enq_map.cpp
store/trunk/cpp/tests/jrnl/unit_test_file_hdr.cpp
Modified:
store/trunk/cpp/lib/jrnl/file_hdr.cpp
store/trunk/cpp/lib/jrnl/file_hdr.hpp
store/trunk/cpp/tests/jrnl/Makefile.am
Log:
Additional unit tests for the journal
Modified: store/trunk/cpp/lib/jrnl/file_hdr.cpp
===================================================================
--- store/trunk/cpp/lib/jrnl/file_hdr.cpp 2007-11-17 14:31:19 UTC (rev 1332)
+++ store/trunk/cpp/lib/jrnl/file_hdr.cpp 2007-11-19 05:46:53 UTC (rev 1333)
@@ -88,7 +88,7 @@
// ***** struct rec_tail *****
rec_tail::rec_tail():
- _xmagic(0xffffff), // 1's complement of 0
+ _xmagic(0xffffffff), // 1's complement of 0
_rid(0)
{}
@@ -180,7 +180,7 @@
}
void
-file_hdr::set_time(timespec ts)
+file_hdr::set_time(timespec& ts)
{
_ts_sec = ts.tv_sec;
_ts_nsec = ts.tv_nsec;
Modified: store/trunk/cpp/lib/jrnl/file_hdr.hpp
===================================================================
--- store/trunk/cpp/lib/jrnl/file_hdr.hpp 2007-11-17 14:31:19 UTC (rev 1332)
+++ store/trunk/cpp/lib/jrnl/file_hdr.hpp 2007-11-19 05:46:53 UTC (rev 1333)
@@ -245,7 +245,7 @@
* \brief Sets the timestamp in the struct to the provided value (in seconds and
* nanoseconds).
*/
- void set_time(timespec ts);
+ void set_time(timespec& ts);
/**
* \brief Returns the size of the header in bytes.
Modified: store/trunk/cpp/tests/jrnl/Makefile.am
===================================================================
--- store/trunk/cpp/tests/jrnl/Makefile.am 2007-11-17 14:31:19 UTC (rev 1332)
+++ store/trunk/cpp/tests/jrnl/Makefile.am 2007-11-19 05:46:53 UTC (rev 1333)
@@ -30,6 +30,8 @@
unit_test_jerrno \
unit_test_jinf \
unit_test_jdir \
+ unit_test_file_hdr \
+ unit_test_enq_map \
run-journal-tests
check_LTLIBRARIES = \
@@ -40,7 +42,9 @@
unit_test_jexception \
unit_test_jerrno \
unit_test_jinf \
- unit_test_jdir
+ unit_test_jdir \
+ unit_test_enq_map \
+ unit_test_file_hdr
unit_test_jexception_SOURCES = unit_test_jexception.cpp
unit_test_jexception_LDFLAGS = -lboost_unit_test_framework -lbdbstore -L../../lib/.libs
@@ -54,6 +58,12 @@
unit_test_jdir_SOURCES = unit_test_jdir.cpp
unit_test_jdir_LDFLAGS = -lboost_unit_test_framework -lbdbstore -lrt -L../../lib/.libs
+unit_test_file_hdr_SOURCES = unit_test_file_hdr.cpp
+unit_test_file_hdr_LDFLAGS = -lboost_unit_test_framework -lbdbstore -lrt -L../../lib/.libs
+
+unit_test_enq_map_SOURCES = unit_test_enq_map.cpp
+unit_test_enq_map_LDFLAGS = -lboost_unit_test_framework -lbdbstore -lrt -L../../lib/.libs
+
JournalSystemTests_la_SOURCES = \
JournalSystemTests.cpp \
JournalSystemTests.hpp
Added: store/trunk/cpp/tests/jrnl/unit_test_enq_map.cpp
===================================================================
--- store/trunk/cpp/tests/jrnl/unit_test_enq_map.cpp (rev 0)
+++ store/trunk/cpp/tests/jrnl/unit_test_enq_map.cpp 2007-11-19 05:46:53 UTC (rev 1333)
@@ -0,0 +1,261 @@
+/**
+* \file unit_test_enq_map.cpp
+*
+* Red Hat Messaging - Message Journal
+*
+* This file contains the unit tests for the journal.
+*
+* \author Kim van der Riet
+*
+* Copyright 2007 Red Hat, Inc.
+*
+* This file is part of Red Hat Messaging.
+*
+* Red Hat Messaging is free software; you can redistribute it and/or
+* modify it under the terms of the GNU Lesser General Public
+* License as published by the Free Software Foundation; either
+* version 2.1 of the License, or (at your option) any later version.
+*
+* This library is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+* Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public
+* License along with this library; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
+* USA
+*
+* The GNU Lesser General Public License is available in the file COPYING.
+*/
+
+#include <boost/test/results_reporter.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/test/unit_test_log.hpp>
+#include <iostream>
+#include <jrnl/enq_map.hpp>
+#include <jrnl/jerrno.hpp>
+
+using namespace boost::unit_test;
+using namespace rhm::journal;
+
+// Test functions of the form
+// void fn() {...}
+
+void test_constructor()
+{
+ enq_map e1;
+ BOOST_CHECK(e1.empty());
+ BOOST_CHECK_EQUAL(e1.size(), 0);
+}
+
+void test_insert_get()
+{
+ u_int16_t fid;
+ u_int64_t rid;
+ u_int16_t fid_start = 0x2000U;
+ u_int64_t rid_begin = 0xffffffff00000000ULL;
+ u_int64_t rid_end = 0xffffffff00000200ULL;
+
+ // insert with no dups
+ u_int64_t rid_incr_1 = 4ULL;
+ enq_map e2;
+ for (rid = rid_begin, fid = fid_start; rid < rid_end; rid += rid_incr_1, fid++)
+ e2.insert_fid(rid, fid);
+ BOOST_CHECK(!e2.empty());
+ BOOST_CHECK_EQUAL(e2.size(), 128);
+
+ // get
+ u_int64_t rid_incr_2 = 6ULL;
+ for (u_int64_t rid = rid_begin; rid < rid_end; rid += rid_incr_2)
+ {
+ BOOST_CHECK_EQUAL(e2.is_enqueued(rid), (rid%rid_incr_1 ? false : true));
+ try
+ {
+ u_int16_t exp_fid = fid_start + (u_int16_t)((rid - rid_begin)/rid_incr_1);
+ u_int16_t ret_fid = e2.get_fid(rid);
+ BOOST_CHECK_EQUAL(ret_fid, exp_fid);
+ BOOST_CHECK(rid%rid_incr_1 == 0);
+ }
+ catch (const jexception& e)
+ {
+ BOOST_CHECK_EQUAL(e.err_code(), jerrno::JERR_MAP_NOTFOUND);
+ BOOST_CHECK(rid%rid_incr_1);
+ }
+ if ((rid + rid_incr_2)%(8 * rid_incr_2) == 0)
+ fid++;
+ }
+
+ // insert with dups
+ for (rid = rid_begin, fid = fid_start; rid < rid_end; rid += rid_incr_2, fid++)
+ {
+ try
+ {
+ e2.insert_fid(rid, fid);
+ BOOST_CHECK(rid%rid_incr_1);
+ }
+ catch (const jexception& e)
+ {
+ BOOST_CHECK_EQUAL(e.err_code(), jerrno::JERR_MAP_DUPLICATE);
+ BOOST_CHECK(rid%rid_incr_1 == 0);
+ }
+ }
+ BOOST_CHECK_EQUAL(e2.size(), 171ULL);
+ e2.clear();
+ BOOST_CHECK(e2.empty());
+ BOOST_CHECK_EQUAL(e2.size(), 0);
+}
+
+void test_get_remove()
+{
+ u_int16_t fid;
+ u_int64_t rid;
+ u_int16_t fid_start = 0x3000U;
+ u_int64_t rid_begin = 0xeeeeeeee00000000ULL;
+ u_int64_t rid_end = 0xeeeeeeee00000200ULL;
+
+ u_int64_t rid_incr_1 = 4ULL;
+ u_int64_t num_incr_1 = (rid_end - rid_begin)/rid_incr_1;
+ enq_map e3;
+ for (rid = rid_begin, fid = fid_start; rid < rid_end; rid += rid_incr_1, fid++)
+ e3.insert_fid(rid, fid);
+ BOOST_CHECK_EQUAL(e3.size(), num_incr_1);
+
+ u_int64_t rid_incr_2 = 6ULL;
+ for (rid = rid_begin, fid = fid_start; rid < rid_end; rid += rid_incr_2, fid++)
+ {
+ try
+ {
+ u_int16_t exp_fid = fid_start + (u_int16_t)((rid - rid_begin)/rid_incr_1);
+ u_int16_t ret_fid = e3.get_remove_fid(rid);
+ BOOST_CHECK_EQUAL(ret_fid, exp_fid);
+ BOOST_CHECK(rid%rid_incr_1 == 0);
+ }
+ catch (const jexception& e)
+ {
+ BOOST_CHECK_EQUAL(e.err_code(), jerrno::JERR_MAP_NOTFOUND);
+ BOOST_CHECK(rid%rid_incr_1);
+ }
+ }
+ BOOST_CHECK_EQUAL(e3.size(), 85ULL);
+}
+
+void test_lock()
+{
+ u_int16_t fid;
+ u_int64_t rid;
+ u_int16_t fid_start = 0x4000U;
+ u_int64_t rid_begin = 0xdddddddd00000000ULL;
+ u_int64_t rid_end = 0xdddddddd00000200ULL;
+
+ // insert, every second entry is locked
+ u_int64_t rid_incr_1 = 4ULL;
+ u_int64_t num_incr_1 = (rid_end - rid_begin)/rid_incr_1;
+ bool locked = false;
+ enq_map e4;
+ for (rid = rid_begin, fid = fid_start; rid < rid_end; rid += rid_incr_1, fid++)
+ {
+ e4.insert_fid(rid, fid, locked);
+ locked = !locked;
+ }
+ BOOST_CHECK_EQUAL(e4.size(), num_incr_1);
+
+ // unlock and lock non-existent rids
+ try
+ {
+ e4.lock(1ULL);
+ BOOST_ERROR("Failed to throw exception when locking non-existent rid.");
+ }
+ catch (const jexception& e) { BOOST_CHECK_EQUAL(e.err_code(), jerrno::JERR_MAP_NOTFOUND); }
+ try
+ {
+ e4.unlock(2ULL);
+ BOOST_ERROR("Failed to throw exception when locking non-existent rid.");
+ }
+ catch (const jexception& e) { BOOST_CHECK_EQUAL(e.err_code(), jerrno::JERR_MAP_NOTFOUND); }
+
+ // get / unlock
+ for (u_int64_t rid = rid_begin; rid < rid_end; rid += rid_incr_1)
+ {
+ try { e4.get_fid(rid); }
+ catch(const jexception& e)
+ {
+ BOOST_CHECK_EQUAL(e.err_code(), jerrno::JERR_MAP_LOCKED);
+ BOOST_CHECK(rid%(2*rid_incr_1));
+ // unlock, read, then relock
+ e4.unlock(rid);
+ e4.get_fid(rid);
+ e4.lock(rid);
+ try
+ {
+ e4.get_fid(rid);
+ BOOST_ERROR("Failed to throw exception when getting locked record");
+ }
+ catch(const jexception& e)
+ {
+ BOOST_CHECK_EQUAL(e.err_code(), jerrno::JERR_MAP_LOCKED);
+ }
+ }
+ }
+
+ // remove all; if locked, use with txn_flag true; should ignore all locked records
+ for (u_int64_t rid = rid_begin; rid < rid_end; rid += rid_incr_1)
+ e4.get_remove_fid(rid, true);
+ BOOST_CHECK(e4.empty());
+}
+
+void test_lists()
+{
+ u_int16_t fid;
+ u_int64_t rid;
+ u_int16_t fid_start = 0x5000UL;
+ u_int64_t rid_begin = 0xdddddddd00000000ULL;
+ u_int64_t rid_end = 0xdddddddd00000200ULL;
+
+ // insert, every second entry is locked
+ u_int64_t rid_incr_1 = 4ULL;
+ u_int64_t num_incr_1 = (rid_end - rid_begin)/rid_incr_1;
+ std::vector<u_int64_t> rid_list;
+ std::vector<u_int16_t> fid_list;
+ enq_map e5;
+ for (rid = rid_begin, fid = fid_start; rid < rid_end; rid += rid_incr_1, fid++)
+ {
+ e5.insert_fid(rid, fid);
+ rid_list.push_back(rid);
+ fid_list.push_back(fid);
+ }
+ BOOST_CHECK_EQUAL(e5.size(), num_incr_1);
+ BOOST_CHECK_EQUAL(rid_list.size(), num_incr_1);
+ BOOST_CHECK_EQUAL(fid_list.size(), num_incr_1);
+
+ std::vector<u_int64_t> ret_rid_list;
+ e5.rid_list(ret_rid_list);
+ BOOST_CHECK_EQUAL(ret_rid_list.size(), num_incr_1);
+ for (unsigned i=0; i<ret_rid_list.size(); i++)
+ BOOST_CHECK_EQUAL(rid_list[i], ret_rid_list[i]);
+
+ std::vector<u_int16_t> ret_fid_list;
+ e5.fid_list(ret_fid_list);
+ BOOST_CHECK_EQUAL(ret_fid_list.size(), num_incr_1);
+ for (unsigned i=0; i<ret_fid_list.size(); i++)
+ BOOST_CHECK_EQUAL(fid_list[i], ret_fid_list[i]);
+}
+
+// Initialize test suite and include test functions
+
+test_suite* init_unit_test_suite(int, char**)
+{
+ std::cout << "--------" << std::endl << "unit_test_enq_map: ";
+ test_suite* ts = BOOST_TEST_SUITE("unit_test_enq_map");
+
+ results_reporter::set_level(SHORT_REPORT);
+ unit_test_log_t::instance().set_threshold_level(log_messages);
+
+ ts->add(BOOST_TEST_CASE(&test_constructor));
+ ts->add(BOOST_TEST_CASE(&test_insert_get));
+ ts->add(BOOST_TEST_CASE(&test_get_remove));
+ ts->add(BOOST_TEST_CASE(&test_lock));
+ ts->add(BOOST_TEST_CASE(&test_lists));
+
+ return ts;
+}
Added: store/trunk/cpp/tests/jrnl/unit_test_file_hdr.cpp
===================================================================
--- store/trunk/cpp/tests/jrnl/unit_test_file_hdr.cpp (rev 0)
+++ store/trunk/cpp/tests/jrnl/unit_test_file_hdr.cpp 2007-11-19 05:46:53 UTC (rev 1333)
@@ -0,0 +1,382 @@
+/**
+* \file unit_test_file_hdr.cpp
+*
+* Red Hat Messaging - Message Journal
+*
+* This file contains the unit tests for the journal.
+*
+* \author Kim van der Riet
+*
+* Copyright 2007 Red Hat, Inc.
+*
+* This file is part of Red Hat Messaging.
+*
+* Red Hat Messaging is free software; you can redistribute it and/or
+* modify it under the terms of the GNU Lesser General Public
+* License as published by the Free Software Foundation; either
+* version 2.1 of the License, or (at your option) any later version.
+*
+* This library is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+* Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public
+* License along with this library; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
+* USA
+*
+* The GNU Lesser General Public License is available in the file COPYING.
+*/
+
+#include <boost/test/results_reporter.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/test/unit_test_log.hpp>
+#include <jrnl/file_hdr.hpp>
+#include <jrnl/jcfg.hpp>
+
+using namespace boost::unit_test;
+using namespace rhm::journal;
+
+// Test functions of the form
+// void fn() {...}
+
+void test_hdr()
+{
+ hdr h1;
+ BOOST_CHECK_EQUAL(h1._magic, 0UL);
+ BOOST_CHECK_EQUAL(h1._version, 0);
+ BOOST_CHECK_EQUAL(h1._eflag, 0);
+ BOOST_CHECK_EQUAL(h1._uflag, 0);
+ BOOST_CHECK_EQUAL(h1._rid, 0ULL);
+
+ const u_int32_t magic = 0x89abcdefUL;
+ const u_int8_t version = 0xef;
+ const u_int16_t uflag = 0xabcd;
+ const u_int64_t rid = 0x123456789abcdef0ULL;
+
+ hdr h2(magic, version, uflag, rid);
+ BOOST_CHECK_EQUAL(h2._magic, magic);
+ BOOST_CHECK_EQUAL(h2._version, version);
+#ifdef JRNL_LITTLE_ENDIAN
+ BOOST_CHECK_EQUAL(h2._eflag, RHM_LENDIAN_FLAG);
+#else
+ BOOST_CHECK_EQUAL(h2._eflag, RHM_BENDIAN_FLAG);
+#endif
+ BOOST_CHECK_EQUAL(h2._uflag, uflag);
+ BOOST_CHECK_EQUAL(h2._rid, rid);
+
+ h1.copy(h2);
+ BOOST_CHECK_EQUAL(h1._magic, magic);
+ BOOST_CHECK_EQUAL(h1._version, version);
+#ifdef JRNL_LITTLE_ENDIAN
+ BOOST_CHECK_EQUAL(h1._eflag, RHM_LENDIAN_FLAG);
+#else
+ BOOST_CHECK_EQUAL(h1._eflag, RHM_BENDIAN_FLAG);
+#endif
+ BOOST_CHECK_EQUAL(h1._uflag, uflag);
+ BOOST_CHECK_EQUAL(h1._rid, rid);
+
+ h1.reset();
+ BOOST_CHECK_EQUAL(h1._magic, 0UL);
+ BOOST_CHECK_EQUAL(h1._version, 0);
+ BOOST_CHECK_EQUAL(h1._eflag, 0);
+ BOOST_CHECK_EQUAL(h1._uflag, 0);
+ BOOST_CHECK_EQUAL(h1._rid, 0ULL);
+}
+
+void test_rec_tail()
+{
+ const u_int32_t magic = 0xfedcba98;
+ const u_int64_t rid = 0xfedcba9876543210ULL;
+ const u_int32_t xmagic = ~magic;
+
+ {
+ rec_tail rt1;
+ BOOST_CHECK_EQUAL(rt1._xmagic, 0xffffffffUL);
+ BOOST_CHECK_EQUAL(rt1._rid, 0ULL);
+ }
+
+ {
+ rec_tail rt2(magic, rid);
+ BOOST_CHECK_EQUAL(rt2._xmagic, magic);
+ BOOST_CHECK_EQUAL(rt2._rid, rid);
+ }
+
+ {
+ hdr h(magic, RHM_JDAT_VERSION, 0, rid);
+ rec_tail rt3(h);
+ BOOST_CHECK_EQUAL(rt3._xmagic, xmagic);
+ BOOST_CHECK_EQUAL(rt3._rid, rid);
+ }
+}
+
+void test_file_hdr()
+{
+ const u_int32_t magic = 0xfedcba98UL;
+ const u_int8_t version = 0xa5;
+ const u_int16_t uflag = 0x1234;
+ const u_int64_t rid = 0xfedcba9876543210ULL;
+ const u_int32_t fid = 0xfedcba98UL;
+#ifdef JRNL_32_BIT
+ const size_t fro = 0xfedcba98UL;
+#else
+ const size_t fro = 0xfedcba9876543210ULL;
+#endif
+ timespec ts;
+
+ {
+ file_hdr fh1;
+ BOOST_CHECK_EQUAL(fh1._hdr._magic, 0UL);
+ BOOST_CHECK_EQUAL(fh1._hdr._version, 0);
+ BOOST_CHECK_EQUAL(fh1._hdr._eflag, 0);
+ BOOST_CHECK_EQUAL(fh1._hdr._uflag, 0);
+ BOOST_CHECK_EQUAL(fh1._hdr._rid, 0ULL);
+ BOOST_CHECK_EQUAL(fh1._fid, 0UL);
+#ifdef JRNL_32_BIT
+ BOOST_CHECK_EQUAL(fh1._fro, 0UL);
+ BOOST_CHECK_EQUAL(fh1._ts_sec, 0L);
+ BOOST_CHECK_EQUAL(fh1._ts_nsec, 0UL);
+#else
+ BOOST_CHECK_EQUAL(fh1._fro, 0ULL);
+ BOOST_CHECK_EQUAL(fh1._ts_sec, 0ULL);
+ BOOST_CHECK_EQUAL(fh1._ts_nsec, 0ULL);
+#endif
+ }
+
+ {
+ file_hdr fh2(magic, version, uflag, rid, fid, fro);
+ BOOST_CHECK_EQUAL(fh2._hdr._magic, magic);
+ BOOST_CHECK_EQUAL(fh2._hdr._version, version);
+#ifdef JRNL_LITTLE_ENDIAN
+ BOOST_CHECK_EQUAL(fh2._hdr._eflag, RHM_LENDIAN_FLAG);
+#else
+ BOOST_CHECK_EQUAL(fh2._hdr._eflag, RHM_BENDIAN_FLAG);
+#endif
+ BOOST_CHECK_EQUAL(fh2._hdr._uflag, uflag);
+ BOOST_CHECK_EQUAL(fh2._hdr._rid, rid);
+ BOOST_CHECK_EQUAL(fh2._fid,fid );
+ BOOST_CHECK_EQUAL(fh2._fro, fro);
+#ifdef JRNL_32_BIT
+ BOOST_CHECK_EQUAL(fh2._ts_sec, 0L);
+ BOOST_CHECK_EQUAL(fh2._ts_nsec, 0UL);
+#else
+ BOOST_CHECK_EQUAL(fh2._ts_sec, 0ULL);
+ BOOST_CHECK_EQUAL(fh2._ts_nsec, 0ULL);
+#endif
+ ::clock_gettime(CLOCK_REALTIME, &ts);
+ fh2.set_time(ts);
+ BOOST_CHECK_EQUAL(fh2._ts_sec, ts.tv_sec);
+ BOOST_CHECK_EQUAL(fh2._ts_nsec, (u_int32_t)ts.tv_nsec);
+ }
+
+ {
+ file_hdr fh3(magic, version, uflag, rid, fid, fro, true);
+ BOOST_CHECK_EQUAL(fh3._hdr._magic, magic);
+ BOOST_CHECK_EQUAL(fh3._hdr._version, version);
+#ifdef JRNL_LITTLE_ENDIAN
+ BOOST_CHECK_EQUAL(fh3._hdr._eflag, RHM_LENDIAN_FLAG);
+#else
+ BOOST_CHECK_EQUAL(fh3._hdr._eflag, RHM_BENDIAN_FLAG);
+#endif
+ BOOST_CHECK_EQUAL(fh3._hdr._uflag, uflag);
+ BOOST_CHECK_EQUAL(fh3._hdr._rid, rid);
+ BOOST_CHECK_EQUAL(fh3._fid, fid);
+ BOOST_CHECK_EQUAL(fh3._fro, fro);
+ BOOST_CHECK(fh3._ts_sec - ts.tv_sec <= 1); // No more than 1 sec difference
+ }
+}
+
+void test_enq_hdr()
+{
+ const u_int32_t magic = 0xfedcba98UL;
+ const u_int8_t version = 0xa5;
+ const u_int64_t rid = 0xfedcba9876543210ULL;
+#ifdef JRNL_32_BIT
+ const size_t xidsize = 0xfedcba98UL;
+ const size_t dsize = 0x76543210UL;
+#else
+ const size_t xidsize = 0xfedcba9876543210ULL;
+ const size_t dsize = 0x76543210fedcba98ULL;
+#endif
+
+ {
+ enq_hdr eh1;
+ BOOST_CHECK_EQUAL(eh1._hdr._magic, 0UL);
+ BOOST_CHECK_EQUAL(eh1._hdr._version, 0);
+ BOOST_CHECK_EQUAL(eh1._hdr._eflag, 0);
+ BOOST_CHECK_EQUAL(eh1._hdr._uflag, 0);
+ BOOST_CHECK_EQUAL(eh1._hdr._rid, 0ULL);
+#ifdef JRNL_32_BIT
+ BOOST_CHECK_EQUAL(eh1._xidsize, 0UL);
+ BOOST_CHECK_EQUAL(eh1._dsize, 0UL);
+#else
+ BOOST_CHECK_EQUAL(eh1._xidsize, 0ULL);
+ BOOST_CHECK_EQUAL(eh1._dsize, 0ULL);
+#endif
+ }
+
+ {
+ enq_hdr eh2(magic, version, rid, xidsize, dsize);
+ BOOST_CHECK_EQUAL(eh2._hdr._magic, magic);
+ BOOST_CHECK_EQUAL(eh2._hdr._version, version);
+#ifdef JRNL_LITTLE_ENDIAN
+ BOOST_CHECK_EQUAL(eh2._hdr._eflag, RHM_LENDIAN_FLAG);
+#else
+ BOOST_CHECK_EQUAL(eh2._hdr._eflag, RHM_BENDIAN_FLAG);
+#endif
+ BOOST_CHECK_EQUAL(eh2._hdr._uflag, 0);
+ BOOST_CHECK_EQUAL(eh2._hdr._rid, rid);
+ BOOST_CHECK_EQUAL(eh2._xidsize, xidsize);
+ BOOST_CHECK_EQUAL(eh2._dsize, dsize);
+ BOOST_CHECK(!eh2.is_transient());
+ BOOST_CHECK(!eh2.is_external());
+
+ eh2.set_transient(true);
+ BOOST_CHECK_EQUAL(eh2._hdr._uflag, enq_hdr::ENQ_HDR_TRANSIENT_MASK);
+ BOOST_CHECK(eh2.is_transient());
+ BOOST_CHECK(!eh2.is_external());
+
+ eh2.set_transient(false);
+ BOOST_CHECK_EQUAL(eh2._hdr._uflag, 0);
+ BOOST_CHECK(!eh2.is_transient());
+ BOOST_CHECK(!eh2.is_external());
+
+ eh2.set_external(true);
+ BOOST_CHECK_EQUAL(eh2._hdr._uflag, enq_hdr::ENQ_HDR_EXTERNAL_MASK);
+ BOOST_CHECK(!eh2.is_transient());
+ BOOST_CHECK(eh2.is_external());
+
+ eh2.set_external(false);
+ BOOST_CHECK_EQUAL(eh2._hdr._uflag, 0);
+ BOOST_CHECK(!eh2.is_transient());
+ BOOST_CHECK(!eh2.is_external());
+
+ eh2.set_transient(true);
+ eh2.set_external(true);
+ BOOST_CHECK_EQUAL(eh2._hdr._uflag,
+ enq_hdr::ENQ_HDR_TRANSIENT_MASK | enq_hdr::ENQ_HDR_EXTERNAL_MASK);
+ }
+
+ {
+ enq_hdr eh3(magic, version, rid, xidsize, dsize, true);
+ BOOST_CHECK_EQUAL(eh3._hdr._magic, magic);
+ BOOST_CHECK_EQUAL(eh3._hdr._version, version);
+#ifdef JRNL_LITTLE_ENDIAN
+ BOOST_CHECK_EQUAL(eh3._hdr._eflag, RHM_LENDIAN_FLAG);
+#else
+ BOOST_CHECK_EQUAL(eh3._hdr._eflag, RHM_BENDIAN_FLAG);
+#endif
+ BOOST_CHECK_EQUAL(eh3._hdr._uflag, enq_hdr::ENQ_HDR_TRANSIENT_MASK);
+ BOOST_CHECK_EQUAL(eh3._hdr._rid, rid);
+ BOOST_CHECK_EQUAL(eh3._xidsize, xidsize);
+ BOOST_CHECK_EQUAL(eh3._dsize, dsize);
+ BOOST_CHECK(eh3.is_transient());
+ BOOST_CHECK(!eh3.is_external());
+ }
+}
+
+void test_deq_hdr()
+{
+ const u_int32_t magic = 0xfedcba98UL;
+ const u_int8_t version = 0xa5;
+ const u_int16_t uflag = 0x1234;
+ const u_int64_t rid = 0xfedcba9876543210ULL;
+ const u_int64_t drid = 0x76543210fedcba98ULL;
+#ifdef JRNL_32_BIT
+ const size_t xidsize = 0xfedcba98UL;
+#else
+ const size_t xidsize = 0xfedcba9876543210ULL;
+#endif
+
+ {
+ deq_hdr dh1;
+ BOOST_CHECK_EQUAL(dh1._hdr._magic, 0UL);
+ BOOST_CHECK_EQUAL(dh1._hdr._version, 0);
+ BOOST_CHECK_EQUAL(dh1._hdr._eflag, 0);
+ BOOST_CHECK_EQUAL(dh1._hdr._uflag, 0);
+ BOOST_CHECK_EQUAL(dh1._hdr._rid, 0ULL);
+ BOOST_CHECK_EQUAL(dh1._deq_rid, 0ULL);
+#ifdef JRNL_32_BIT
+ BOOST_CHECK_EQUAL(dh1._xidsize, 0UL);
+#else
+ BOOST_CHECK_EQUAL(dh1._xidsize, 0ULL);
+#endif
+ }
+
+ {
+ deq_hdr dh2(magic, version, uflag, rid, drid, xidsize);
+ BOOST_CHECK_EQUAL(dh2._hdr._magic, magic);
+ BOOST_CHECK_EQUAL(dh2._hdr._version, version);
+#ifdef JRNL_LITTLE_ENDIAN
+ BOOST_CHECK_EQUAL(dh2._hdr._eflag, RHM_LENDIAN_FLAG);
+#else
+ BOOST_CHECK_EQUAL(dh2._hdr._eflag, RHM_BENDIAN_FLAG);
+#endif
+ BOOST_CHECK_EQUAL(dh2._hdr._uflag, uflag);
+ BOOST_CHECK_EQUAL(dh2._hdr._rid, rid);
+ BOOST_CHECK_EQUAL(dh2._deq_rid, drid);
+ BOOST_CHECK_EQUAL(dh2._xidsize, xidsize);
+ }
+}
+
+void test_txn_hdr()
+{
+ const u_int32_t magic = 0xfedcba98UL;
+ const u_int8_t version = 0xa5;
+ const u_int16_t uflag = 0x1234;
+ const u_int64_t rid = 0xfedcba9876543210ULL;
+#ifdef JRNL_32_BIT
+ const size_t xidsize = 0xfedcba98UL;
+#else
+ const size_t xidsize = 0xfedcba9876543210ULL;
+#endif
+
+ {
+ txn_hdr th1;
+ BOOST_CHECK_EQUAL(th1._hdr._magic, 0UL);
+ BOOST_CHECK_EQUAL(th1._hdr._version, 0);
+ BOOST_CHECK_EQUAL(th1._hdr._eflag, 0);
+ BOOST_CHECK_EQUAL(th1._hdr._uflag, 0);
+ BOOST_CHECK_EQUAL(th1._hdr._rid, 0ULL);
+#ifdef JRNL_32_BIT
+ BOOST_CHECK_EQUAL(th1._xidsize, 0UL);
+#else
+ BOOST_CHECK_EQUAL(th1._xidsize, 0ULL);
+#endif
+ }
+
+ {
+ txn_hdr th2(magic, version, uflag, rid, xidsize);
+ BOOST_CHECK_EQUAL(th2._hdr._magic, magic);
+ BOOST_CHECK_EQUAL(th2._hdr._version, version);
+#ifdef JRNL_LITTLE_ENDIAN
+ BOOST_CHECK_EQUAL(th2._hdr._eflag, RHM_LENDIAN_FLAG);
+#else
+ BOOST_CHECK_EQUAL(th2._hdr._eflag, RHM_BENDIAN_FLAG);
+#endif
+ BOOST_CHECK_EQUAL(th2._hdr._uflag, uflag);
+ BOOST_CHECK_EQUAL(th2._hdr._rid, rid);
+ BOOST_CHECK_EQUAL(th2._xidsize, xidsize);
+ }
+}
+
+// Initialize test suite and include test functions
+
+test_suite* init_unit_test_suite(int, char**)
+{
+ std::cout << "--------" << std::endl << "unit_test_file_hdr: ";
+ test_suite* ts = BOOST_TEST_SUITE("unit_test_file_hdr");
+
+ results_reporter::set_level(SHORT_REPORT);
+ unit_test_log_t::instance().set_threshold_level(log_messages);
+
+ ts->add(BOOST_TEST_CASE(&test_hdr));
+ ts->add(BOOST_TEST_CASE(&test_rec_tail));
+ ts->add(BOOST_TEST_CASE(&test_file_hdr));
+ ts->add(BOOST_TEST_CASE(&test_enq_hdr));
+ ts->add(BOOST_TEST_CASE(&test_deq_hdr));
+ ts->add(BOOST_TEST_CASE(&test_txn_hdr));
+
+ return ts;
+}
More information about the rhmessaging-commits
mailing list