/*
 * main.cpp -- main test file for Utf8
 *
 * 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.
 */

/*
 * /!\ Be sure to keep this file with UTF-8 encoding /!\
 */

#include <gtest/gtest.h>

#include <Utf8.h>

using namespace testing;

/* --------------------------------------------------------
 * Conversion UTF32 -> UTF8
 * -------------------------------------------------------- */

TEST(Conversion32to8, ascii)
{
	try {
		std::u32string u32{'a', 'b', 'c'};
		std::string s = Utf8::toutf8(u32);

		ASSERT_EQ("abc", s);
	} catch (const std::exception &ex) {
		FAIL() << ex.what();
	}
}

TEST(Conversion32to8, valid)
{
	try {
		std::u32string u32{'a', /* é */ 233, 'c'};
		std::string s = Utf8::toutf8(u32);

		ASSERT_EQ("aéc", s);
	} catch (const std::exception &ex) {
		FAIL() << ex.what();
	}
}

TEST(Conversion32to8, invalid)
{
	try {
		std::u32string u32{'a', 0xFFFFFFFF, 'c'};
		std::string s = Utf8::toutf8(u32);

		FAIL() << "expected a failure";
	} catch (const std::exception &ex) {
		SUCCEED();
	}
}

/* --------------------------------------------------------
 * Conversion UTF8 -> UTF32
 * -------------------------------------------------------- */

TEST(Conversion8to32, ascii)
{
	try {
		std::string s{"abc"};
		std::u32string expected{'a', 'b', 'c'};
		std::u32string result = Utf8::toutf32(s);

		ASSERT_EQ(expected, result);
	} catch (const std::exception &ex) {
		FAIL() << ex.what();
	}
}

TEST(Conversion8to32, valid)
{
	try {
		std::string s{"aéc"};
		std::u32string expected{'a', /* é */ 233, 'c'};
		std::u32string result = Utf8::toutf32(s);

		ASSERT_EQ(expected, result);
	} catch (const std::exception &ex) {
		FAIL() << ex.what();
	}
}

/* --------------------------------------------------------
 * UTF32 to upper
 * -------------------------------------------------------- */

TEST(Toupper32, ascii)
{
	try {
		std::u32string u32{'a', 'b', 'c'};
		std::u32string expected{'A', 'B', 'C'};
		std::u32string result = Utf8::toupper(u32);

		ASSERT_EQ(expected, result);
	} catch (const std::exception &ex) {
		FAIL() << ex.what();
	}
}

TEST(Toupper32, valid)
{
	try {
		std::u32string u32{/* ä */ 228, /* ç */ 231, /* ë */ 235};
		std::u32string expected{/* Ä */ 196, /* Ç */ 199, /* Ë */ 203};
		std::u32string result = Utf8::toupper(u32);

		ASSERT_EQ(expected, result);
	} catch (const std::exception &ex) {
		FAIL() << ex.what();
	}
}

TEST(Toupper32, invalid)
{
	try {
		std::u32string u32{'a', 0xFFFFFFFF, 'b'};
		std::u32string expected{'A', 0xFFFFFFFF, 'B'};
		std::u32string result = Utf8::toupper(u32);

		ASSERT_EQ(expected, result);
	} catch (const std::exception &ex) {
		FAIL() << ex.what();
	}
}

/* --------------------------------------------------------
 * UTF32 to lower
 * -------------------------------------------------------- */

TEST(Tolower32, ascii)
{
	try {
		std::u32string u32{'A', 'B', 'C'};
		std::u32string expected{'a', 'b', 'c'};
		std::u32string result = Utf8::tolower(u32);

		ASSERT_EQ(expected, result);
	} catch (const std::exception &ex) {
		FAIL() << ex.what();
	}
}

TEST(Tolower32, valid)
{
	try {
		std::u32string u32{/* Ä */ 196, /* Ç */ 199, /* Ë */ 203};
		std::u32string expected{/* ä */ 228, /* ç */ 231, /* ë */ 235};
		std::u32string result = Utf8::tolower(u32);

		ASSERT_EQ(expected, result);
	} catch (const std::exception &ex) {
		FAIL() << ex.what();
	}
}

