// Copyright 2016 Yahoo Inc. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
#include <vespa/fastos/fastos.h>
#include <limits>
#include <vespa/log/log.h>
LOG_SETUP("identifiable_test");
#include <vespa/vespalib/testkit/testapp.h>
#include <vespa/vespalib/stllike/asciistream.h>
#include <vespa/vespalib/util/exceptions.h>
#include <iomanip>

using namespace vespalib;

class AsciistreamTest : public TestApp
{
public:
    int Main();
    template <typename T>
    void verify(T first, T second, const char * firstResult, const char * secondResult, char delim);
    template <typename T>
    void verifyBothWays(T value, const char * firstResult);
    void testIntegerManip();
    void testFill();
    void testString();
    void testCreateFromFile();
    void testWriteThenRead();
    void testGetLine();
    void testCopyConstruct();
    void testIllegalNumbers();
    void testDouble();
};

template <typename T>
void
AsciistreamTest::verifyBothWays(T value, const char * expected)
{
    asciistream os;
    os << value;
    EXPECT_EQUAL(os.str(), string(expected));
    EXPECT_EQUAL(os.size(), strlen(expected));
    T v;
    os >> v;
    EXPECT_EQUAL(value, v);
    EXPECT_TRUE(os.empty());
}

template <typename T>
void
AsciistreamTest::verify(T first, T second, const char * firstResult, const char * secondResult, char delim)
{
    asciistream os;
    std::ostringstream ss;
    os << first;
    ss << first;
    EXPECT_EQUAL(os.str(), string(firstResult));
    EXPECT_EQUAL(os.size(), strlen(firstResult));
    EXPECT_EQUAL(ss.str().size(), strlen(firstResult));
    EXPECT_EQUAL(strcmp(ss.str().c_str(), firstResult), 0);
    os << delim << second;
    ss << delim << second;
    EXPECT_EQUAL(os.size(), strlen(secondResult));
    EXPECT_EQUAL(ss.str().size(), strlen(secondResult));
    EXPECT_EQUAL(strcmp(os.c_str(), secondResult), 0);
    EXPECT_EQUAL(strcmp(ss.str().c_str(), secondResult), 0);
}

