/*
 * main.cpp -- main test file for Ini
 *
 * Copyright (c) 2013, 2014 David Demelier <markand@malikania.fr>
 *
 * Permission to use, copy, modify, and/or distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <iostream>

#include <gtest/gtest.h>

#include <Ini.h>

class BasicTest : public testing::Test {
protected:
	Ini m_ini;

public:
	BasicTest()
		: m_ini("simple.conf")
	{
	}

};

TEST_F(BasicTest, simple)
{
	ASSERT_EQ(1, static_cast<int>(m_ini.size()));
}

TEST_F(BasicTest, iniOperators)
{
	try {
		ASSERT_EQ(3, static_cast<int>(m_ini[0].size()));
		ASSERT_EQ("general", m_ini[0].key());
		ASSERT_EQ("general", m_ini["general"].key());
	} catch (const std::exception &ex) {
		FAIL() << ex.what();
	}
}

TEST_F(BasicTest, iniSectionOperators)
{
	try {
		// option1=1 (indexes)
		ASSERT_EQ("option1", m_ini[0][0].key());
		ASSERT_EQ("1", m_ini[0][0].value());

		// option1=1 (keys)
		ASSERT_EQ("option1", m_ini["general"]["option1"].key());
		ASSERT_EQ("1", m_ini["general"]["option1"].value());

		// option2 =2 (indexes)
		ASSERT_EQ("option2", m_ini[0][1].key());
		ASSERT_EQ("2", m_ini[0][1].value());

		// option2 =2 (keys)
		ASSERT_EQ("option2", m_ini["general"]["option2"].key());
		ASSERT_EQ("2", m_ini["general"]["option2"].value());

		// option3 = 3 (indexes)
		ASSERT_EQ("option3", m_ini[0][2].key());
		ASSERT_EQ("3", m_ini[0][2].value());

		// option3 = 3 (keys)
		ASSERT_EQ("option3", m_ini["general"]["option3"].key());
		ASSERT_EQ("3", m_ini["general"]["option3"].value());
	} catch (const std::exception &ex) {
		FAIL() << ex.what();
	}
}

/* --------------------------------------------------------
 * Reserved tokens in words
 * -------------------------------------------------------- */

TEST(Tokens, iniReserved)
{
	try {
		Ini ini("tokens.conf");

		ASSERT_EQ("I have [brackets]", ini["tokens"]["bracket"].value());
		ASSERT_EQ("I have foo@at", ini["tokens"]["at"].value());
	} catch (const std::exception &ex) {
		FAIL() << ex.what();
	}
}

/* --------------------------------------------------------
 * Multiple definition
 * -------------------------------------------------------- */

class MultiTest : public testing::Test {
protected:
	Ini m_ini;

public:
	MultiTest()
		: m_ini("multi.conf")
	{
	}
};

TEST_F(MultiTest, defined)
{
	ASSERT_EQ(2, static_cast<int>(m_ini.size()));
	ASSERT_EQ("name", m_ini[0]["name"].key());
	ASSERT_EQ("Player", m_ini[0]["name"].value());
	ASSERT_EQ("version", m_ini[0]["version"].key());
	ASSERT_EQ("1.0", m_ini[0]["version"].value());
	ASSERT_EQ("name", m_ini[1]["name"].key());
	ASSERT_EQ("Subwinner", m_ini[1]["name"].value());
	ASSERT_EQ("version", m_ini[1]["version"].key());
	ASSERT_EQ("2.0", m_ini[1]["version"].value());
}

/* --------------------------------------------------------
 * Option with no values
 * -------------------------------------------------------- */

class NoValueTest : public testing::Test {
protected:
	Ini m_ini;

public:
	NoValueTest()
		: m_ini("novalue.conf")
	{
	}
};

TEST_F(NoValueTest, isDefined)
{
	ASSERT_EQ("plugins", m_ini[0].key());
	ASSERT_EQ("", m_ini["plugins"]["histedit"].value());
	ASSERT_EQ("", m_ini["plugins"]["highlight"].value());
	ASSERT_EQ("", m_ini["plugins"]["general"].value());
}

/* --------------------------------------------------------
 * Include tests
 * -------------------------------------------------------- */

class IncludeTest : public testing::Test {
protected:
	Ini m_ini;

public:
	IncludeTest()
		: m_ini("includes.conf")
	{
	}
};

TEST_F(IncludeTest, all)
{
	ASSERT_EQ(2, static_cast<int>(m_ini.size()));

	// from include
	ASSERT_EQ("1", m_ini[0][0].value());
	ASSERT_EQ("2", m_ini[0][1].value());
	ASSERT_EQ("3", m_ini[0][2].value());

	// from standard
	ASSERT_EQ("false", m_ini[1][0].value());
}

/* --------------------------------------------------------
 * Compact
 * -------------------------------------------------------- */

TEST(Compact, test)
{
	try {
		Ini ini("compact.conf");

		ASSERT_EQ(2, static_cast<int>(ini.size()));
		ASSERT_EQ("true", ini["general"]["verbose"].value());
		ASSERT_EQ("false", ini["general"]["foreground"].value());
		ASSERT_EQ("google.fr", ini["server"]["host"].value());
	} catch (const std::exception &ex) {
		FAIL() << ex.what();
	}
}

/* --------------------------------------------------------
 * Errors
 * -------------------------------------------------------- */

TEST(Errors, nosection)
{
	// An option outside a section is not allowed
	try {
		Ini ini("error-nosection.conf");

		FAIL() << "Failure expected, got success";
	} catch (const std::exception &ex) {
	}
}

TEST(Errors, lineassigment)
{
	// The = assignment must be on the same line as the option key
	try {
		Ini ini("error-lineassigment.conf");

		FAIL() << "Failure expected, got success";
	} catch (const std::exception &ex) {
	}
}

TEST(Errors, badcomment)
{
	// Comment can't between option-key and = assigment
	try {
		Ini ini("error-badcomment.conf");

		FAIL() << "Failure expected, got success";
	} catch (const std::exception &ex) {
	}
}

TEST(Errors, badsection)
{
	// Bad section naming
	try {
		Ini ini("error-badsection.conf");

		FAIL() << "Failure expected, got success";
	} catch (const std::exception &ex) {
		std::cout << ex.what() << std::endl;
	}
}

int main(int argc, char **argv)
{
	testing::InitGoogleTest(&argc, argv);

	return RUN_ALL_TESTS();
}