TEST(Tolower32, invalid)
{
	try {
		std::u32string u32{'A', 0xFFFFFFFF, 'B'};
		std::u32string expected{'a', 0xFFFFFFFF, 'b'};
		std::u32string result = Utf8::tolower(u32);

		ASSERT_EQ(expected, result);
	} catch (const std::exception &ex) {
		FAIL() << ex.what();
	}
}

/* --------------------------------------------------------
 * UTF8 to upper
 * -------------------------------------------------------- */

TEST(Toupper8, ascii)
{
	try {
		std::string s{"abc"};
		std::string r = Utf8::toupper(s);

		ASSERT_EQ("ABC", r);
	} catch (const std::exception &ex) {
		FAIL() << ex.what();
	}
}

TEST(Toupper8, valid)
{
	try {
		std::string s{"aéc"};
		std::string r = Utf8::toupper(s);

		ASSERT_EQ("AÉC", r);
	} catch (const std::exception &ex) {
		FAIL() << ex.what();
	}
}

TEST(Toupper8, invalid)
{
	try {
		std::string s{"a" "\xFF""b"};
		std::string r = Utf8::toupper(s);

		FAIL() << "expected a failure";
	} catch (const std::exception &ex) {
		SUCCEED();
	}
}

/* --------------------------------------------------------
 * UTF8 to lower
 * -------------------------------------------------------- */

TEST(Tolower8, ascii)
{
	try {
		std::string s{"ABC"};
		std::string r = Utf8::tolower(s);

		ASSERT_EQ("abc", r);
	} catch (const std::exception &ex) {
		FAIL() << ex.what();
	}
}

TEST(Tolower8, valid)
{
	try {
		std::string s{"AÉC"};
		std::string r = Utf8::tolower(s);

		ASSERT_EQ("aéc", r);
	} catch (const std::exception &ex) {
		FAIL() << ex.what();
	}
}

TEST(Tolower8, invalid)
{
	try {
		std::string s{"A" "\xFF""B"};
		std::string r = Utf8::tolower(s);

		FAIL() << "expected a failure";
	} catch (const std::exception &ex) {
		SUCCEED();
	}
}

/* --------------------------------------------------------
 * Check functions
 * -------------------------------------------------------- */

TEST(Check, isspace)
{
	ASSERT_TRUE(Utf8::isspace(' '));
	ASSERT_FALSE(Utf8::isspace(/* é */ 233));
}

TEST(Check, isletter)
{
	ASSERT_TRUE(Utf8::isletter(/* é */ 233));
	ASSERT_FALSE(Utf8::isletter(/* € */ 8364));
}

TEST(Check, isupper)
{
	ASSERT_FALSE(Utf8::isupper('a'));
	ASSERT_FALSE(Utf8::isupper(/* é */ 233));
	ASSERT_TRUE(Utf8::isupper('A'));
	ASSERT_TRUE(Utf8::isupper(/* É */ 201));
}

TEST(Check, islower)
{
	ASSERT_TRUE(Utf8::islower('a'));
	ASSERT_TRUE(Utf8::islower(/* é */ 233));
	ASSERT_FALSE(Utf8::islower('A'));
	ASSERT_FALSE(Utf8::islower(/* É */ 201));
}

/* --------------------------------------------------------
 * Miscellaneous
 * -------------------------------------------------------- */

TEST(Misc, nbytesPoint)
{
	ASSERT_EQ(1, Utf8::nbytesPoint('a'));
	ASSERT_EQ(2, Utf8::nbytesPoint(/* é */ 233));
	ASSERT_EQ(3, Utf8::nbytesPoint(/* € */ 8364));
	ASSERT_EQ(4, Utf8::nbytesPoint(/* 𠀀 */ 131072));
}

TEST(Misc, nbytesUtf8)
{
	std::string s1{"a"};
	std::string s2{"é"};
	std::string s3{"€"};
	std::string s4{"𠀀"};

	ASSERT_EQ(1, Utf8::nbytesUtf8(s1[0]));
	ASSERT_EQ(2, Utf8::nbytesUtf8(s2[0]));
	ASSERT_EQ(3, Utf8::nbytesUtf8(s3[0]));
	ASSERT_EQ(4, Utf8::nbytesUtf8(s4[0]));	
}

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

	return RUN_ALL_TESTS();
}