void
AsciistreamTest::testIllegalNumbers()
{
    {
        asciistream is("777777777777");
        uint16_t s(0);
        EXPECT_EXCEPTION(is >> s, IllegalArgumentException, "An uint16_t can not represent '777777777777'");
        EXPECT_EQUAL(12u, is.size());
        uint32_t i(0);
        EXPECT_EXCEPTION(is >> i, IllegalArgumentException, "An uint32_t can not represent '777777777777'");
        EXPECT_EQUAL(12u, is.size());
        int16_t si(0);
        EXPECT_EXCEPTION(is >> si, IllegalArgumentException, "An int16_t can not represent '777777777777'");
        EXPECT_EQUAL(12u, is.size());
        int32_t ii(0);
        EXPECT_EXCEPTION(is >> ii, IllegalArgumentException, "An int32_t can not represent '777777777777'");
        EXPECT_EQUAL(12u, is.size());
        is << "777777777777";
        EXPECT_EQUAL(24u, is.size());
        uint64_t l(0);
        EXPECT_EXCEPTION(is >> l, IllegalArgumentException, "uint64_t value is outside of range '777777777777777777777777'");
        EXPECT_EQUAL(24u, is.size());
        int64_t li(0);
        EXPECT_EXCEPTION(is >> li, IllegalArgumentException, "int64_t value is outside of range '777777777777777777777777'");
        EXPECT_EQUAL(24u, is.size());
    }
    {
        asciistream is("-77");
        uint16_t s(0);
        EXPECT_EXCEPTION(is >> s, IllegalArgumentException, "An uint16_t can not represent '-77'");
        EXPECT_EQUAL(3u, is.size());
        uint32_t i(0);
        EXPECT_EXCEPTION(is >> i, IllegalArgumentException, "An uint32_t can not represent '-77'");
        EXPECT_EQUAL(3u, is.size());
    }
    {
        asciistream is("7777777777777777777777777777777777777777");
        EXPECT_EQUAL(40u, is.size());
        float f(0);
        EXPECT_EXCEPTION(is >> f, IllegalArgumentException, "float value is outside of range '7777777777777777777777777777777777777777'");
        EXPECT_EQUAL(40u, is.size());
        is << "e" << is.str();
        EXPECT_EQUAL(81u, is.size());
        double d(0);
        EXPECT_EXCEPTION(is >> d, IllegalArgumentException, "double value is outside of range '7777777777777777777777777777777777777777e7777777777777777777777777777777777777777'");
        EXPECT_EQUAL(81u, is.size());
    }
    {
        asciistream is("a");
        char c(' ');
        EXPECT_EQUAL(1u, is.size());
        is >> c;
        EXPECT_EQUAL('a', c);
        EXPECT_TRUE(is.empty());
        EXPECT_EXCEPTION(is >> c, IllegalArgumentException, "buffer underflow at pos 1.");
        EXPECT_TRUE(is.empty());
        unsigned char u(' ');
        EXPECT_EXCEPTION(is >> u, IllegalArgumentException, "buffer underflow at pos 1.");
        EXPECT_TRUE(is.empty());
        bool b(false);
        EXPECT_EXCEPTION(is >> b, IllegalArgumentException, "buffer underflow at pos 1.");
        EXPECT_TRUE(is.empty());
        {
            uint32_t l(0);
            EXPECT_EXCEPTION(is >> l, IllegalArgumentException, "Failed decoding a uint64_t from ''.");
            EXPECT_TRUE(is.empty());
        }
        {
            int32_t l(0);
            EXPECT_EXCEPTION(is >> l, IllegalArgumentException, "Failed decoding a int64_t from ''.");
            EXPECT_TRUE(is.empty());
        }
        {
            float l(0);
            EXPECT_EXCEPTION(is >> l, IllegalArgumentException, "Failed decoding a float from ''.");
            EXPECT_TRUE(is.empty());
        }
        {
            double l(0);
            EXPECT_EXCEPTION(is >> l, IllegalArgumentException, "Failed decoding a double from ''.");
            EXPECT_TRUE(is.empty());
        }

    }
}

void
AsciistreamTest::testCopyConstruct()
{
    asciistream os;
    os << "test1";
    asciistream os2(os);
    EXPECT_EQUAL(os.str(), os2.str());
    os2 << " test2";
    EXPECT_FALSE(os.str() == os2.str());
    asciistream os3(os);
    os3 = os2;
    EXPECT_EQUAL(os2.str(), os3.str());
    os.swap(os2);
    EXPECT_EQUAL(os.str(), os3.str());
    EXPECT_FALSE(os3.str() == os2.str());
    os.swap(os2);
    EXPECT_TRUE(os3.str() == os2.str());
}

