test_compressed_file.cpp File Reference

#include <boost/test/included/unit_test.hpp>
#include <list>
#include <boost/filesystem.hpp>
#include <boost/filesystem/fstream.hpp>
#include <sysio/trace_api/compressed_file.hpp>
#include <sysio/trace_api/test_common.hpp>

Include dependency graph for test_compressed_file.cpp:

Go to the source code of this file.

Classes
struct	temp_file_fixture

Namespaces
namespace	std

Macros
#define	BOOST_TEST_MODULE   trace_compressed_file

Typedefs
typedef std::tuple< uint64_t, std::array< char, 6733 > >	test_types

Functions
template<typename T , size_t S>
std::ostream &	std::operator<< (std::ostream &os, const std::array< T, S > &array)
	BOOST_FIXTURE_TEST_CASE_TEMPLATE (random_access_test, T, test_types, temp_file_fixture)
	BOOST_FIXTURE_TEST_CASE_TEMPLATE (sequential_access, T, test_types, temp_file_fixture)
	BOOST_FIXTURE_TEST_CASE_TEMPLATE (blob_access, T, test_types, temp_file_fixture)
	BOOST_FIXTURE_TEST_CASE_TEMPLATE (blob_access_no_seek_points, T, test_types, temp_file_fixture)

Macro Definition Documentation

BOOST_TEST_MODULE

#define BOOST_TEST_MODULE   trace_compressed_file

Definition at line 1 of file test_compressed_file.cpp.

Typedef Documentation

test_types

typedef std::tuple<uint64_t, std::array<char, 6733> > test_types

Definition at line 46 of file test_compressed_file.cpp.

Function Documentation

BOOST_FIXTURE_TEST_CASE_TEMPLATE() [1/4]

BOOST_FIXTURE_TEST_CASE_TEMPLATE	(	blob_access	,
		T	,
		test_types	,
		temp_file_fixture	)

Definition at line 156 of file test_compressed_file.cpp.

                                                                                {
   // generate a large dataset where ever 8 bytes is the offset to that 8 bytes of data
   auto data = std::vector<T>(128);
   std::generate(data.begin(), data.end(), []() {
      return make_random<T>();
   });
 
   auto uncompressed_filename = create_temp_file(data.data(), data.size() * sizeof(T));
   auto compressed_filename = create_temp_file(nullptr, 0);
 
   BOOST_TEST(compressed_file::process(uncompressed_filename, compressed_filename, 512));
 
   // test that you can read all of the offsets from the compressed form through the end of the file
   for (size_t i = 0; i < data.size(); i++) {
      auto actual_data = std::vector<T>(128);
      auto compf = compressed_file(compressed_filename);
      compf.open();
      compf.seek(i * sizeof(T));
      compf.read(reinterpret_cast<char*>(actual_data.data()), (actual_data.size() - i) * sizeof(T));
      compf.close();
      BOOST_REQUIRE_EQUAL_COLLECTIONS(data.begin() + i, data.end(), actual_data.begin(), actual_data.end() - i);
   }
}

Here is the call graph for this function:

BOOST_FIXTURE_TEST_CASE_TEMPLATE() [2/4]

BOOST_FIXTURE_TEST_CASE_TEMPLATE	(	blob_access_no_seek_points	,
		T	,
		test_types	,
		temp_file_fixture	)

