/*
 * main.cpp -- main test file for XDG
 *
 * Copyright (c) 2013-2016 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 <gtest/gtest.h>

#include <xdg.hpp>

using namespace testing;

namespace {

std::string myhome;

}

#if defined(_WIN32)

inline bool unsetenv(std::string name)
{
    name += "=";

    _putenv(name.c_str());

    return true;
}

inline bool setenv(const std::string &name, const std::string &value, bool)
{
    std::string t = name + "=" + value;

    _putenv(t.c_str());

    return true;
}

#endif

TEST(HomeEmpty, config)
{
    ASSERT_TRUE(unsetenv("XDG_CONFIG_HOME") == 0);

    Xdg xdg;

    ASSERT_EQ(myhome + "/.config", xdg.configHome());
}

TEST(HomeEmpty, data)
{
    ASSERT_TRUE(unsetenv("XDG_DATA_HOME") == 0);

    Xdg xdg;

    ASSERT_EQ(myhome + "/.local/share", xdg.dataHome());
}

TEST(HomeEmpty, cache)
{
    ASSERT_TRUE(unsetenv("XDG_CACHE_HOME") == 0);

    Xdg xdg;

    ASSERT_EQ(myhome + "/.cache", xdg.cacheHome());
}

TEST(HomeEmpty, runtime)
{
    ASSERT_TRUE(unsetenv("XDG_RUNTIME_DIR") == 0);

    Xdg xdg;

    ASSERT_TRUE(xdg.runtimeDir().empty());
}

TEST(HomeValid, config)
{
    ASSERT_TRUE(setenv("XDG_CONFIG_HOME", "/test/config", true) == 0);

    Xdg xdg;

    ASSERT_EQ("/test/config", xdg.configHome());
}

TEST(HomeValid, data)
{
    ASSERT_TRUE(setenv("XDG_DATA_HOME", "/test/data", true) == 0);

    Xdg xdg;

    ASSERT_EQ("/test/data", xdg.dataHome());
}

TEST(HomeValid, cache)
{
    ASSERT_TRUE(setenv("XDG_CACHE_HOME", "/test/cache", true) == 0);

    Xdg xdg;

    ASSERT_EQ("/test/cache", xdg.cacheHome());
}

TEST(HomeValid, runtime)
{
    ASSERT_TRUE(setenv("XDG_RUNTIME_DIR", "/test/runtime", true) == 0);

    Xdg xdg;

    ASSERT_EQ("/test/runtime", xdg.runtimeDir());
}

TEST(HomeInvalid, config)
{
    ASSERT_TRUE(setenv("XDG_CONFIG_HOME", "invalid", true) == 0);

    Xdg xdg;

    ASSERT_EQ(myhome + "/.config", xdg.configHome());
}

TEST(HomeInvalid, data)
{
    ASSERT_TRUE(setenv("XDG_DATA_HOME", "invalid", true) == 0);

    Xdg xdg;

    ASSERT_EQ(myhome + "/.local/share", xdg.dataHome());
}

TEST(HomeInvalid, cache)
{
    ASSERT_TRUE(setenv("XDG_CACHE_HOME", "invalid", true) == 0);

    Xdg xdg;

    ASSERT_EQ(myhome + "/.cache", xdg.cacheHome());
}

TEST(HomeInvalid, runtime)
{
    ASSERT_TRUE(setenv("XDG_RUNTIME_DIR", "invalid", true) == 0);

    Xdg xdg;

    ASSERT_TRUE(xdg.runtimeDir().empty());
}

TEST(DirectoriesEmpty, config)
{
    ASSERT_TRUE(unsetenv("XDG_CONFIG_DIRS") == 0);

    Xdg xdg;

    const auto &list = xdg.configDirs();

    ASSERT_EQ((size_t)1, list.size());
    ASSERT_EQ("/etc/xdg", list[0]);
}

TEST(DirectoriesEmpty, data)
{
    ASSERT_TRUE(unsetenv("XDG_DATA_DIRS") == 0);

    Xdg xdg;

    const auto &list = xdg.dataDirs();

    ASSERT_EQ((size_t)2, list.size());
    ASSERT_EQ("/usr/local/share", list[0]);
    ASSERT_EQ("/usr/share", list[1]);
}

TEST(DirectoriesValid, config)
{
    ASSERT_TRUE(setenv("XDG_CONFIG_DIRS", "/config1:/config2", true) == 0);

    Xdg xdg;

    const auto &list = xdg.configDirs();

    ASSERT_EQ((size_t)2, list.size());
    ASSERT_EQ("/config1", list[0]);
    ASSERT_EQ("/config2", list[1]);
}

TEST(DirectoriesValid, data)
{
    ASSERT_TRUE(setenv("XDG_DATA_DIRS", "/data1:/data2", true) == 0);

    Xdg xdg;

    const auto &list = xdg.dataDirs();

    ASSERT_EQ((size_t)2, list.size());
    ASSERT_EQ("/data1", list[0]);
    ASSERT_EQ("/data2", list[1]);
}

TEST(DirectoriesInvalid, config)
{
    ASSERT_TRUE(setenv("XDG_CONFIG_DIRS", "bad1:bad2", true) == 0);

    Xdg xdg;

    const auto &list = xdg.configDirs();

    ASSERT_EQ((size_t)1, list.size());
    ASSERT_EQ("/etc/xdg", list[0]);
}

TEST(DirectoriesInvalid, data)
{
    ASSERT_TRUE(setenv("XDG_DATA_DIRS", "bad1:bad2", true) == 0);

    Xdg xdg;

    const auto &list = xdg.dataDirs();

    ASSERT_EQ((size_t)2, list.size());
    ASSERT_EQ("/usr/local/share", list[0]);
    ASSERT_EQ("/usr/share", list[1]);
}

TEST(DirectoriesMixed, config)
{
    ASSERT_TRUE(setenv("XDG_CONFIG_DIRS", "/config1:bad:/config2", true) == 0);

    Xdg xdg;

    const auto &list = xdg.configDirs();

    ASSERT_EQ((size_t)2, list.size());
    ASSERT_EQ("/config1", list[0]);
    ASSERT_EQ("/config2", list[1]);
}

TEST(DirectoriesMixed, data)
{
    ASSERT_TRUE(setenv("XDG_DATA_DIRS", "/data1:bad:/data2", true) == 0);

    Xdg xdg;

    const auto &list = xdg.dataDirs();

    ASSERT_EQ((size_t)2, list.size());
    ASSERT_EQ("/data1", list[0]);
    ASSERT_EQ("/data2", list[1]);
}

int main(int argc, char **argv)
{
    auto home = getenv("HOME");

    if (home == nullptr)
        return 0;

    myhome = home;
    InitGoogleTest(&argc, argv);

    return RUN_ALL_TESTS();
}