void
AsciistreamTest::testIntegerManip()
{
    asciistream os;
    std::ostringstream ss;
    os << 10;
    ss << 10;
    EXPECT_EQUAL(os.size(), 2u);
    EXPECT_EQUAL(ss.str().size(), 2u);
    EXPECT_EQUAL(strcmp(os.c_str(), "10"), 0);
    EXPECT_EQUAL(strcmp(ss.str().c_str(), "10"), 0);
    os << ' ' << dec << 10;
    ss << ' ' << std::dec << 10;
    EXPECT_EQUAL(os.size(), 5u);
    EXPECT_EQUAL(ss.str().size(), 5u);
    EXPECT_EQUAL(strcmp(os.c_str(), "10 10"), 0);
    EXPECT_EQUAL(strcmp(ss.str().c_str(), "10 10"), 0);
    os << ' ' << hex << 10 << ' ' << 11;
    ss << ' ' << std::hex << 10 << ' ' << 11;
    EXPECT_EQUAL(os.size(), 9u);
    EXPECT_EQUAL(ss.str().size(), 9u);
    EXPECT_EQUAL(strcmp(os.c_str(), "10 10 a b"), 0);
    EXPECT_EQUAL(strcmp(ss.str().c_str(), "10 10 a b"), 0);
    os << ' ' << oct << 10;
    ss << ' ' << std::oct << 10;
    EXPECT_EQUAL(os.size(), 12u);
    EXPECT_EQUAL(ss.str().size(), 12u);
    EXPECT_EQUAL(strcmp(os.c_str(), "10 10 a b 12"), 0);
    EXPECT_EQUAL(strcmp(ss.str().c_str(), "10 10 a b 12"), 0);

    // std::bin not supported by std::streams.
    os << ' ' << bin << 10;
    EXPECT_EQUAL(os.size(), 19u);
    EXPECT_EQUAL(strcmp(os.c_str(), "10 10 a b 12 0b1010"), 0);

    void *fooptr = reinterpret_cast<void*>(0x1badbadc0ffeeull);
    // Also test that number base is restored OK after ptr print
    os << dec << ' ' << fooptr << ' ' << 1234;
    ss << std::dec << ' ' << fooptr << ' ' << 1234;
    EXPECT_EQUAL(std::string("10 10 a b 12 0b1010 0x1badbadc0ffee 1234"), os.str());
    EXPECT_EQUAL(std::string("10 10 a b 12 0x1badbadc0ffee 1234"), ss.str());

    int i = 0;
    const char *digits = "12345";
    std::string ffs(digits, 4);
    std::istringstream std_istr(ffs);
    std_istr >> i;
    EXPECT_EQUAL(1234, i);

    stringref firstfour(digits, 4);
    asciistream istr(firstfour);
    istr >> i;
    EXPECT_EQUAL(1234, i);
}


void
AsciistreamTest::testFill()
{
    {
        asciistream os;
        std::ostringstream ss;
        os << 10 << ' ' << setfill('h') << 11;
        ss << 10 << ' ' << std::setfill('h') << 11;
        EXPECT_EQUAL(os.size(), 5u);
        EXPECT_EQUAL(ss.str().size(), 5u);
        EXPECT_EQUAL(strcmp(os.c_str(), "10 11"), 0);
        EXPECT_EQUAL(strcmp(ss.str().c_str(), "10 11"), 0);
        os << setw(4) << 10 << ' ' << 11;
        ss << std::setw(4) << 10 << ' ' << 11;
        EXPECT_EQUAL(os.size(), 12u);
        EXPECT_EQUAL(ss.str().size(), 12u);
        EXPECT_EQUAL(strcmp(os.c_str(), "10 11hh10 11"), 0);
        EXPECT_EQUAL(strcmp(ss.str().c_str(), "10 11hh10 11"), 0);
        os << setw(4) << 10 << ' ' << 11;
        ss << std::setw(4) << 10 << ' ' << 11;
        EXPECT_EQUAL(os.size(), 19u);
        EXPECT_EQUAL(ss.str().size(), 19u);
        EXPECT_EQUAL(strcmp(os.c_str(), "10 11hh10 11hh10 11"), 0);
        EXPECT_EQUAL(strcmp(ss.str().c_str(), "10 11hh10 11hh10 11"), 0);
    }
    {
        asciistream os;
        std::ostringstream ss;
        os << setfill('X') << setw(19) << 'a';
        ss << std::setfill('X') << std::setw(19) << 'a';
        EXPECT_EQUAL(os.size(), 19u);
        EXPECT_EQUAL(ss.str().size(), 19u);
        EXPECT_EQUAL(strcmp(os.c_str(), "XXXXXXXXXXXXXXXXXXa"), 0);
        EXPECT_EQUAL(strcmp(ss.str().c_str(), "XXXXXXXXXXXXXXXXXXa"), 0);
    }
    {
        asciistream os;
        std::ostringstream ss;
        os << setfill('X') << setw(19) << "a";
        ss << std::setfill('X') << std::setw(19) << "a";
        EXPECT_EQUAL(os.size(), 19u);
        EXPECT_EQUAL(ss.str().size(), 19u);
        EXPECT_EQUAL(strcmp(os.c_str(), "XXXXXXXXXXXXXXXXXXa"), 0);
        EXPECT_EQUAL(strcmp(ss.str().c_str(), "XXXXXXXXXXXXXXXXXXa"), 0);
    }
    {
        float f(8.9);
        asciistream os;
        std::ostringstream ss;
        os << setfill('X') << setw(19) << f;
        ss << std::setfill('X') << std::setw(19) << f;
        EXPECT_EQUAL(os.size(), 19u);
        EXPECT_EQUAL(ss.str().size(), 19u);
        EXPECT_EQUAL(strcmp(os.c_str(), "XXXXXXXXXXXXXXXX8.9"), 0);
        EXPECT_EQUAL(strcmp(ss.str().c_str(), "XXXXXXXXXXXXXXXX8.9"), 0);
    }
    {
        double f(8.9);
        asciistream os;
        std::ostringstream ss;
        os << setfill('X') << setw(19) << f;
        ss << std::setfill('X') << std::setw(19) << f;
        EXPECT_EQUAL(os.size(), 19u);
        EXPECT_EQUAL(ss.str().size(), 19u);
        EXPECT_EQUAL(strcmp(os.c_str(), "XXXXXXXXXXXXXXXX8.9"), 0);
        EXPECT_EQUAL(strcmp(ss.str().c_str(), "XXXXXXXXXXXXXXXX8.9"), 0);
    }

}