Definition at line 180 of file test_compressed_file.cpp.

                                                                                               {
   // generate a large dataset where ever 8 bytes is the offset to that 8 bytes of data
   auto data = std::vector<T>(32);
   std::generate(data.begin(), data.end(), []() {
      return make_random<T>();
   });
 
   auto uncompressed_size = data.size() * sizeof(T);
   auto uncompressed_filename = create_temp_file(data.data(), uncompressed_size);
   auto compressed_filename = create_temp_file(nullptr, 0);
 
   // set a stride of the whole file which should result in no seek points
   BOOST_TEST(compressed_file::process(uncompressed_filename, compressed_filename, uncompressed_size));
 
   // verify that no seek points were created
   fc::cfile compressed;
   compressed.set_file_path(compressed_filename);
   compressed.open("r");
   compressed.seek(fc::file_size(compressed_filename) - 2);
   const uint16_t expected_seek_point_count = 0;
   uint16_t actual_seek_point_count = std::numeric_limits<uint16_t>::max();
   compressed.read(reinterpret_cast<char*>(&actual_seek_point_count), 2);
   BOOST_REQUIRE_EQUAL(expected_seek_point_count, actual_seek_point_count);
 
   // test that you can read all of the offsets from the compressed form through the end of the file
   for (size_t i = 0; i < data.size(); i++) {
      auto actual_data = std::vector<T>(32);
      auto compf = compressed_file(compressed_filename);
      compf.open();
      compf.seek(i * sizeof(T));
      compf.read(reinterpret_cast<char*>(actual_data.data()), (actual_data.size() - i) * sizeof(T));
      compf.close();
      BOOST_REQUIRE_EQUAL_COLLECTIONS(data.begin() + i, data.end(), actual_data.begin(), actual_data.end() - i);
   }
}

Here is the call graph for this function:

BOOST_FIXTURE_TEST_CASE_TEMPLATE() [3/4]

BOOST_FIXTURE_TEST_CASE_TEMPLATE	(	random_access_test	,
		T	,
		test_types	,
		temp_file_fixture	)

Definition at line 104 of file test_compressed_file.cpp.

                                                                                       {
   // generate a large dataset where ever 8 bytes is the offset to that 8 bytes of data
   auto data = std::vector<T>(128);
   std::generate(data.begin(), data.end(), [offset=0ULL]() mutable {
      auto result = offset;
      offset+=sizeof(T);
      return convert_to<T>(result);
   });
 
   auto uncompressed_filename = create_temp_file(data.data(), data.size() * sizeof(T));
   auto compressed_filename = create_temp_file(nullptr, 0);
 
   BOOST_TEST(compressed_file::process(uncompressed_filename, compressed_filename, 512));
 
   // test that you can read all of the offsets from the compressed form by opening and seeking to them
   for (size_t i = 0; i < data.size(); i++) {
      const auto& entry = data.at(i);
      auto compf = compressed_file(compressed_filename);
      compf.open();
      T value;
      compf.seek((long)i * sizeof(T));
      compf.read(reinterpret_cast<char*>(&value), sizeof(T));
      BOOST_TEST(value == entry);
      compf.close();
   }
}

Here is the call graph for this function:

BOOST_FIXTURE_TEST_CASE_TEMPLATE() [4/4]

BOOST_FIXTURE_TEST_CASE_TEMPLATE	(	sequential_access	,
		T	,
		test_types	,
		temp_file_fixture	)

Definition at line 131 of file test_compressed_file.cpp.

                                                                                      {
   // generate a large dataset where ever 8 bytes is the offset to that 8 bytes of data
   auto data = std::vector<T>(128);
   std::generate(data.begin(), data.end(), [offset=0ULL]() mutable {
      auto result = offset;
      offset+=sizeof(T);
      return convert_to<T>(result);
   });
 
   auto uncompressed_filename = create_temp_file(data.data(), data.size() * sizeof(T));
   auto compressed_filename = create_temp_file(nullptr, 0);
 
   BOOST_TEST(compressed_file::process(uncompressed_filename, compressed_filename, 512));
 
   // test that you can read all of the offsets from the compressed form sequentially
   auto compf = compressed_file(compressed_filename);
   compf.open();
   for( const auto& entry : data ) {
      T value;
      compf.read(reinterpret_cast<char*>(&value), sizeof(value));
      BOOST_TEST(value == entry);
   }
   compf.close();
}

Here is the call graph for this function: