// Copyright 2015 The Android Open Source Project
//
// This software is licensed under the terms of the GNU General Public
// License version 2, as published by the Free Software Foundation, and
// may be copied, distributed, and modified under those terms.
//
// This program 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 General Public License for more details.

#include "android/base/files/IniFile.h"

#include "android/base/testing/TestTempDir.h"

#include <gtest/gtest.h>

#include <algorithm>
#include <fstream>
#include <limits>
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>

namespace android {
namespace base {

using std::endl;
using std::numeric_limits;
using std::string;
using std::unique_ptr;
using std::unordered_map;
using std::vector;

namespace {

class IniFileTest : public ::testing::Test {
public:
    void SetUp() override {
        mTempDir.reset(new TestTempDir("inifiletest"));
        mIniFilePath = mTempDir->makeSubPath("test.ini").c_str();
        mIni.reset(new IniFile(mIniFilePath));
    }

    void TearDown() override {
        mIni.reset();
        mTempDir.reset();
    }

protected:
    void writeIniFileData(const vector<string>& lines) {
        std::ofstream outFile(mIniFilePath,
                              std::ios_base::out | std::ios_base::trunc);
        ASSERT_FALSE(outFile.fail());
        for (const auto& line : lines) {
            outFile << line << endl;
        }
    }

    void verifyFileContents(const vector<string>& lines) {
        std::ifstream inFile(mIniFilePath);
        ASSERT_FALSE(inFile.fail());
        vector<string> fileLines;
        string line;
        while (std::getline(inFile, line)) {
            fileLines.push_back(line);
        }

        ASSERT_EQ(lines.size(), fileLines.size());
        for (size_t i = 0; i < lines.size(); ++i) {
            EXPECT_EQ(lines[i], fileLines[i]);
        }
    }

    // Verifies that the underlying file for |ini| is |updated| when
    // |writeIfChanged| is called.
    // Note that this changes |ini|. After this function is called, |ini| is
    // always
    // clean, and the data has been changed arbitrarily.
    void verifyFileUpdated(bool updated) {
        static int counter = 0;
        string key = "key" + std::to_string(counter++);
        vector<string> lines = {key + " = somevalue"};

        writeIniFileData(lines);
        EXPECT_TRUE(mIni->writeIfChanged());
        EXPECT_TRUE(mIni->read());

        // If the file was updated, then the new uniquely written data must have
        // disappeared, not otherwise.
        if (updated) {
            EXPECT_FALSE(mIni->hasKey(key));
        } else {
            EXPECT_TRUE(mIni->hasKey(key));
        }
    }