void
AsciistreamTest::testString()
{

    std::string ss("a");
    vespalib::string vs("a");
    {
        std::ostringstream oss;
        oss << ss << vs;
        EXPECT_EQUAL("aa", oss.str());
    }
    {
        asciistream oss;
        oss << ss << vs;
        EXPECT_EQUAL("aa", oss.str());
    }
    {
        std::istringstream iss("b c");
        iss >> ss >> vs;
        EXPECT_EQUAL("b", ss);
        EXPECT_EQUAL("c", vs);
    }
    {
        std::istringstream iss("b c");
        iss >> vs >> ss;
        EXPECT_EQUAL("b", vs);
        EXPECT_EQUAL("c", ss);
    }
    {
        asciistream iss("b c");
        iss >> ss >> vs;
        EXPECT_EQUAL("b", ss);
        EXPECT_EQUAL("c", vs);
    }
    {
        asciistream iss("b c");
        iss >> vs >> ss;
        EXPECT_EQUAL("b", vs);
        EXPECT_EQUAL("c", ss);
    }
}

void
AsciistreamTest::testCreateFromFile()
{
    asciistream is(asciistream::createFromFile("non-existing.txt"));
    EXPECT_TRUE(is.eof());

    is = asciistream::createFromFile(vespalib::TestApp::GetSourceDirectory() + "test.txt");
    EXPECT_FALSE(is.eof());
    EXPECT_EQUAL(12u, is.size());
    string s;
    is >> s;
    EXPECT_EQUAL("line1", s);
    is >> s;
    EXPECT_EQUAL("line2", s);
    EXPECT_FALSE(is.eof());
    is >> s;
    EXPECT_EQUAL("", s);
    EXPECT_TRUE(is.eof());

    is = asciistream::createFromDevice("/proc/stat");
    EXPECT_FALSE(is.eof());
}

void
AsciistreamTest::testWriteThenRead()
{
    asciistream ios;
    ios << "3 words";
    int n(0);
    string v;
    ios >> n >> v;
    EXPECT_EQUAL(3, n);
    EXPECT_EQUAL("words", v);
    EXPECT_TRUE(ios.eof());
}

void
AsciistreamTest::testGetLine()
{
    asciistream is("");
    EXPECT_TRUE(is.getlines().empty());
    is = asciistream("line 1");
    std::vector<string> v = is.getlines();
    EXPECT_EQUAL(1u, v.size());
    EXPECT_EQUAL("line 1", v[0]);
    is = asciistream("line 1\nline 2");
    v = is.getlines();
    EXPECT_EQUAL(2u, v.size());
    EXPECT_EQUAL("line 1", v[0]);
    EXPECT_EQUAL("line 2", v[1]);
    is = asciistream("line 1\nline 2\n\n");
    v = is.getlines();
    EXPECT_EQUAL(3u, v.size());
    EXPECT_EQUAL("line 1", v[0]);
    EXPECT_EQUAL("line 2", v[1]);
    EXPECT_EQUAL("", v[2]);
    is = asciistream("line 1");
    string s;
    getline(is, s);
    EXPECT_EQUAL("line 1", s);
}

