serialize.test.cc

Go to the documentation of this file.

/*
 * Copyright 2021 Daniel R. Carvalho
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met: redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer;
 * redistributions in binary form must reproduce the above copyright
 * notice, this list of conditions and the following disclaimer in the
 * documentation and/or other materials provided with the distribution;
 * neither the name of the copyright holders nor the names of its
 * contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
#include <gmock/gmock.h>
#include <gtest/gtest-spi.h>
#include <gtest/gtest.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
 
#include <array>
#include <cassert>
#include <cstdint>
#include <deque>
#include <fstream>
#include <list>
#include <memory>
#include <set>
#include <string>
#include <vector>
 
#include "base/compiler.hh"
#include "base/gtest/cur_tick_fake.hh"
#include "base/gtest/logging.hh"
#include "base/gtest/serialization_fixture.hh"
#include "sim/serialize.hh"
 
using namespace gem5;
 
// Instantiate the mock class to have a valid curTick of 0
GTestTickHandler tickHandler;
 
bool
dirExists(std::string dir)
{
    struct stat info;
    return (stat(dir.c_str(), &info) == 0) && (info.st_mode & S_IFDIR);
}
 
using SerializeFixture = SerializationFixture;
 
class CheckpointInFixture : public SerializationFixture
{
  public:
    std::unique_ptr<CheckpointIn> cpt;
 
    using SerializeFixture::SerializeFixture;
 
    void
    SetUp() override
    {
        SerializeFixture::SetUp();
 
        std::ofstream file(getCptPath());
        assert(file.good());
        file << R"cpt_file(
[General]
    Test1=BARasdf
    Test2=bar
 
[Junk]
Test3=yo
Test4=mama
 
[Foo]
Foo1=89
Foo2=384
 
[General]
Test3=89
 
[Junk]
Test4+=mia
)cpt_file";
        file.close();
        cpt = std::make_unique<CheckpointIn>(getDirName());
    }
 
    void
    TearDown() override
    {
        std::remove((getCptPath()).c_str());
        SerializeFixture::TearDown();
    }
};
 
class SerializableFixture : public SerializeFixture
{
  public:
    std::unique_ptr<CheckpointIn> cpt_in;
    std::unique_ptr<std::ofstream> cpt_out;
 
    using SerializeFixture::SerializeFixture;
 
    void
    SetUp() override
    {
        SerializeFixture::SetUp();
 
        cpt_out = std::make_unique<std::ofstream>(getCptPath());
        assert(cpt_out->good());
        cpt_in = std::make_unique<CheckpointIn>(getDirName());
    }
 
    void
    TearDown() override
    {
        std::remove((getCptPath()).c_str());
        SerializeFixture::TearDown();
    }
};
 
using SerializeFixtureDeathTest = SerializeFixture;
using CheckpointInFixtureDeathTest = CheckpointInFixture;
using SerializableFixtureDeathTest = SerializableFixture;
 
TEST(CheckpointInTest, SetGetDirSlash)
{
    ASSERT_EQ(CheckpointIn::setDir(""), "/");
    ASSERT_EQ(CheckpointIn::dir(), "/");
    ASSERT_EQ(CheckpointIn::setDir("/"), "/");
    ASSERT_EQ(CheckpointIn::dir(), "/");
    ASSERT_EQ(CheckpointIn::setDir("test_cpt_dir"), "test_cpt_dir/");
    ASSERT_EQ(CheckpointIn::dir(), "test_cpt_dir/");
    ASSERT_EQ(CheckpointIn::setDir("test_cpt_dir_2/"), "test_cpt_dir_2/");
    ASSERT_EQ(CheckpointIn::dir(), "test_cpt_dir_2/");
}
 
TEST(CheckpointInTest, SetGetDirTick)
{
    ASSERT_EQ(CheckpointIn::setDir("tick%d"), "tick0/");
    ASSERT_EQ(CheckpointIn::dir(), "tick0/");
    ASSERT_EQ(CheckpointIn::setDir("ti%dck"), "ti0ck/");
    ASSERT_EQ(CheckpointIn::dir(), "ti0ck/");
}
 
TEST_F(SerializeFixtureDeathTest, ConstructorFailure)
{
    // Assign another cpt dir to make sure that it is changed when a new
    // CheckpointIn instance is created
    CheckpointIn::setDir("test");
 
    // Make sure file does not exist, so that the constructor will fail
    std::ifstream file(getCptPath());
    assert(!file.good());
    ASSERT_ANY_THROW(CheckpointIn cpt(getDirName()));
}
 
TEST_F(SerializeFixture, ConstructorSuccess)
{
    // Assign another cpt dir to make sure that it is changed when a new
    // CheckpointIn instance is created
    CheckpointIn::setDir("test");
 
    // Create the file before creating the cpt to make sure it exists
    std::ofstream file(getCptPath());
    assert(file.good());
    file.close();
    CheckpointIn cpt(getDirName());
 
    // When a new CheckpointIn instance is created the static cpt dir changes
    EXPECT_EQ(CheckpointIn::dir(), getDirName());
}
 
TEST_F(CheckpointInFixtureDeathTest, GetCptDir)
{
    ASSERT_ANY_THROW(CheckpointIn("/random_dir_name"));
}
 
TEST_F(CheckpointInFixture, FindSections)
{
    // Successful searches
    ASSERT_TRUE(cpt->sectionExists("General"));
    ASSERT_TRUE(cpt->sectionExists("Junk"));
    ASSERT_TRUE(cpt->sectionExists("Foo"));
 
    // Failed searches
    ASSERT_FALSE(cpt->sectionExists("Junk2"));
    ASSERT_FALSE(cpt->sectionExists("Test1"));
}
 
TEST_F(CheckpointInFixture, FindEntries)
{
    // Successful searches
    ASSERT_TRUE(cpt->entryExists("General", "Test2"));
    ASSERT_TRUE(cpt->entryExists("Junk", "Test3"));
    ASSERT_TRUE(cpt->entryExists("Junk", "Test4"));
    ASSERT_TRUE(cpt->entryExists("General", "Test1"));
    ASSERT_TRUE(cpt->entryExists("General", "Test3"));
 
    // Failed searches
    ASSERT_FALSE(cpt->entryExists("Junk2", "test3"));
    ASSERT_FALSE(cpt->entryExists("Junk", "test4"));
}
 
TEST_F(CheckpointInFixture, ExtractEntries)
{
    std::string value;
 
    // Successful searches
    ASSERT_TRUE(cpt->find("General", "Test2", value));
    ASSERT_EQ(value, "bar");
    ASSERT_TRUE(cpt->find("Junk", "Test3", value));
    ASSERT_EQ(value, "yo");
    ASSERT_TRUE(cpt->find("Junk", "Test4", value));
    ASSERT_EQ(value, "mama mia");
    ASSERT_TRUE(cpt->find("General", "Test1", value));
    ASSERT_EQ(value, "BARasdf");
    ASSERT_TRUE(cpt->find("General", "Test3", value));
    ASSERT_EQ(value, "89");
 
    // Failed searches
    ASSERT_FALSE(cpt->find("Junk2", "test3", value));
    ASSERT_FALSE(cpt->find("Junk", "test4", value));
}
 
TEST_F(CheckpointInFixture, SCSCptInPathScoped)
{
    Serializable::ScopedCheckpointSection scs(*(cpt.get()), "Section1");
    ASSERT_EQ(Serializable::currentSection(), "Section1");
 
    {
        Serializable::ScopedCheckpointSection scs_2(*(cpt.get()), "Section2");
        ASSERT_EQ(Serializable::currentSection(), "Section1.Section2");
 
        Serializable::ScopedCheckpointSection scs_3(*(cpt.get()), "Section3");
        ASSERT_EQ(Serializable::currentSection(),
            "Section1.Section2.Section3");
    }
 
    Serializable::ScopedCheckpointSection scs_4(*(cpt.get()), "Section4");
    ASSERT_EQ(Serializable::currentSection(), "Section1.Section4");
}
 
TEST_F(SerializeFixture, SCSCptOutPathScoped)
{
    std::ofstream cpt(getCptPath());
 
    Serializable::ScopedCheckpointSection scs(cpt, "Section1");
    ASSERT_EQ(Serializable::currentSection(), "Section1");
 
    {
        Serializable::ScopedCheckpointSection scs_2(cpt, "Section2");
        ASSERT_EQ(Serializable::currentSection(), "Section1.Section2");
 
        Serializable::ScopedCheckpointSection scs_3(cpt, "Section3");
        ASSERT_EQ(Serializable::currentSection(),
            "Section1.Section2.Section3");
    }
 
    Serializable::ScopedCheckpointSection scs_4(cpt, "Section4");
    ASSERT_EQ(Serializable::currentSection(), "Section1.Section4");
}
 
TEST_F(SerializeFixture, SCSNoChangeCptIn)
{
    {
        // Create empty cpt file
        std::ofstream os(getCptPath());
        assert(os.good());
        os.close();
    }
 
    CheckpointIn cpt(getDirName());
 
    std::ifstream is(getCptPath());
    assert(is.good());
    ASSERT_EQ(is.peek(), std::ifstream::traits_type::eof());
 
    Serializable::ScopedCheckpointSection scs(cpt, "Section1");
    ASSERT_EQ(is.peek(), std::ifstream::traits_type::eof());
    ASSERT_EQ(Serializable::currentSection(), "Section1");
}
 
std::string
getString(std::istream &is)
{
    auto buf = is.rdbuf();
    std::ostringstream oss;
    oss << buf;
    return oss.str();
}
 
std::string
getContents(std::ofstream &cpt, std::string filename)
{
    // The checkpoint must be flushed, otherwise the file may not be up-
    // to-date and the assertions below will fail
    cpt.flush();
 
    std::ifstream is(filename);
    assert(is.good());
    return std::string(std::istreambuf_iterator<char>(is),
        std::istreambuf_iterator<char>());
}
 
TEST_F(SerializableFixture, SCSChangeCptOutSingle)
{
    Serializable::ScopedCheckpointSection scs(*cpt_out, "Section1");
    ASSERT_EQ(getContents(*cpt_out, getCptPath()),
        "\n[Section1]\n");
}
 
TEST_F(SerializableFixture, SCSChangeCptOutMultiple)
{
    std::string expected = "";
    Serializable::ScopedCheckpointSection scs(*cpt_out, "Section1");
    expected += "\n[Section1]\n";
    ASSERT_EQ(getContents(*cpt_out, getCptPath()), expected);
 
    {
        Serializable::ScopedCheckpointSection scs_2(*cpt_out, "Section2");
        expected += "\n[Section1.Section2]\n";
        ASSERT_EQ(getContents(*cpt_out, getCptPath()), expected);
 
        Serializable::ScopedCheckpointSection scs_3(*cpt_out, "Section3");
        expected += "\n[Section1.Section2.Section3]\n";
        ASSERT_EQ(getContents(*cpt_out, getCptPath()), expected);
    }
 
    Serializable::ScopedCheckpointSection scs_4(*cpt_out, "Section4");
    expected += "\n[Section1.Section4]\n";
    ASSERT_EQ(getContents(*cpt_out, getCptPath()), expected);
}
 
TEST_F(SerializableFixture, SCSChangeCptOutLarge)
{
    std::string expected = "";
    Serializable::ScopedCheckpointSection scs(*cpt_out, "Section1");
    expected += "\n[Section1]\n";
    ASSERT_EQ(getContents(*cpt_out, getCptPath()), expected);
 
    {
        Serializable::ScopedCheckpointSection scs_2(*cpt_out, "Section2");
        expected += "\n[Section1.Section2]\n";
        ASSERT_EQ(getContents(*cpt_out, getCptPath()), expected);
 
        {
            Serializable::ScopedCheckpointSection scs_3(*cpt_out, "Section3");
            expected += "\n[Section1.Section2.Section3]\n";
            ASSERT_EQ(getContents(*cpt_out, getCptPath()),
            expected);
        }
 
        Serializable::ScopedCheckpointSection scs_4(*cpt_out, "Section4");
        expected += "\n[Section1.Section2.Section4]\n";
        ASSERT_EQ(getContents(*cpt_out, getCptPath()), expected);
    }
 
    Serializable::ScopedCheckpointSection scs_5(*cpt_out, "Section5");
    expected += "\n[Section1.Section5]\n";
    ASSERT_EQ(getContents(*cpt_out, getCptPath()), expected);
 
    {
        Serializable::ScopedCheckpointSection scs_6(*cpt_out, "Section6");
        expected += "\n[Section1.Section5.Section6]\n";
        ASSERT_EQ(getContents(*cpt_out, getCptPath()), expected);
 
        Serializable::ScopedCheckpointSection scs_7(*cpt_out, "Section7");
        expected += "\n[Section1.Section5.Section6.Section7]\n";
        ASSERT_EQ(getContents(*cpt_out, getCptPath()), expected);
    }
 
    Serializable::ScopedCheckpointSection scs_8(*cpt_out, "Section8");
    expected += "\n[Section1.Section5.Section8]\n";
    ASSERT_EQ(getContents(*cpt_out, getCptPath()), expected);
}
 
TEST(SerializableDeathTest, GenerateCptOutFail)
{
    std::ofstream cpt;
    const std::string dir_name =
        SerializeFixture::generateTempDirName();
    ASSERT_FALSE(dirExists(dir_name));
 
    ASSERT_ANY_THROW(Serializable::generateCheckpointOut(
        dir_name + "/b/a/n/a/n/a/", cpt));
}
 
TEST_F(SerializeFixture, GenerateCptOut)
{
    // The fixture will auto-create the dir. Remove it.
    assert(rmdir(getDirName().c_str()) == 0);
 
    std::ofstream cpt;
    Serializable::generateCheckpointOut(getDirName(), cpt);
    ASSERT_TRUE(dirExists(getDirName()));
 
    // Make sure the checkpoint was properly created. Using EXPECT to
    // force removing the directory at the end
    EXPECT_NE(getContents(cpt, getCptPath()).find(
        "## checkpoint generated: "), std::string::npos);
}
 
TEST_F(SerializeFixture, GenerateCptOutExistent)
{
    assert(dirExists(getDirName()));
 
    // Create the checkpoint and make sure it has been properly created by
    // deleting it and making sure the function was successful
    std::ofstream cpt;
    Serializable::generateCheckpointOut(getDirName(), cpt);
    EXPECT_TRUE(remove((getCptPath()).c_str()) == 0);
}
 
class SerializableType : public Serializable
{
  private:
    mutable bool _serialized = false;
    bool _unserialized = false;
 
  public:
    SerializableType() : Serializable() {}
 
    void serialize(CheckpointOut &cp) const override { _serialized = true; }
    void unserialize(CheckpointIn &cp) override { _unserialized = true; }
 
    bool
    checkAndResetSerialized()
    {
        const bool serialized = _serialized;
        _serialized = false;
        return serialized;
    }
 
    bool
    checkAndResetUnserialized()
    {
        const bool unserialized = _unserialized;
        _unserialized = false;
        return unserialized;
    }
};
 
TEST_F(SerializableFixture, SectionSerializationSimple)
{
    SerializableType serializable;
 
    // Serialization
    {
        serializable.serializeSection(*cpt_out, "Section1");
        ASSERT_EQ(getContents(*cpt_out, getCptPath()),
            "\n[Section1]\n");
        ASSERT_TRUE(serializable.checkAndResetSerialized());
        ASSERT_FALSE(serializable.checkAndResetUnserialized());
 
        serializable.serializeSection(*cpt_out, "Section2");
        ASSERT_EQ(getContents(*cpt_out, getCptPath()),
            "\n[Section1]\n\n[Section2]\n");
        ASSERT_TRUE(serializable.checkAndResetSerialized());
        ASSERT_FALSE(serializable.checkAndResetUnserialized());
 
        serializable.serializeSection(*cpt_out, "Section3");
        ASSERT_EQ(getContents(*cpt_out, getCptPath()),
            "\n[Section1]\n\n[Section2]\n\n[Section3]\n");
        ASSERT_TRUE(serializable.checkAndResetSerialized());
        ASSERT_FALSE(serializable.checkAndResetUnserialized());
    }
 
    // Unserialization. Since the object has no serializable contents,
    // just make sure it does not throw for existent and non-existent
    // sections
    {
        ASSERT_NO_THROW(serializable.unserializeSection(*cpt_in, "Section1"));
        ASSERT_FALSE(serializable.checkAndResetSerialized());
        ASSERT_TRUE(serializable.checkAndResetUnserialized());
 
        ASSERT_NO_THROW(serializable.unserializeSection(*cpt_in, "Section2"));
        ASSERT_FALSE(serializable.checkAndResetSerialized());
        ASSERT_TRUE(serializable.checkAndResetUnserialized());
 
        ASSERT_NO_THROW(serializable.unserializeSection(*cpt_in, "Section3"));
        ASSERT_FALSE(serializable.checkAndResetSerialized());
        ASSERT_TRUE(serializable.checkAndResetUnserialized());
 
        ASSERT_NO_THROW(serializable.unserializeSection(*cpt_in, "Section4"));
        ASSERT_FALSE(serializable.checkAndResetSerialized());
        ASSERT_TRUE(serializable.checkAndResetUnserialized());
    }
}
 
TEST_F(SerializableFixtureDeathTest, ParamIn)
{
    int unserialized_integer;
    Serializable::ScopedCheckpointSection scs(*cpt_in, "Section1");
    ASSERT_ANY_THROW(paramIn(*cpt_in, "Param1", unserialized_integer));
}
 
TEST_F(SerializableFixture, ParamOutIn)
{
    const int integer = 5;
    const double real = 3.7;
    const bool boolean = true;
    const std::string str = "string test";
    const char character = 'c';
 
    // Serialization
    {
        Serializable::ScopedCheckpointSection scs(*cpt_out, "Section1");
        std::string expected = "\n[Section1]\n";
 
        paramOut(*cpt_out, "Param1", integer);
        expected += "Param1=5\n";
        ASSERT_EQ(getContents(*cpt_out, getCptPath()), expected);
 
        paramOut(*cpt_out, "Param2", real);
        expected += "Param2=3.7\n";
        ASSERT_EQ(getContents(*cpt_out, getCptPath()), expected);
 
        paramOut(*cpt_out, "Param3", boolean);
        expected += "Param3=true\n";
        ASSERT_EQ(getContents(*cpt_out, getCptPath()), expected);
 
        paramOut(*cpt_out, "Param4", str);
        expected += "Param4=string test\n";
        ASSERT_EQ(getContents(*cpt_out, getCptPath()), expected);
 
        paramOut(*cpt_out, "Param5", character);
        expected += "Param5=99\n";
        ASSERT_EQ(getContents(*cpt_out, getCptPath()), expected);
    }
 
    // Unserialization
    {
        CheckpointIn cpt(getDirName());
 
        int unserialized_integer;
        double unserialized_real;
        bool unserialized_boolean;
        std::string unserialized_str;
        char unserialized_character;
 
        Serializable::ScopedCheckpointSection scs(cpt, "Section1");
 
        paramIn(cpt, "Param1", unserialized_integer);
        ASSERT_EQ(integer, unserialized_integer);
 
        paramIn(cpt, "Param2", unserialized_real);
        ASSERT_EQ(real, unserialized_real);
 
        paramIn(cpt, "Param3", unserialized_boolean);
        ASSERT_EQ(boolean, unserialized_boolean);
 
        paramIn(cpt, "Param4", unserialized_str);
        ASSERT_EQ(str, unserialized_str);
 
        paramIn(cpt, "Param5", unserialized_character);
        ASSERT_EQ(character, unserialized_character);
    }
}
 
TEST_F(SerializableFixture, ParamOutInMultipleSections)
{
    const int integer = 5;
    const double real = 3.7;
    const bool boolean = true;
    const std::string str = "string test";
    const char character = 'c';
 
    // Serialization
    {
        Serializable::ScopedCheckpointSection scs(*cpt_out, "Section1");
        std::string expected = "\n[Section1]\n";
 
        paramOut(*cpt_out, "Param1", integer);
        expected += "Param1=5\n";
        ASSERT_EQ(getContents(*cpt_out, getCptPath()), expected);
 
        paramOut(*cpt_out, "Param2", real);
        expected += "Param2=3.7\n";
        ASSERT_EQ(getContents(*cpt_out, getCptPath()), expected);
 
        {
            Serializable::ScopedCheckpointSection scs_2(*cpt_out, "Section2");
            expected += "\n[Section1.Section2]\n";
 
            paramOut(*cpt_out, "Param3", boolean);
            expected += "Param3=true\n";
            ASSERT_EQ(getContents(*cpt_out, getCptPath()),
                expected);
        }
 
        // Possibly unexpected behavior: Since scs_2 has gone out of scope
        // the user may expect that we'd go back to Section1; however, this
        // is not the case, and Param4 is added to Section1.Section2
        paramOut(*cpt_out, "Param4", str);
        expected += "Param4=string test\n";
        ASSERT_EQ(getContents(*cpt_out, getCptPath()), expected);
 
        {
            Serializable::ScopedCheckpointSection scs_3(*cpt_out, "Section3");
            expected += "\n[Section1.Section3]\n";
 
            Serializable::ScopedCheckpointSection scs_4(*cpt_out, "Section4");
            expected += "\n[Section1.Section3.Section4]\n";
 
            paramOut(*cpt_out, "Param5", character);
            expected += "Param5=99\n";
            ASSERT_EQ(getContents(*cpt_out, getCptPath()),
                expected);
        }
    }
 
    // Unserialization
    {
        CheckpointIn cpt(getDirName());
 
        int unserialized_integer;
        double unserialized_real;
        bool unserialized_boolean;
        std::string unserialized_str;
        char unserialized_character;
 
        Serializable::ScopedCheckpointSection scs(cpt, "Section1");
 
        paramIn(cpt, "Param1", unserialized_integer);
        ASSERT_EQ(integer, unserialized_integer);
 
        paramIn(cpt, "Param2", unserialized_real);
        ASSERT_EQ(real, unserialized_real);
 
        {
            Serializable::ScopedCheckpointSection scs_2(cpt, "Section2");
 
            paramIn(cpt, "Param3", unserialized_boolean);
            ASSERT_EQ(boolean, unserialized_boolean);
 
            // Due to the reason mentioned above on serialization, this param
            // must be extracted within the scope of Section 2
            paramIn(cpt, "Param4", unserialized_str);
            ASSERT_EQ(str, unserialized_str);
        }
 
        {
            Serializable::ScopedCheckpointSection scs_3(cpt, "Section3");
            Serializable::ScopedCheckpointSection scs_4(cpt, "Section4");
 
            paramIn(cpt, "Param5", unserialized_character);
            ASSERT_EQ(character, unserialized_character);
        }
    }
}
 
TEST_F(SerializeFixture, OptParamOutIn)
{
    const double real = 3.7;
    const std::string str = "string test";
 
    // Serialization
    {
        std::ofstream cpt(getCptPath());
        Serializable::ScopedCheckpointSection scs(cpt, "Section1");
        paramOut(cpt, "Param2", real);
        paramOut(cpt, "Param4", str);
    }
 
    // Unserialization
    {
        CheckpointIn cpt(getDirName());
 
        int unserialized_integer;
        double unserialized_real;
        bool unserialized_boolean;
        std::string unserialized_str;
 
        Serializable::ScopedCheckpointSection scs(cpt, "Section1");
 
        // Optional without warning
        gtestLogOutput.str("");
        ASSERT_FALSE(optParamIn(cpt, "Param1", unserialized_integer, false));
        ASSERT_EQ(gtestLogOutput.str(), "");
 
        gtestLogOutput.str("");
        ASSERT_TRUE(optParamIn(cpt, "Param2", unserialized_real, false));
        ASSERT_EQ(real, unserialized_real);
        ASSERT_EQ(gtestLogOutput.str(), "");
 
        // Optional with default request for warning
        gtestLogOutput.str("");
        ASSERT_FALSE(optParamIn(cpt, "Param3", unserialized_boolean));
        ASSERT_THAT(gtestLogOutput.str(),
            ::testing::HasSubstr("warn: optional parameter Section1:Param3 "
            "not present\n"));
 
        gtestLogOutput.str("");
        ASSERT_TRUE(optParamIn(cpt, "Param4", unserialized_str));
        ASSERT_EQ(str, unserialized_str);
        ASSERT_EQ(gtestLogOutput.str(), "");
 
        // Explicit request for warning
        gtestLogOutput.str("");
        ASSERT_FALSE(optParamIn(cpt, "Param5", unserialized_boolean, true));
        ASSERT_THAT(gtestLogOutput.str(),
            ::testing::HasSubstr("warn: optional parameter Section1:Param5 "
            "not present\n"));
    }
}
 
TEST_F(SerializableFixtureDeathTest, NoSectionParamIn)
{
#ifndef NDEBUG
    GTEST_SKIP() << "Skipping as assertions are "
        "stripped out of fast builds";
#endif
 
    std::ofstream of(getCptPath());
    CheckpointIn cpt(getDirName());
    int unserialized_integer;
    ASSERT_DEATH(paramIn(cpt, "Param1", unserialized_integer), "");
}
 
TEST_F(SerializeFixture, ArrayParamOutIn)
{
    const int integer[] = {5, 10, 15};
    std::array<double, 4> real = {0.1, 1.345, 892.72, 1e+10};
    std::list<bool> boolean = {true, false};
    std::vector<std::string> str = {"a", "string", "test"};
    std::set<uint64_t> uint64 = {12751928501, 13, 111111};
    std::deque<uint8_t> uint8 = {17, 42, 255};
 
    // Serialization
    {
        std::ofstream cpt(getCptPath());
        Serializable::ScopedCheckpointSection scs(cpt, "Section1");
        std::string expected = "\n[Section1]\n";
 
        arrayParamOut(cpt, "Param1", integer);
        expected += "Param1=5 10 15\n";
        ASSERT_EQ(getContents(cpt, getCptPath()), expected);
 
        arrayParamOut(cpt, "Param2", real);
        expected += "Param2=0.1 1.345 892.72 1e+10\n";
        ASSERT_EQ(getContents(cpt, getCptPath()), expected);
 
        arrayParamOut(cpt, "Param3", boolean);
        expected += "Param3=true false\n";
        ASSERT_EQ(getContents(cpt, getCptPath()), expected);
 
        arrayParamOut(cpt, "Param4", str);
        expected += "Param4=a string test\n";
        ASSERT_EQ(getContents(cpt, getCptPath()), expected);
 
        arrayParamOut(cpt, "Param5", uint64);
        expected += "Param5=13 111111 12751928501\n";
        ASSERT_EQ(getContents(cpt, getCptPath()), expected);
 
        arrayParamOut(cpt, "Param6", uint8);
        expected += "Param6=17 42 255\n";
        ASSERT_EQ(getContents(cpt, getCptPath()), expected);
    }
 
    // Unserialization
    {
        CheckpointIn cpt(getDirName());
 
        int unserialized_integer[3];
        std::array<double, 4> unserialized_real;
        std::list<bool> unserialized_boolean;
        std::vector<std::string> unserialized_str;
        std::set<uint64_t> unserialized_uint64;
        std::deque<uint8_t> unserialized_uint8;
 
        Serializable::ScopedCheckpointSection scs(cpt, "Section1");
 
        arrayParamIn(cpt, "Param1", unserialized_integer, 3);
        ASSERT_THAT(unserialized_integer, testing::ElementsAre(5, 10, 15));
 
        arrayParamIn(cpt, "Param2", unserialized_real.data(),
            unserialized_real.size());
        ASSERT_EQ(real, unserialized_real);
 
        arrayParamIn(cpt, "Param3", unserialized_boolean);
        ASSERT_EQ(boolean, unserialized_boolean);
 
        arrayParamIn(cpt, "Param4", unserialized_str);
        ASSERT_EQ(str, unserialized_str);
 
        arrayParamIn(cpt, "Param5", unserialized_uint64);
        ASSERT_EQ(uint64, unserialized_uint64);
 
        arrayParamIn(cpt, "Param6", unserialized_uint8);
        ASSERT_EQ(uint8, unserialized_uint8);
    }
}
 
TEST_F(SerializeFixture, DISABLED_ArrayParamOutInSpacedStrings)
{
    std::vector<std::string> str = {"a string test", "for", "array param out"};
 
    // Serialization
    {
        std::ofstream cpt(getCptPath());
        Serializable::ScopedCheckpointSection scs(cpt, "Section1");
        std::string expected = "\n[Section1]\n";
 
        arrayParamOut(cpt, "Param1", str);
        expected += "Param1=string test for array param out\n";
        ASSERT_EQ(getContents(cpt, getCptPath()), expected);
    }
 
    // Unserialization
    {
        CheckpointIn cpt(getDirName());
 
        std::vector<std::string> unserialized_str;
 
        Serializable::ScopedCheckpointSection scs(cpt, "Section1");
 
        arrayParamIn(cpt, "Param1", unserialized_str);
        ASSERT_EQ(str, unserialized_str);
    }
}
 
TEST_F(SerializeFixtureDeathTest, ArrayParamOutInSmaller)
{
    // Serialization
    {
        const int integer[] = {5, 10, 15};
 
        std::ofstream cpt(getCptPath());
        Serializable::ScopedCheckpointSection scs(cpt, "Section1");
        std::string expected = "\n[Section1]\n";
 
        arrayParamOut(cpt, "Param1", integer);
        expected += "Param1=5 10 15\n";
        ASSERT_EQ(getContents(cpt, getCptPath()), expected);
    }
 
    // Unserialization
    {
        CheckpointIn cpt(getDirName());
 
        int unserialized_integer[1];
 
        Serializable::ScopedCheckpointSection scs(cpt, "Section1");
 
        ASSERT_ANY_THROW(arrayParamIn(cpt, "Param1", unserialized_integer, 2));
    }
}
 
TEST_F(SerializeFixture, MappingParamOutIn)
{
    const int integers[] = {10, 32, 100};
    std::array<double, 4> reals = {0.1, 1.345, 892.72, 1e+10};
    const char* const names_ints[] = {"ten", "thirty-two", "one hundred"};
    const char* const names_reals[] = {"first", "second", "third", "fourth"};
 
    // Serialization
    {
        std::ofstream cpt(getCptPath());
        Serializable::ScopedCheckpointSection scs(cpt, "Section1");
        std::string expected = "\n[Section1]\n";
 
        mappingParamOut(cpt, "Integers", names_ints, integers, 3);
        expected += "\n[Section1.Integers]\nten=10\nthirty-two=32\n"
            "one hundred=100\n";
        ASSERT_EQ(getContents(cpt, getCptPath()), expected);
 
        mappingParamOut(cpt, "Reals", names_reals, reals.data(), reals.size());
        expected += "\n[Section1.Reals]\nfirst=0.1\nsecond=1.345\n"
            "third=892.72\nfourth=1e+10\n";
        ASSERT_EQ(getContents(cpt, getCptPath()), expected);
    }
 
    // Unserialization
    {
        CheckpointIn cpt(getDirName());
 
        int unserialized_integers[3];
        std::array<double, 4> unserialized_reals;
 
        mappingParamIn(cpt, "Section1.Integers", names_ints,
            unserialized_integers, 3);
        ASSERT_THAT(unserialized_integers, testing::ElementsAre(10, 32, 100));
 
        mappingParamIn(cpt, "Section1.Reals", names_reals,
            unserialized_reals.data(), unserialized_reals.size());
        ASSERT_EQ(unserialized_reals, reals);
    }
}
 
TEST_F(SerializeFixture, MappingParamOutInMissing)
{
    const int integers[] = {10, 32, 100};
    std::array<double, 4> reals = {0.1, 1.345, 892.72, 1e+10};
 
    // Serialization
    {
        const char* const names_ints[] = {"ten", "thirty-two", "one hundred"};
        const char* const names_reals[] =
            {"first", "second", "third", "fourth"};
 
        std::ofstream cpt(getCptPath());
        Serializable::ScopedCheckpointSection scs(cpt, "Section1");
        std::string expected = "\n[Section1]\n";
 
        mappingParamOut(cpt, "Integers", names_ints, integers, 3);
        expected += "\n[Section1.Integers]\nten=10\nthirty-two=32\n"
            "one hundred=100\n";
        ASSERT_EQ(getContents(cpt, getCptPath()), expected);
 
        mappingParamOut(cpt, "Reals", names_reals, reals.data(), reals.size());
        expected += "\n[Section1.Reals]\nfirst=0.1\nsecond=1.345\n"
            "third=892.72\nfourth=1e+10\n";
        ASSERT_EQ(getContents(cpt, getCptPath()), expected);
    }
 
    // Unserialization
    {
        const char* const names_ints[] = {"one hundred"};
        const char* const names_reals[] = {"first", "third"};
        std::array<double, 2> expected_reals = {0.1, 892.72};
 
        CheckpointIn cpt(getDirName());
 
        std::string err;
        int unserialized_integers[1];
        std::array<double, 2> unserialized_reals;
 
        gtestLogOutput.str("");
        mappingParamIn(cpt, "Section1.Integers", names_ints,
            unserialized_integers, 1);
        ASSERT_THAT(unserialized_integers, testing::ElementsAre(100));
        err = gtestLogOutput.str();
        ASSERT_THAT(err, ::testing::HasSubstr("warn: unknown entry found in "
            "checkpoint: Section1.Integers thirty-two 32\n"));
        ASSERT_THAT(err, ::testing::HasSubstr("warn: unknown entry found in "
            "checkpoint: Section1.Integers ten 10\n"));
 
        gtestLogOutput.str("");
        mappingParamIn(cpt, "Section1.Reals", names_reals,
            unserialized_reals.data(), unserialized_reals.size());
        ASSERT_EQ(unserialized_reals, expected_reals);
        err = gtestLogOutput.str();
        ASSERT_THAT(err, ::testing::HasSubstr("warn: unknown entry found in "
            "checkpoint: Section1.Reals fourth 1e+10\n"));
        ASSERT_THAT(err, ::testing::HasSubstr("warn: unknown entry found in "
            "checkpoint: Section1.Reals second 1.345\n"));
    }
}
 
TEST_F(SerializeFixture, SerializeScalar)
{
    const int expected_integer = 5;
    const double expected_real = 3.7;
    const bool expected_boolean = true;
    const std::string expected_str = "string test";
 
    // Serialization
    {
        const int integer = expected_integer;
        const double real = expected_real;
        const bool boolean = expected_boolean;
        const std::string str = expected_str;
 
        std::ofstream cp(getCptPath());
        Serializable::ScopedCheckpointSection scs(cp, "Section1");
        std::string expected = "\n[Section1]\n";
 
        SERIALIZE_SCALAR(integer);
        expected += "integer=5\n";
        ASSERT_EQ(getContents(cp, getCptPath()), expected);
 
        SERIALIZE_SCALAR(real);
        expected += "real=3.7\n";
        ASSERT_EQ(getContents(cp, getCptPath()), expected);
 
        SERIALIZE_SCALAR(boolean);
        expected += "boolean=true\n";
        ASSERT_EQ(getContents(cp, getCptPath()), expected);
 
        SERIALIZE_SCALAR(str);
        expected += "str=string test\n";
        ASSERT_EQ(getContents(cp, getCptPath()), expected);
    }
 
    // Unserialization
    {
        CheckpointIn cp(getDirName());
 
        int integer;
        double real;
        bool boolean;
        std::string str;
 
        Serializable::ScopedCheckpointSection scs(cp, "Section1");
 
        UNSERIALIZE_SCALAR(integer);
        ASSERT_EQ(integer, expected_integer);
 
        UNSERIALIZE_SCALAR(real);
        ASSERT_EQ(real, expected_real);
 
        UNSERIALIZE_SCALAR(boolean);
        ASSERT_EQ(boolean, expected_boolean);
 
        UNSERIALIZE_SCALAR(str);
        ASSERT_EQ(str, expected_str);
    }
}
 
TEST_F(SerializeFixture, UnserializeOptScalar)
{
    const double expected_real = 3.7;
    const std::string expected_str = "string test";
 
    // Serialization
    {
        const double real = expected_real;
        const std::string str = expected_str;
 
        std::ofstream cp(getCptPath());
        Serializable::ScopedCheckpointSection scs(cp, "Section1");
        SERIALIZE_SCALAR(real);
        SERIALIZE_SCALAR(str);
    }
 
    // Unserialization
    {
        CheckpointIn cp(getDirName());
 
        int integer;
        double real;
        bool boolean;
        std::string str;
 
        Serializable::ScopedCheckpointSection scs(cp, "Section1");
 
        // Optional without warning
        ASSERT_FALSE(UNSERIALIZE_OPT_SCALAR(integer));
 
        ASSERT_TRUE(UNSERIALIZE_OPT_SCALAR(real));
        ASSERT_EQ(real, expected_real);
 
        // Optional with default request for warning
        ASSERT_FALSE(UNSERIALIZE_OPT_SCALAR(boolean));
 
        ASSERT_TRUE(UNSERIALIZE_OPT_SCALAR(str));
        ASSERT_EQ(str, expected_str);
    }
}
 
TEST_F(SerializeFixture, SerializeEnum)
{
    enum Number
    {
        ZERO,
        TEN=10,
        THIRTY_TWO=32
    };
    const Number expected_val = ZERO;
    const Number expected_val_2 = THIRTY_TWO;
 
    // Serialization
    {
        const Number zero = expected_val;
        const Number thirty_two = expected_val_2;
 
        std::ofstream cp(getCptPath());
        Serializable::ScopedCheckpointSection scs(cp, "Section1");
        std::string expected = "\n[Section1]\n";
 
        SERIALIZE_ENUM(zero);
        expected += "zero=0\n";
        ASSERT_EQ(getContents(cp, getCptPath()), expected);
 
        SERIALIZE_ENUM(thirty_two);
        expected += "thirty_two=32\n";
        ASSERT_EQ(getContents(cp, getCptPath()), expected);
    }
 
    // Unserialization
    {
        CheckpointIn cp(getDirName());
 
        Number zero;
        Number thirty_two;
 
        Serializable::ScopedCheckpointSection scs(cp, "Section1");
 
        UNSERIALIZE_ENUM(zero);
        ASSERT_EQ(zero, expected_val);
 
        UNSERIALIZE_ENUM(thirty_two);
        ASSERT_EQ(thirty_two, expected_val_2);
    }
}
 
TEST_F(SerializeFixture, SerializeArray)
{
    std::array<double, 4> expected_real = {0.1, 1.345, 892.72, 1e+10};
 
    // Serialization
    {
        const int integer[] = {5, 10, 15};
        const double *real = expected_real.data();
 
        std::ofstream cp(getCptPath());
        Serializable::ScopedCheckpointSection scs(cp, "Section1");
        std::string expected = "\n[Section1]\n";
 
        SERIALIZE_ARRAY(integer, 3);
        expected += "integer=5 10 15\n";
        ASSERT_EQ(getContents(cp, getCptPath()), expected);
 
        SERIALIZE_ARRAY(real, expected_real.size());
        expected += "real=0.1 1.345 892.72 1e+10\n";
        ASSERT_EQ(getContents(cp, getCptPath()), expected);
    }
 
    // Unserialization
    {
        CheckpointIn cp(getDirName());
 
        int integer[3];
        std::array<double, 4> real_array;
        double *real = real_array.data();
 
        Serializable::ScopedCheckpointSection scs(cp, "Section1");
 
        UNSERIALIZE_ARRAY(integer, 3);
        ASSERT_THAT(integer, testing::ElementsAre(5, 10, 15));
 
        UNSERIALIZE_ARRAY(real, expected_real.size());
        ASSERT_EQ(real_array, expected_real);
    }
}
 
TEST_F(SerializeFixture, SerializeContainer)
{
    std::list<bool> expected_boolean = {true, false};
    std::vector<std::string> expected_str = {"a", "string", "test"};
    std::set<uint64_t> expected_uint64 = {12751928501, 13, 111111};
    std::deque<uint8_t> expected_uint8 = {17, 42, 255};
 
    // Serialization
    {
        const std::list<bool> boolean = expected_boolean;
        const std::vector<std::string> str = expected_str;
        const std::set<uint64_t> uint64 = expected_uint64;
        const std::deque<uint8_t> uint8 = expected_uint8;
 
        std::ofstream cp(getCptPath());
        Serializable::ScopedCheckpointSection scs(cp, "Section1");
        std::string expected = "\n[Section1]\n";
 
        SERIALIZE_CONTAINER(boolean);
        expected += "boolean=true false\n";
        ASSERT_EQ(getContents(cp, getCptPath()), expected);
 
        SERIALIZE_CONTAINER(str);
        expected += "str=a string test\n";
        ASSERT_EQ(getContents(cp, getCptPath()), expected);
 
        SERIALIZE_CONTAINER(uint64);
        expected += "uint64=13 111111 12751928501\n";
        ASSERT_EQ(getContents(cp, getCptPath()), expected);
 
        SERIALIZE_CONTAINER(uint8);
        expected += "uint8=17 42 255\n";
        ASSERT_EQ(getContents(cp, getCptPath()), expected);
    }
 
    // Unserialization
    {
        CheckpointIn cp(getDirName());
 
        std::list<bool> boolean;
        std::vector<std::string> str;
        std::set<uint64_t> uint64;
        std::deque<uint8_t> uint8;
 
        Serializable::ScopedCheckpointSection scs(cp, "Section1");
 
        UNSERIALIZE_CONTAINER(boolean);
        ASSERT_EQ(boolean, expected_boolean);
 
        UNSERIALIZE_CONTAINER(str);
        ASSERT_EQ(str, expected_str);
 
        UNSERIALIZE_CONTAINER(uint64);
        ASSERT_EQ(uint64, expected_uint64);
 
        UNSERIALIZE_CONTAINER(uint8);
        ASSERT_EQ(uint8, expected_uint8);
    }
}
 
TEST_F(SerializeFixture, SerializeMapping)
{
    const int expected_integers[] = {10, 32, 100};
    std::array<double, 4> expected_reals = {0.1, 1.345, 892.72, 1e+10};
    const char* const names_ints[] = {"ten", "thirty-two", "one hundred"};
    const char* const names_reals[] = {"first", "second", "third", "fourth"};
 
    // Serialization
    {
        const int *integers = expected_integers;
        const double *reals = expected_reals.data();
 
        std::ofstream cp(getCptPath());
        Serializable::ScopedCheckpointSection scs(cp, "Section1");
        std::string expected = "\n[Section1]\n";
 
        SERIALIZE_MAPPING(integers, names_ints, 3);
        expected += "\n[Section1.integers]\nten=10\nthirty-two=32\n"
            "one hundred=100\n";
        ASSERT_EQ(getContents(cp, getCptPath()), expected);
 
        SERIALIZE_MAPPING(reals, names_reals, expected_reals.size());
        expected += "\n[Section1.reals]\nfirst=0.1\nsecond=1.345\n"
            "third=892.72\nfourth=1e+10\n";
        ASSERT_EQ(getContents(cp, getCptPath()), expected);
    }
 
    // Unserialization
    {
        CheckpointIn cp(getDirName());
 
        int integers[3];
        double reals[4];
 
        Serializable::ScopedCheckpointSection scs(cp, "Section1");
 
        UNSERIALIZE_MAPPING(integers, names_ints, 3);
        ASSERT_THAT(integers, testing::ElementsAre(10, 32, 100));
 
        UNSERIALIZE_MAPPING(reals, names_reals, expected_reals.size());
        ASSERT_THAT(reals, testing::ElementsAre(0.1, 1.345, 892.72, 1e+10));
    }
}