    unique_ptr<TestTempDir> mTempDir;
    string mIniFilePath;
    unique_ptr<IniFile> mIni;
};

}  // namespace

TEST_F(IniFileTest, readWrite) {
    static const unordered_map<string, int> intData = {
            {"zeroInt", 0},
            {"positiveInt", 1},
            {"negativeInt", -1},
            {"maxInt", numeric_limits<int>::max()},
            {"minInt", numeric_limits<int>::min()},
            {"lowestInt", numeric_limits<int>::lowest()}};
    static const unordered_map<string, int64_t> int64Data = {
            {"zeroInt64", 0ULL},
            {"positiveInt64", 1ULL},
            {"negativeInt64", -1ULL},
            {"maxInt64", numeric_limits<int64_t>::max()},
            {"minInt64", numeric_limits<int64_t>::min()},
            {"lowestInt64", numeric_limits<int64_t>::lowest()}};
    static const unordered_map<string, double> doubleData = {
            {"zeroDouble", 0.0},
            {"positiveDouble", 1.5},
            {"negativeDouble", -1.5},
            {"maxDouble", numeric_limits<double>::max()},
            // minDouble fails because of rounding errors.
            // {"minDouble", numeric_limits<double>::min()},
            {"lowestDouble", numeric_limits<double>::lowest()}};

    // This doesn't actually test the format in which values are persisted.
    // But it does test that serialize-deserialize are consistent.
    static const unordered_map<string, bool> boolData = {{"trueKey", true},
                                                         {"falseKey", false}};
    static const unordered_map<string, IniFile::DiskSize> diskSizeData = {
            {"ds0", 0ULL},
            {"ds1000B", 1000ULL},
            {"ds1K", 1024ULL},
            {"ds5k", 5 * 1024ULL},
            {"ds1M", 1024 * 1024ULL},
            {"ds3G", 3 * 1024 * 1024 * 1024ULL}};

    for (const auto& keyval : intData) {
        mIni->setInt(keyval.first, keyval.second);
    }
    for (const auto& keyval : int64Data) {
        mIni->setInt64(keyval.first, keyval.second);
    }
    for (const auto& keyval : doubleData) {
        mIni->setDouble(keyval.first, keyval.second);
    }
    for (const auto& keyval : boolData) {
        mIni->setBool(keyval.first, keyval.second);
    }
    for (const auto& keyval : diskSizeData) {
        mIni->setDiskSize(keyval.first, keyval.second);
    }

    ASSERT_TRUE(mIni->write());

    mIni.reset(new IniFile(mIniFilePath));
    ASSERT_EQ(0, mIni->size());
    ASSERT_TRUE(mIni->read());
    EXPECT_EQ(intData.size() + int64Data.size() + doubleData.size() +
                      boolData.size() + diskSizeData.size(),
              mIni->size());

    // Mix-up the order a bit.
    for (const auto& keyval : boolData) {
        EXPECT_TRUE(mIni->hasKey(keyval.first));
        EXPECT_EQ(keyval.second, mIni->getBool(keyval.first, 99));
    }
    for (const auto& keyval : diskSizeData) {
        EXPECT_TRUE(mIni->hasKey(keyval.first));
        EXPECT_EQ(keyval.second, mIni->getDiskSize(keyval.first, 99));
    }
    for (const auto& keyval : int64Data) {
        EXPECT_TRUE(mIni->hasKey(keyval.first));
        EXPECT_EQ(keyval.second, mIni->getInt64(keyval.first, 99));
    }
    for (const auto& keyval : intData) {
        EXPECT_TRUE(mIni->hasKey(keyval.first));
        EXPECT_EQ(keyval.second, mIni->getInt(keyval.first, 99));
    }
    for (const auto& keyval : doubleData) {
        EXPECT_TRUE(mIni->hasKey(keyval.first));
        EXPECT_EQ(keyval.second, mIni->getDouble(keyval.first, 99));
    }
}

TEST_F(IniFileTest, duplicateAndMisingKeys) {
    mIni->setInt("int", 0);
    mIni->setInt("int", 1);
    mIni->setInt64("int64", 0ULL);
    mIni->setInt64("int64", 1ULL);
    mIni->setDouble("double", 0.0);
    mIni->setDouble("double", 1.1);
    mIni->setBool("bool", false);
    mIni->setBool("bool", true);
    mIni->setDiskSize("ds", 0ULL);
    mIni->setDiskSize("ds", 1ULL);

    ASSERT_TRUE(mIni->write());
    mIni.reset(new IniFile(mIniFilePath));
    ASSERT_EQ(0, mIni->size());
    ASSERT_TRUE(mIni->read());
    EXPECT_NE(0, mIni->size());

    EXPECT_EQ(1, mIni->getInt("int", 99));
    EXPECT_EQ(1ULL, mIni->getInt64("int64", 99));
    EXPECT_EQ(1.1, mIni->getDouble("double", 99));
    EXPECT_EQ(true, mIni->getBool("bool", false));
    EXPECT_EQ(1ULL, mIni->getDiskSize("ds", 99ULL));

    EXPECT_EQ(-11, mIni->getInt("missing", -11));
    EXPECT_EQ(22ULL, mIni->getInt64("missing", 22ULL));
    EXPECT_EQ(3.3, mIni->getDouble("missing", 3.3));
    EXPECT_EQ(true, mIni->getBool("missing", true));
    EXPECT_EQ(44ULL, mIni->getInt("missing", 44ULL));
}

TEST_F(IniFileTest, valueFormat) {
    static const vector<string> fileData = {
            "key1 = value with spaces", "key2 = value with trailing spaces  ",
            "key3 = \"value with redundant quotes\"", "keyAllSpaces =       "};
    writeIniFileData(fileData);

    ASSERT_TRUE(mIni->read());
    EXPECT_EQ(fileData.size(), mIni->size());
    EXPECT_EQ("value with spaces", mIni->getString("key1", ""));
    EXPECT_EQ("value with trailing spaces", mIni->getString("key2", ""));
    EXPECT_EQ("\"value with redundant quotes\"", mIni->getString("key3", ""));
    EXPECT_EQ("", mIni->getString("keyAllSpaces", "nonemptydefault"));
}

TEST_F(IniFileTest, readMalformedFile) {
    static const int defaultInt = -99;
    static const vector<string> fileData = {
            "a = 5",
            "; This comment will be skipped",
            "  b = 4",
            "   # So will this: irrelevant ; and #",
            "c=43",
            "d= 37malformedint,otherwiseOK",
            "This is actually malformed, and will be skipped with warning",
            " d = 45.6 now this becomes malformed here",
            "d = 43 ; hanging comments are not supported.",
            " ee = 546",
            "f=\"56\"",
            "f32ASDF_-.dfae3=1",
            "90=KeyMustStartWithAlpha",
            "a9%0=KeyCanNotContainPercent",
            ""};
    static const unordered_map<string, int> validEntries = {
            {"a", 5},
            {"b", 4},
            {"c", 43},
            {"d", defaultInt},
            {"ee", 546},
            {"f", defaultInt},
            {"f32ASDF_-.dfae3", 1}};

    writeIniFileData(fileData);

    ASSERT_TRUE(mIni->read());
    EXPECT_EQ(validEntries.size(), mIni->size());
    for (const auto& keyval : validEntries) {
        EXPECT_TRUE(mIni->hasKey(keyval.first));
        EXPECT_EQ(keyval.second, mIni->getInt(keyval.first, defaultInt));
    }
}

static void formatToLines(vector<string>* lines,
                          const unordered_map<string, string>& dataMap) {
    for (const auto& keyval : dataMap) {
        lines->push_back(keyval.first + " = " + keyval.second);
    }
}

TEST_F(IniFileTest, boolFormat) {
    static const unordered_map<string, string> validTrues = {{"true1", "yes"},
                                                             {"true2", "YES"},
                                                             {"true3", "true"},
                                                             {"true4", "TRUE"},
                                                             {"true5", "1"}};
    static const unordered_map<string, string> validFalses = {
            {"false1", "no"},
            {"false2", "NO"},
            {"false3", "false"},
            {"flase4", "FALSE"},
            {"false5", "0"}};
    static const unordered_map<string, string> invalidTrues = {
            {"true12", "blah"}, {"true13", "\"1\""}};
    static const unordered_map<string, string> invalidFalses = {
            {"false12", "blah"}, {"false13", "\"0\""}};

    vector<string> lines;
    formatToLines(&lines, validTrues);
    formatToLines(&lines, invalidTrues);
    formatToLines(&lines, validFalses);
    formatToLines(&lines, invalidFalses);
    writeIniFileData(lines);

    ASSERT_TRUE(mIni->read());
    EXPECT_EQ(lines.size(), mIni->size());
    for (const auto& keyval : validTrues) {
        EXPECT_TRUE(mIni->hasKey(keyval.first));
        EXPECT_TRUE(mIni->getBool(keyval.first, false));
    }
    for (const auto& keyval : validFalses) {
        EXPECT_TRUE(mIni->hasKey(keyval.first));
        EXPECT_FALSE(mIni->getBool(keyval.first, true));
    }
    for (const auto& keyval : invalidTrues) {
        // The keyval exists, it's just not a valid bool value.
        EXPECT_TRUE(mIni->hasKey(keyval.first));
        EXPECT_FALSE(mIni->getBool(keyval.first, false));
    }
    for (const auto& keyval : invalidFalses) {
        // The keyval exists, it's just not a valid bool value.
        EXPECT_TRUE(mIni->hasKey(keyval.first));
        EXPECT_TRUE(mIni->getBool(keyval.first, true));
    }
}

TEST_F(IniFileTest, diskSizeFormat) {
    static const unordered_map<string, string> validDiskSizes = {
            {"ThirtyB", "30"}, {"OneKilo", "1k"},  {"FiveKilo", "5K"},
            {"OneMega", "1m"}, {"FiveMega", "5M"}, {"OneGiga", "1g"},
            {"FiveGiga", "5G"}};
    static const unordered_map<string, string> invalidDiskSizes = {
            {"WrongUnit", "30hertz"},
            {"FractionalNumber", "2.14142135423"},
            {"FractionalKilo", "3.14K"},
            {"smiley_really", ";-)"}};

    vector<string> lines;
    formatToLines(&lines, validDiskSizes);
    formatToLines(&lines, invalidDiskSizes);
    writeIniFileData(lines);

    ASSERT_TRUE(mIni->read());
    EXPECT_EQ(lines.size(), mIni->size());
    EXPECT_EQ(30ULL, mIni->getDiskSize("ThirtyB", 99));
    EXPECT_EQ(1024ULL, mIni->getDiskSize("OneKilo", 99));
    EXPECT_EQ(1024 * 1024ULL, mIni->getDiskSize("OneMega", 99));
    EXPECT_EQ(1024 * 1024 * 1024ULL, mIni->getDiskSize("OneGiga", 99));
    EXPECT_EQ(5 * 1024ULL, mIni->getDiskSize("FiveKilo", 99));
    EXPECT_EQ(5 * 1024 * 1024ULL, mIni->getDiskSize("FiveMega", 99));
    EXPECT_EQ(5 * 1024 * 1024 * 1024ULL, mIni->getDiskSize("FiveGiga", 99));

    EXPECT_EQ(99L, mIni->getDiskSize("WrongUnit", 99L));
    EXPECT_EQ(99L, mIni->getDiskSize("FractionalNumber", 99L));
    EXPECT_EQ(99L, mIni->getDiskSize("FractionalKilo", 99L));
    EXPECT_EQ(99L, mIni->getDiskSize("smiley_really", 99L));
}

TEST_F(IniFileTest, discardEmpty) {
    mIni->setString("nonEmpty", "someValue");
    mIni->setString("empty", "");

    ASSERT_TRUE(mIni->write());
    mIni.reset(new IniFile(mIniFilePath));
    ASSERT_EQ(0, mIni->size());
    ASSERT_TRUE(mIni->read());
    EXPECT_EQ(2, mIni->size());
    EXPECT_EQ("someValue", mIni->getString("nonEmpty", "defaultString"));
    EXPECT_EQ("", mIni->getString("empty", "defaultString"));

    EXPECT_TRUE(mIni->writeDiscardingEmpty());
    mIni.reset(new IniFile(mIniFilePath));
    ASSERT_EQ(0, mIni->size());
    ASSERT_TRUE(mIni->read());
    EXPECT_EQ(1, mIni->size());
    EXPECT_EQ("someValue", mIni->getString("nonEmpty", "defaultString"));
    EXPECT_EQ("defaultString", mIni->getString("empty", "defaultString"));
}

TEST_F(IniFileTest, writeIfChanged) {
    // Initially, we must treat the object as dirty.
    // Hence, we'll clear the lines we'd written previously.
    mIni.reset(new IniFile(mIniFilePath));
    verifyFileUpdated(true);

    mIni->write();
    // Now we consider the object as clean, so write shouldn't modify the
    // underlying file.
    verifyFileUpdated(false);

    // Now let's change the data.
    mIni->setString("random", "yippeeee");
    verifyFileUpdated(true);

    mIni->read();
    // No changes, so write shouldn't do anything.
    verifyFileUpdated(false);
    // But resetting the file path means we should flush.
    mIni->setBackingFile(mIniFilePath);
    verifyFileUpdated(true);
}

TEST_F(IniFileTest, noBackingFile) {
    mIni.reset(new IniFile());
    ASSERT_FALSE(mIni->read());

    mIni->setBackingFile(mIniFilePath);
    ASSERT_FALSE(mIni->read());
    ASSERT_TRUE(mIni->write());
    ASSERT_TRUE(mIni->read());
}

TEST_F(IniFileTest, iterator) {
    mIni->setString("firstKey", "firstValue");
    mIni->setString("secondKey", "secondValue");

    // Const iterators, also verify order.
    const IniFile& cIni = *mIni;
    vector<string> keys = {"firstKey", "secondKey"};
    ASSERT_EQ(keys.size(), mIni->size());
    size_t i = 0;
    for (const auto& key : cIni) {
        EXPECT_EQ(keys[i], key);
        ++i;
    }
}

TEST_F(IniFileTest, diskFileOrder) {
    vector<string> lines = {
            "first = some valid value",  "second line is invalid",
            "; Third line is a comment", "fourth = is valid",
            "# Fifth is also a comment", "",
            ";Sixth was a comment",      "3p0 = is an invalid key",
            "lets = finish with valid"};
    vector<string> rewritten_lines = {"first = some valid value",
                                      "; Third line is a comment",
                                      "fourth = is valid",
                                      "# Fifth is also a comment",
                                      "",
                                      ";Sixth was a comment",
                                      "lets = finish with valid"};

    writeIniFileData(lines);
    ASSERT_TRUE(mIni->read());
    ASSERT_TRUE(mIni->write());
    verifyFileContents(rewritten_lines);

    // This is order indpendent. Let's try the reverse
    std::reverse(std::begin(lines), std::end(lines));
    std::reverse(std::begin(rewritten_lines), std::end(rewritten_lines));
    writeIniFileData(lines);
    ASSERT_TRUE(mIni->read());
    ASSERT_TRUE(mIni->write());
    verifyFileContents(rewritten_lines);

    // Extra keys are appended to the file.
    mIni->setString("extraKey", "extraValue");
    ASSERT_TRUE(mIni->write());
    rewritten_lines.push_back("extraKey = extraValue");
    verifyFileContents(rewritten_lines);

    // Test order of iteration in this complicated case.
    // Remeber we reversed the lines.
    vector<string> keys = {"lets", "fourth", "first", "extraKey"};
    ASSERT_EQ(keys.size(), mIni->size());
    size_t i = 0;
    for (const auto& key : *mIni) {
        EXPECT_EQ(keys[i], key);
        ++i;
    }
}

TEST_F(IniFileTest, strDefaultValues) {
    ASSERT_EQ(0, mIni->size());
    EXPECT_TRUE(mIni->getBoolStr("missingKey", "yes"));
    EXPECT_FALSE(mIni->getBoolStr("missingKey", "no"));
    EXPECT_EQ(1024ULL, mIni->getDiskSizeStr("missingKey", "1k"));
}

TEST_F(IniFileTest, makeValidKey) {
    EXPECT_STREQ("_key", IniFile::makeValidKey("key").c_str());
    EXPECT_STREQ("_", IniFile::makeValidKey("").c_str());
    EXPECT_STREQ("_.3D", IniFile::makeValidKey("=").c_str());
    EXPECT_STREQ("_a.20sign.20.23", IniFile::makeValidKey("a sign #").c_str());
    EXPECT_STREQ("_some.20number.2010.20within",
                 IniFile::makeValidKey("some number 10 within").c_str());
}

}  // namespace base
}  // namespace android