#define VERIFY_DOUBLE_SERIALIZATION(value, expected, format, precision) { \
    asciistream mystream; \
    mystream << format; \
    if (precision > 0) mystream << asciistream::Precision(precision); \
    mystream << value; \
    EXPECT_EQUAL(expected, mystream.str()); \
}

void
AsciistreamTest::testDouble() {
    VERIFY_DOUBLE_SERIALIZATION(0.0, "0.000000", fixed, -1);
    VERIFY_DOUBLE_SERIALIZATION(0.0, "0.000000e+00", scientific, -1);
    VERIFY_DOUBLE_SERIALIZATION(0.0, "0", automatic, -1);

    VERIFY_DOUBLE_SERIALIZATION(0.0, "0.0", fixed, 1);
    VERIFY_DOUBLE_SERIALIZATION(0.0, "0.0e+00", scientific, 1);
    VERIFY_DOUBLE_SERIALIZATION(0.0, "0", automatic, 1);

    VERIFY_DOUBLE_SERIALIZATION(0.0, "0.0000000000000000", fixed, 16);
    VERIFY_DOUBLE_SERIALIZATION(0.0, "0.0000000000000000e+00", scientific, 16);
    VERIFY_DOUBLE_SERIALIZATION(0.0, "0", automatic, 16);

    double maxVal = std::numeric_limits<double>::max();
    VERIFY_DOUBLE_SERIALIZATION(maxVal, "179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.000000", fixed, -1);
    VERIFY_DOUBLE_SERIALIZATION(maxVal, "1.797693e+308", scientific, -1);
    VERIFY_DOUBLE_SERIALIZATION(maxVal, "1.79769e+308", automatic, -1);

    VERIFY_DOUBLE_SERIALIZATION(maxVal, "179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.0", fixed, 1);
    VERIFY_DOUBLE_SERIALIZATION(maxVal, "1.8e+308", scientific, 1);
    VERIFY_DOUBLE_SERIALIZATION(maxVal, "2e+308", automatic, 1);

    VERIFY_DOUBLE_SERIALIZATION(maxVal, "179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.0000000000000000", fixed, 16);
    VERIFY_DOUBLE_SERIALIZATION(maxVal, "1.7976931348623157e+308", scientific, 16)
    VERIFY_DOUBLE_SERIALIZATION(maxVal, "1.797693134862316e+308", automatic, 16);

    double minVal = std::numeric_limits<double>::min();
    VERIFY_DOUBLE_SERIALIZATION(minVal, "0.000000", fixed, -1);
    VERIFY_DOUBLE_SERIALIZATION(minVal, "2.225074e-308", scientific, -1);
    VERIFY_DOUBLE_SERIALIZATION(minVal, "2.22507e-308", automatic, -1);

    VERIFY_DOUBLE_SERIALIZATION(minVal, "0.0", fixed, 1);
    VERIFY_DOUBLE_SERIALIZATION(minVal, "2.2e-308", scientific, 1);
    VERIFY_DOUBLE_SERIALIZATION(minVal, "2e-308", automatic, 1);

    VERIFY_DOUBLE_SERIALIZATION(minVal, "0.0000000000000000", fixed, 16);
    VERIFY_DOUBLE_SERIALIZATION(minVal, "2.2250738585072014e-308", scientific, 16);
    VERIFY_DOUBLE_SERIALIZATION(minVal, "2.225073858507201e-308", automatic, 16);

    double maxInteger = uint64_t(1) << 53;
    VERIFY_DOUBLE_SERIALIZATION(maxInteger, "9007199254740992.000000", fixed, -1);
    VERIFY_DOUBLE_SERIALIZATION(maxInteger, "9.007199e+15", scientific, -1);
    VERIFY_DOUBLE_SERIALIZATION(maxInteger, "9.0072e+15", automatic, -1);

    VERIFY_DOUBLE_SERIALIZATION(maxInteger, "9007199254740992.0", fixed, 1);
    VERIFY_DOUBLE_SERIALIZATION(maxInteger, "9.0e+15", scientific, 1);
    VERIFY_DOUBLE_SERIALIZATION(maxInteger, "9e+15", automatic, 1);

    VERIFY_DOUBLE_SERIALIZATION(maxInteger, "9007199254740992.0000000000000000", fixed, 16);
    VERIFY_DOUBLE_SERIALIZATION(maxInteger, "9.0071992547409920e+15", scientific, 16);
    VERIFY_DOUBLE_SERIALIZATION(maxInteger, "9007199254740992", automatic, 16);

    VERIFY_DOUBLE_SERIALIZATION(0.0, "0.0", automatic << forcedot, -1);
    VERIFY_DOUBLE_SERIALIZATION(0.0, "0.0", automatic << forcedot, 1);
    VERIFY_DOUBLE_SERIALIZATION(0.0, "0.0", automatic << forcedot, 16);
    VERIFY_DOUBLE_SERIALIZATION(maxInteger, "9007199254740992.0", automatic << forcedot, 16);
}

int
AsciistreamTest::Main()
{
    TEST_INIT("asciistream_test");

    TEST_DO(verify("per", "paal", "per", "per paal", ' '));
    TEST_DO(verify<float>(7.89, -1.3, "7.89", "7.89 -1.3", ' '));
    TEST_DO(verify<double>(7.89, -1.3, "7.89", "7.89 -1.3", ' '));
    TEST_DO(verify<bool>(true, false, "1", "1 0", ' '));
    TEST_DO(verify<char>(65, 66, "A", "A B", ' '));
//    TEST_DO(verify<int8_t>(65, -1, "65", "65 -1", ' '));
    TEST_DO(verify<int16_t>(0, -1, "0", "0 -1", ' '));
    TEST_DO(verify<int16_t>(789, -1, "789", "789 -1", ' '));
    TEST_DO(verify<int32_t>(789, -1, "789", "789 -1", ' '));
    TEST_DO(verify<int64_t>(789789789789789l, -1, "789789789789789", "789789789789789 -1", ' '));
//    TEST_DO(verify<uint8_t>(65, -1, "65", "65 255", ' '));
    TEST_DO(verify<uint16_t>(789, -1, "789", "789 65535", ' '));
    TEST_DO(verify<uint32_t>(789, -1, "789", "789 4294967295", ' '));
    TEST_DO(verify<uint64_t>(789789789789789l, -1, "789789789789789", "789789789789789 18446744073709551615", ' '));

    TEST_DO(verifyBothWays<vespalib::string>("7.89", "7.89"));
    TEST_DO(verifyBothWays<std::string>("7.89", "7.89"));
    TEST_DO(verifyBothWays<float>(7.89, "7.89"));
    TEST_DO(verifyBothWays<double>(7.89, "7.89"));
    TEST_DO(verifyBothWays<bool>(true, "1"));
    TEST_DO(verifyBothWays<bool>(false, "0"));
    TEST_DO(verifyBothWays<char>(65, "A"));
    TEST_DO(verifyBothWays<unsigned char>(65, "A"));
    //TEST_DO(verifyBothWays<int8_t>(7, "7"));
    //TEST_DO(verifyBothWays<uint8_t>(7, "7"));
    TEST_DO(verifyBothWays<int16_t>(7, "7"));
    TEST_DO(verifyBothWays<uint16_t>(7, "7"));
    TEST_DO(verifyBothWays<int32_t>(7, "7"));
    TEST_DO(verifyBothWays<uint32_t>(7, "7"));
    TEST_DO(verifyBothWays<int64_t>(7, "7"));
    TEST_DO(verifyBothWays<uint64_t>(7, "7"));

    testCopyConstruct();
    testIntegerManip();
    testFill();
    testString();
    testCreateFromFile();
    testWriteThenRead();
    testGetLine();
    testIllegalNumbers();
    testDouble();
    TEST_DONE();
}

TEST_APPHOOK(AsciistreamTest)