#include <cstdint>
#include <limits>
#include <random>
#include <stdexcept>
#include <sstream>
#include <string>
#include <vector>

#define BOOST_TEST_MAIN  1
#include <boost/test/unit_test.hpp>

#include "fixed.h"

// Helper macros
#define VALUE_CHECK(val)                    \
    output.str("");                         \
    output << value;                        \
    BOOST_CHECK(output.str() == val);

#define PARSE_VALUE_CHECK(val)              \
    value.parse(input);                     \
    output.str("");                         \
    output << value;                        \
    BOOST_CHECK(output.str() == val);


#define PARSE_EXCEPTION_CHECK               \
    exception = false;                      \
    try                                     \
    {                                       \
        value.parse(input);                 \
    }                                       \
    catch (const std::out_of_range& exp)    \
    {                                       \
        exception = true;                   \
    }                                       \
    BOOST_CHECK(exception);

BOOST_AUTO_TEST_CASE(t000)
{
    /* TEST CASE 0: Check storage sizes (in bytes) of all predefined fixed 
     * point types.
     */
    fixed_8_8  f_8_8;
    fixed_8_32 f_8_32;
    fixed_8_16 f_8_16;
    fixed_8_64 f_8_64;
    BOOST_CHECK(sizeof(f_8_8)  == 2);
    BOOST_CHECK(sizeof(f_8_16) == 4);
    BOOST_CHECK(sizeof(f_8_32) == 8);
    BOOST_CHECK(sizeof(f_8_64) == 16);
    
    fixed_16_8  f_16_8;
    fixed_16_16 f_16_16;
    fixed_16_32 f_16_32;
    fixed_16_64 f_16_64;
    BOOST_CHECK(sizeof(f_16_8)  == 4);
    BOOST_CHECK(sizeof(f_16_16) == 4);
    BOOST_CHECK(sizeof(f_16_32) == 8);
    BOOST_CHECK(sizeof(f_16_64) == 16);
    
    fixed_32_8  f_32_8;
    fixed_32_16 f_32_16;
    fixed_32_32 f_32_32;
    fixed_32_64 f_32_64;
    BOOST_CHECK(sizeof(f_32_8)  == 8);
    BOOST_CHECK(sizeof(f_32_16) == 8);
    BOOST_CHECK(sizeof(f_32_32) == 8);
    BOOST_CHECK(sizeof(f_32_64) == 16);
    
    fixed_64_8  f_64_8;
    fixed_64_16 f_64_16;
    fixed_64_32 f_64_32;
    fixed_64_64 f_64_64;
    BOOST_CHECK(sizeof(f_64_8)  == 16);
    BOOST_CHECK(sizeof(f_64_16) == 16);
    BOOST_CHECK(sizeof(f_64_32) == 16);
    BOOST_CHECK(sizeof(f_64_64) == 16);
}

BOOST_AUTO_TEST_CASE(t001)
{
    /* TEST CASE 1: Test basic comparisons
     */ 
    fixed_64_64 val1(100, 1, 0);
    fixed_64_64 val2(100, 1);
    
    BOOST_CHECK(  (val1 == val2));
    BOOST_CHECK(! (val1 != val2));
    BOOST_CHECK(! (val1 > val2));
    BOOST_CHECK(! (val1 < val2));
    BOOST_CHECK(  (val1 >= val2));
    BOOST_CHECK(  (val1 <= val2));
    
    val2.assignUnscaledFrac(100, 1, 18);
    
    BOOST_CHECK(! (val1 == val2));
    BOOST_CHECK(  (val1 != val2));
    BOOST_CHECK(  (val1 > val2));
    BOOST_CHECK(! (val1 < val2));
    BOOST_CHECK(  (val1 >= val2));
    BOOST_CHECK(! (val1 <= val2));
}

BOOST_AUTO_TEST_CASE(t002)
{
    /* TEST CASE 2: Test parsing with leading zeros.
     */ 
    fixed_64_64 val1;
    fixed_64_64 val2;

    // 1
    val1.assign(1, 2000000000000000000);
    val2.parse("1.2");
    BOOST_CHECK(val1 == val2);

    // 2
    val1.assign(1, 200000000000000000);
    val2.parse("1.02");
    BOOST_CHECK(val1 == val2);

    // 3
    val1.assign(1, 20000000000000000);
    val2.parse("1.002");
    BOOST_CHECK(val1 == val2);

    // 4
    val1.assign(1, 2000000000000000);
    val2.parse("1.0002");
    BOOST_CHECK(val1 == val2);

    // 5
    val1.assign(1, 200000000000000);
    val2.parse("1.00002");
    BOOST_CHECK(val1 == val2);

    // 6
    val1.assign(1, 20000000000000);
    val2.parse("1.000002");
    BOOST_CHECK(val1 == val2);

    // 7
    val1.assign(1, 2000000000000);
    val2.parse("1.0000002");
    BOOST_CHECK(val1 == val2);

    // 8
    val1.assign(1, 200000000000);
    val2.parse("1.00000002");
    BOOST_CHECK(val1 == val2);

    // 9
    val1.assign(1, 20000000000);
    val2.parse("1.000000002");
    BOOST_CHECK(val1 == val2);

    // 10
    val1.assign(1, 2000000000);
    val2.parse("1.0000000002");
    BOOST_CHECK(val1 == val2);

    // 11
    val1.assign(1, 200000000);
    val2.parse("1.00000000002");
    BOOST_CHECK(val1 == val2);

    // 12
    val1.assign(1, 20000000);
    val2.parse("1.000000000002");
    BOOST_CHECK(val1 == val2);

    // 13
    val1.assign(1, 2000000);
    val2.parse("1.0000000000002");
    BOOST_CHECK(val1 == val2);

    // 14
    val1.assign(1, 200000);
    val2.parse("1.00000000000002");
    BOOST_CHECK(val1 == val2);

    // 15
    val1.assign(1, 20000);
    val2.parse("1.000000000000002");
    BOOST_CHECK(val1 == val2);

    // 16
    val1.assign(1, 2000);
    val2.parse("1.0000000000000002");
    BOOST_CHECK(val1 == val2);

    // 17
    val1.assign(1, 200);
    val2.parse("1.00000000000000002");
    BOOST_CHECK(val1 == val2);

    // 18
    val1.assign(1, 20);
    val2.parse("1.000000000000000002");
    BOOST_CHECK(val1 == val2);

    // 19
    val1.assign(1, 2);
    val2.parse("1.0000000000000000002");
    BOOST_CHECK(val1 == val2);
}

BOOST_AUTO_TEST_CASE(t003)
{
    /* TEST CASE 3: Test parsing and printing randomly generated values
     */ 
    using theType = fixed_64_64;

    uint32_t NUMBER = 1000000;
    uint64_t SEED = 0xDEADBEEF123;
    
    std::random_device dev;
    std::mt19937 rng;
    rng.seed(SEED);
    
    std::uniform_int_distribution<std::mt19937::result_type> negative(0, 1);
    std::uniform_int_distribution<std::mt19937::result_type> intDigits(1, theType::integer_decimal_digits);
    std::uniform_int_distribution<std::mt19937::result_type> fracDigits(1, theType::fractional_decimal_digits);
    std::uniform_int_distribution<std::mt19937::result_type> digits(0, 9);
    
    // Generate NUMBER worth of parsable decimal number strings
    std::vector<std::string> values;
    for (uint32_t idx = 0; idx < NUMBER; ++idx)
    {
        std::ostringstream output;
        
        // Decide if the number should be negative
        if (negative(rng) == 1)
        {
            output << "-";
        }
        
        // Generate random integer number digits
        for (uint32_t integerIdx = 0; integerIdx < intDigits(rng); ++integerIdx)
        {
            int digit = digits(rng);
            
            // Integer part cannot start with a zero
            if (integerIdx == 0)
            {
                while (digit == 0)
                {
                    digit = digits(rng);
                }
            }
            
            output << digit;
        }
        
        output << ".";
        
        // Generate random fractional number digits
        uint32_t numFracDigits = fracDigits(rng);
        for (uint32_t fracIdx = 0; fracIdx < numFracDigits; ++fracIdx)
        {
            int digit = digits(rng);
            
            // Fractional part cannot end with a zero
            if (fracIdx == (numFracDigits - 1))
            {
                while (digit == 0)
                {
                    digit = digits(rng);
                }
            }
            
            output << digit;
        }
        
        values.emplace_back(output.str());
        //~ std::cout << "VAL: " << values.back() << std::endl;
    }
    
    // Now validate that the output of the parsed 
    theType fixedValue;
    std::ostringstream output;
    for (auto& value : values)
    {
        fixedValue.parse(value.c_str());
        output << fixedValue;
        
        //~ std::cout << "TEST: " << output.str() << " -- " << value << std::endl;
        BOOST_CHECK(output.str() == value);
        output.str("");
    }
}

BOOST_AUTO_TEST_CASE(t004)
{
    /* TEST CASE 4: Basic test division by unsigned integer
     */ 
    fixed_64_64 val1(18, 55, 0);
    fixed_64_64 val2(0, 1855, 0);
    
    fixed_64_64 answer = val1 / 100;
    BOOST_CHECK(answer == val2);
}

BOOST_AUTO_TEST_CASE(t005)
{
    /* TEST CASE 5: Test parsing a decimal number with a larger than supported
     * fractional part.
     */ 
     
    const char* input = ".00010102030508132134";

    fixed_64_64 value;
#if 0
    value.parse(input);
    
    std::ostringstream output;
    output << value;
    
    BOOST_CHECK(output.str() == "0.0001010203050813213");
#else
    bool exception = false;
    try
    {
        value.parse(input);
    }
    catch (const std::out_of_range& exp)
    {
        exception = true;
    }
    BOOST_CHECK(exception);
#endif
}

BOOST_AUTO_TEST_CASE(t006)
{
    /* TEST CASE 6: zero integer, positive exponent, walking one positive test 
     * cases
     */ 
    fixed_64_64 value;
    std::ostringstream output;
     
    const char* input = "0.0000000000000000001e36";
    PARSE_VALUE_CHECK("100000000000000000.0");
    
    input = "0.0000000000000000001e35";
    PARSE_VALUE_CHECK("10000000000000000.0");
    
    input = "0.0000000000000000001e34";
    PARSE_VALUE_CHECK("1000000000000000.0");
    
    input = "0.0000000000000000001e33";
    PARSE_VALUE_CHECK("100000000000000.0");
    
    input = "0.0000000000000000001e32";
    PARSE_VALUE_CHECK("10000000000000.0");
    
    input = "0.0000000000000000001e31";
    PARSE_VALUE_CHECK("1000000000000.0");
    
    input = "0.0000000000000000001e30";
    PARSE_VALUE_CHECK("100000000000.0");
    
    input = "0.0000000000000000001e29";
    PARSE_VALUE_CHECK("10000000000.0");
    
    input = "0.0000000000000000001e28";
    PARSE_VALUE_CHECK("1000000000.0");
    
    input = "0.0000000000000000001e27";
    PARSE_VALUE_CHECK("100000000.0");
    
    input = "0.0000000000000000001e26";
    PARSE_VALUE_CHECK("10000000.0");
    
    input = "0.0000000000000000001e25";
    PARSE_VALUE_CHECK("1000000.0");
    
    input = "0.0000000000000000001e24";
    PARSE_VALUE_CHECK("100000.0");
    
    input = "0.0000000000000000001e23";
    PARSE_VALUE_CHECK("10000.0");
    
    input = "0.0000000000000000001e22";
    PARSE_VALUE_CHECK("1000.0");
    
    input = "0.0000000000000000001e21";
    PARSE_VALUE_CHECK("100.0");
    
    input = "0.0000000000000000001e20";
    PARSE_VALUE_CHECK("10.0");
    
    input = "0.0000000000000000001e19";
    PARSE_VALUE_CHECK("1.0");
    
    // Cross over
    input = "0.0000000000000000001e18";
    PARSE_VALUE_CHECK("0.1");
    
    input = "0.0000000000000000001e17";
    PARSE_VALUE_CHECK("0.01");
    
    input = "0.0000000000000000001e16";
    PARSE_VALUE_CHECK("0.001");
    
    input = "0.0000000000000000001e15";
    PARSE_VALUE_CHECK("0.0001");
    
    input = "0.0000000000000000001e14";
    PARSE_VALUE_CHECK("0.00001");
    
    input = "0.0000000000000000001e13";
    PARSE_VALUE_CHECK("0.000001");
    
    input = "0.0000000000000000001e12";
    PARSE_VALUE_CHECK("0.0000001");
    
    input = "0.0000000000000000001e11";
    PARSE_VALUE_CHECK("0.00000001");
    
    input = "0.0000000000000000001e10";
    PARSE_VALUE_CHECK("0.000000001");
    
    input = "0.0000000000000000001e9";
    PARSE_VALUE_CHECK("0.0000000001");
    
    input = "0.0000000000000000001e8";
    PARSE_VALUE_CHECK("0.00000000001");
    
    input = "0.0000000000000000001e7";
    PARSE_VALUE_CHECK("0.000000000001");
    
    input = "0.0000000000000000001e6";
    PARSE_VALUE_CHECK("0.0000000000001");
    
    input = "0.0000000000000000001e5";
    PARSE_VALUE_CHECK("0.00000000000001");
    
    input = "0.0000000000000000001e4";
    PARSE_VALUE_CHECK("0.000000000000001");
    
    input = "0.0000000000000000001e3";
    PARSE_VALUE_CHECK("0.0000000000000001");
    
    input = "0.0000000000000000001e2";
    PARSE_VALUE_CHECK("0.00000000000000001");
    
    input = "0.0000000000000000001e1";
    PARSE_VALUE_CHECK("0.000000000000000001");
    
    input = "0.0000000000000000001e0";
    PARSE_VALUE_CHECK("0.0000000000000000001");
}

BOOST_AUTO_TEST_CASE(t007)
{
    /* TEST CASE 7: non-zero integer, positive exponent, walking value 
     * positive+negative test cases
     */ 
    fixed_64_64 value;
    std::ostringstream output;
     
    const char* input = "1.0000000000000000001e1";
    PARSE_VALUE_CHECK("10.000000000000000001");
    
    input = "1.0000000000000000001e2";
    PARSE_VALUE_CHECK("100.00000000000000001");
    
    input = "1.0000000000000000001e3";
    PARSE_VALUE_CHECK("1000.0000000000000001");
    
    input = "1.0000000000000000001e4";
    PARSE_VALUE_CHECK("10000.000000000000001");
    
    input = "1.0000000000000000001e5";
    PARSE_VALUE_CHECK("100000.00000000000001");
    
    input = "1.0000000000000000001e6";
    PARSE_VALUE_CHECK("1000000.0000000000001");
    
    input = "1.0000000000000000001e7";
    PARSE_VALUE_CHECK("10000000.000000000001");
    
    input = "1.0000000000000000001e8";
    PARSE_VALUE_CHECK("100000000.00000000001");
    
    input = "1.0000000000000000001e9";
    PARSE_VALUE_CHECK("1000000000.0000000001");
    
    input = "1.0000000000000000001e10";
    PARSE_VALUE_CHECK("10000000000.000000001");
    
    input = "1.0000000000000000001e11";
    PARSE_VALUE_CHECK("100000000000.00000001");
    
    input = "1.0000000000000000001e12";
    PARSE_VALUE_CHECK("1000000000000.0000001");
    
    input = "1.0000000000000000001e13";
    PARSE_VALUE_CHECK("10000000000000.000001");
    
    input = "1.0000000000000000001e14";
    PARSE_VALUE_CHECK("100000000000000.00001");
    
    input = "1.0000000000000000001e15";
    PARSE_VALUE_CHECK("1000000000000000.0001");
    
    input = "1.0000000000000000001e16";
    PARSE_VALUE_CHECK("10000000000000000.001");
    
    input = "1.0000000000000000001e17";
    PARSE_VALUE_CHECK("100000000000000000.01");
    
    input = "1.0000000000000000001e18";
    bool exception = false;
    PARSE_EXCEPTION_CHECK
}

BOOST_AUTO_TEST_CASE(t008)
{
    /* TEST CASE 8: zero integer, positive exponent, walking one negative test 
     * cases
     */ 
    fixed_64_64 value;
    std::ostringstream output;
     
    const char* input = "0.0000000000000000001e37";
    bool exception = false;
    PARSE_EXCEPTION_CHECK
    
    input = "0.000000000000000001e38";
    PARSE_EXCEPTION_CHECK
    
    input = "0.00000000000000001e37";
    PARSE_EXCEPTION_CHECK
    
    input = "0.0000000000000001e36";
    PARSE_EXCEPTION_CHECK
    
    input = "0.0000000000000001e35";
    PARSE_EXCEPTION_CHECK
    
    input = "0.000000000000001e34";
    PARSE_EXCEPTION_CHECK
    
    input = "0.00000000000001e32";
    PARSE_EXCEPTION_CHECK
    
    input = "0.0000000000001e31";
    PARSE_EXCEPTION_CHECK
    
    input = "0.000000000001e30";
    PARSE_EXCEPTION_CHECK
    
    input = "0.00000000001e29";
    PARSE_EXCEPTION_CHECK
    
    input = "0.0000000001e28";
    PARSE_EXCEPTION_CHECK
    
    input = "0.000000001e27";
    PARSE_EXCEPTION_CHECK
    
    input = "0.00000001e26";
    PARSE_EXCEPTION_CHECK
    
    input = "0.0000001e25";
    PARSE_EXCEPTION_CHECK
    
    input = "0.000001e24";
    PARSE_EXCEPTION_CHECK
    
    input = "0.00001e23";
    PARSE_EXCEPTION_CHECK
    
    input = "0.0001e22";
    PARSE_EXCEPTION_CHECK
    
    input = "0.001e21";
    PARSE_EXCEPTION_CHECK
    
    input = "0.01e20";
    PARSE_EXCEPTION_CHECK
    
    input = "0.1e19";
    PARSE_EXCEPTION_CHECK
    
    // Cross over
    input = "1.0e18";
    PARSE_EXCEPTION_CHECK
    
    input = "10.0e17";
    PARSE_EXCEPTION_CHECK
    
    input = "100.0e16";
    PARSE_EXCEPTION_CHECK
    
    input = "1000.0e15";
    PARSE_EXCEPTION_CHECK
    
    input = "10000.0e14";
    PARSE_EXCEPTION_CHECK
    
    input = "100000.0e13";
    PARSE_EXCEPTION_CHECK
    
    input = "1000000.0e12";
    PARSE_EXCEPTION_CHECK
    
    input = "10000000.0e11";
    PARSE_EXCEPTION_CHECK
    
    input = "100000000.0e10";
    PARSE_EXCEPTION_CHECK
    
    input = "1000000000.0e9";
    PARSE_EXCEPTION_CHECK
    
    input = "10000000000.0e8";
    PARSE_EXCEPTION_CHECK
    
    input = "100000000000.0e7";
    PARSE_EXCEPTION_CHECK
    
    input = "1000000000000.0e6";
    PARSE_EXCEPTION_CHECK
    
    input = "10000000000000.0e5";
    PARSE_EXCEPTION_CHECK
    
    input = "100000000000000.0e4";
    PARSE_EXCEPTION_CHECK
    
    input = "1000000000000000.0e3";
    PARSE_EXCEPTION_CHECK
    
    input = "10000000000000000.0e2";
    PARSE_EXCEPTION_CHECK
    
    input = "100000000000000000.0e1";
    PARSE_EXCEPTION_CHECK
    
    input = "1000000000000000000.0e0";
    PARSE_EXCEPTION_CHECK
}

BOOST_AUTO_TEST_CASE(t009)
{
    /* TEST CASE 9: zero factional, negative exponent, walking one positive test 
     * cases
     */ 
    fixed_64_64 value;
    std::ostringstream output;
     
    const char* input = "100000000000000000.0e-1";
    PARSE_VALUE_CHECK("10000000000000000.0");
    
    input = "100000000000000000.0e-2";
    PARSE_VALUE_CHECK("1000000000000000.0");
    
    input = "100000000000000000.0e-3";
    PARSE_VALUE_CHECK("100000000000000.0");
    
    input = "100000000000000000.0e-4";
    PARSE_VALUE_CHECK("10000000000000.0");
    
    input = "100000000000000000.0e-5";
    PARSE_VALUE_CHECK("1000000000000.0");
    
    input = "100000000000000000.0e-6";
    PARSE_VALUE_CHECK("100000000000.0");
    
    input = "100000000000000000.0e-7";
    PARSE_VALUE_CHECK("10000000000.0");
    
    input = "100000000000000000.0e-8";
    PARSE_VALUE_CHECK("1000000000.0");
    
    input = "100000000000000000.0e-9";
    PARSE_VALUE_CHECK("100000000.0");
    
    input = "100000000000000000.0e-10";
    PARSE_VALUE_CHECK("10000000.0");
    
    input = "100000000000000000.0e-11";
    PARSE_VALUE_CHECK("1000000.0");
    
    input = "100000000000000000.0e-12";
    PARSE_VALUE_CHECK("100000.0");
    
    input = "100000000000000000.0e-13";
    PARSE_VALUE_CHECK("10000.0");
    
    input = "100000000000000000.0e-14";
    PARSE_VALUE_CHECK("1000.0");
    
    input = "100000000000000000.0e-15";
    PARSE_VALUE_CHECK("100.0");
    
    input = "100000000000000000.0e-16";
    PARSE_VALUE_CHECK("10.0");
    
    input = "100000000000000000.0e-17";
    PARSE_VALUE_CHECK("1.0");
    
    // Cross over
    input = "100000000000000000.0e-18";
    PARSE_VALUE_CHECK("0.1");
    
    input = "100000000000000000.0e-19";
    PARSE_VALUE_CHECK("0.01");
    
    input = "100000000000000000.0e-20";
    PARSE_VALUE_CHECK("0.001");
    
    input = "100000000000000000.0e-21";
    PARSE_VALUE_CHECK("0.0001");
    
    input = "100000000000000000.0e-22";
    PARSE_VALUE_CHECK("0.00001");
    
    input = "100000000000000000.0e-23";
    PARSE_VALUE_CHECK("0.000001");
    
    input = "100000000000000000.0e-24";
    PARSE_VALUE_CHECK("0.0000001");
    
    input = "100000000000000000.0e-25";
    PARSE_VALUE_CHECK("0.00000001");
    
    input = "100000000000000000.0e-26";
    PARSE_VALUE_CHECK("0.000000001");
    
    input = "100000000000000000.0e-27";
    PARSE_VALUE_CHECK("0.0000000001");
    
    input = "100000000000000000.0e-28";
    PARSE_VALUE_CHECK("0.00000000001");
    
    input = "100000000000000000.0e-29";
    PARSE_VALUE_CHECK("0.000000000001");
    
    input = "100000000000000000.0e-30";
    PARSE_VALUE_CHECK("0.0000000000001");
    
    input = "100000000000000000.0e-31";
    PARSE_VALUE_CHECK("0.00000000000001");
    
    input = "100000000000000000.0e-32";
    PARSE_VALUE_CHECK("0.000000000000001");
    
    input = "100000000000000000.0e-33";
    PARSE_VALUE_CHECK("0.0000000000000001");
    
    input = "100000000000000000.0e-34";
    PARSE_VALUE_CHECK("0.00000000000000001");
    
    input = "100000000000000000.0e-35";
    PARSE_VALUE_CHECK("0.000000000000000001");
    
    input = "100000000000000000.0e-36";
    PARSE_VALUE_CHECK("0.0000000000000000001");
}

BOOST_AUTO_TEST_CASE(t010)
{
    /* TEST CASE 10: non-zero factional, negative exponent, walking value 
     * positive+negative test cases
     */ 
    fixed_64_64 value;
    std::ostringstream output;
     
    const char* input = "100000000000000000.1e-1";
    PARSE_VALUE_CHECK("10000000000000000.01");
    
    input = "100000000000000000.1e-2";
    PARSE_VALUE_CHECK("1000000000000000.001");
    
    input = "100000000000000000.1e-3";
    PARSE_VALUE_CHECK("100000000000000.0001");
    
    input = "100000000000000000.1e-4";
    PARSE_VALUE_CHECK("10000000000000.00001");
    
    input = "100000000000000000.1e-5";
    PARSE_VALUE_CHECK("1000000000000.000001");
    
    input = "100000000000000000.1e-6";
    PARSE_VALUE_CHECK("100000000000.0000001");
    
    input = "100000000000000000.1e-7";
    PARSE_VALUE_CHECK("10000000000.00000001");
    
    input = "100000000000000000.1e-8";
    PARSE_VALUE_CHECK("1000000000.000000001");
    
    input = "100000000000000000.1e-9";
    PARSE_VALUE_CHECK("100000000.0000000001");
    
    input = "100000000000000000.1e-10";
    PARSE_VALUE_CHECK("10000000.00000000001");
    
    input = "100000000000000000.1e-11";
    PARSE_VALUE_CHECK("1000000.000000000001");
    
    input = "100000000000000000.1e-12";
    PARSE_VALUE_CHECK("100000.0000000000001");
    
    input = "100000000000000000.1e-13";
    PARSE_VALUE_CHECK("10000.00000000000001");
    
    input = "100000000000000000.1e-14";
    PARSE_VALUE_CHECK("1000.000000000000001");
    
    input = "100000000000000000.1e-15";
    PARSE_VALUE_CHECK("100.0000000000000001");
    
    input = "100000000000000000.1e-16";
    PARSE_VALUE_CHECK("10.00000000000000001");
    
    input = "100000000000000000.1e-17";
    PARSE_VALUE_CHECK("1.000000000000000001");
    
    input = "100000000000000000.1e-18";
    PARSE_VALUE_CHECK("0.1000000000000000001");
    
    input = "100000000000000000.1e-19";
    bool exception = false;
    PARSE_EXCEPTION_CHECK
}

BOOST_AUTO_TEST_CASE(t011)
{
    /* TEST CASE 11: zero factional, negative exponent, walking one negative test 
     * cases
     */ 
    fixed_64_64 value;
    std::ostringstream output;
     
    const char* input = "100000000000000000.0e-37";
    bool exception = false;
    PARSE_EXCEPTION_CHECK
    
    input = "10000000000000000.0e-36";
    PARSE_EXCEPTION_CHECK
    
    input = "1000000000000000.0e-35";
    PARSE_EXCEPTION_CHECK
    
    input = "100000000000000.0e-34";
    PARSE_EXCEPTION_CHECK
    
    input = "10000000000000.0e-33";
    PARSE_EXCEPTION_CHECK
    
    input = "1000000000000.0e-32";
    PARSE_EXCEPTION_CHECK
    
    input = "100000000000.0e-31";
    PARSE_EXCEPTION_CHECK
    
    input = "10000000000.0e-30";
    PARSE_EXCEPTION_CHECK
    
    input = "1000000000.0e-29";
    PARSE_EXCEPTION_CHECK
    
    input = "100000000.0e-28";
    PARSE_EXCEPTION_CHECK
    
    input = "10000000.0e-27";
    PARSE_EXCEPTION_CHECK
    
    input = "1000000.0e-26";
    PARSE_EXCEPTION_CHECK
    
    input = "100000.0e-25";
    PARSE_EXCEPTION_CHECK
    
    input = "10000.0e-24";
    PARSE_EXCEPTION_CHECK
    
    input = "1000.0e-23";
    PARSE_EXCEPTION_CHECK
    
    input = "100.0e-22";
    PARSE_EXCEPTION_CHECK
    
    input = "10.0e-21";
    PARSE_EXCEPTION_CHECK
    
    input = "1.0e-20";
    PARSE_EXCEPTION_CHECK
    
    // Cross over
    input = "0.1e-19";
    PARSE_EXCEPTION_CHECK
    
    input = "0.01e-18";
    PARSE_EXCEPTION_CHECK
    
    input = "0.001e-17";
    PARSE_EXCEPTION_CHECK
    
    input = "0.0001e-16";
    PARSE_EXCEPTION_CHECK
    
    input = "0.00001e-15";
    PARSE_EXCEPTION_CHECK
    
    input = "0.000001e-14";
    PARSE_EXCEPTION_CHECK
    
    input = "0.0000001e-13";
    PARSE_EXCEPTION_CHECK
    
    input = "0.00000001e-12";
    PARSE_EXCEPTION_CHECK
    
    input = "0.000000001e-11";
    PARSE_EXCEPTION_CHECK
    
    input = "0.0000000001e-10";
    PARSE_EXCEPTION_CHECK
    
    input = "0.00000000001e-9";
    PARSE_EXCEPTION_CHECK
    
    input = "0.000000000001e-8";
    PARSE_EXCEPTION_CHECK
    
    input = "0.0000000000001e-7";
    PARSE_EXCEPTION_CHECK
    
    input = "0.00000000000001e-6";
    PARSE_EXCEPTION_CHECK
    
    input = "0.000000000000001e-5";
    PARSE_EXCEPTION_CHECK
    
    input = "0.0000000000000001e-4";
    PARSE_EXCEPTION_CHECK
    
    input = "0.00000000000000001e-3";
    PARSE_EXCEPTION_CHECK
    
    input = "0.000000000000000001e-2";
    PARSE_EXCEPTION_CHECK
    
    input = "0.0000000000000000001e-1";
    PARSE_EXCEPTION_CHECK
}

BOOST_AUTO_TEST_CASE(t012)
{
    /* TEST CASE 12: non-zero negative integer, positive exponent, walking value 
     * positive+negative test cases
     */ 
    fixed_64_64 value;
    std::ostringstream output;
     
    const char* input = "-1.0000000000000000001e1";
    PARSE_VALUE_CHECK("-10.000000000000000001");
    
    input = "-1.0000000000000000001e2";
    PARSE_VALUE_CHECK("-100.00000000000000001");
    
    input = "-1.0000000000000000001e3";
    PARSE_VALUE_CHECK("-1000.0000000000000001");
    
    input = "-1.0000000000000000001e4";
    PARSE_VALUE_CHECK("-10000.000000000000001");
    
    input = "-1.0000000000000000001e5";
    PARSE_VALUE_CHECK("-100000.00000000000001");
    
    input = "-1.0000000000000000001e6";
    PARSE_VALUE_CHECK("-1000000.0000000000001");
    
    input = "-1.0000000000000000001e7";
    PARSE_VALUE_CHECK("-10000000.000000000001");
    
    input = "-1.0000000000000000001e8";
    PARSE_VALUE_CHECK("-100000000.00000000001");
    
    input = "-1.0000000000000000001e9";
    PARSE_VALUE_CHECK("-1000000000.0000000001");
    
    input = "-1.0000000000000000001e10";
    PARSE_VALUE_CHECK("-10000000000.000000001");
    
    input = "-1.0000000000000000001e11";
    PARSE_VALUE_CHECK("-100000000000.00000001");
    
    input = "-1.0000000000000000001e12";
    PARSE_VALUE_CHECK("-1000000000000.0000001");
    
    input = "-1.0000000000000000001e13";
    PARSE_VALUE_CHECK("-10000000000000.000001");
    
    input = "-1.0000000000000000001e14";
    PARSE_VALUE_CHECK("-100000000000000.00001");
    
    input = "-1.0000000000000000001e15";
    PARSE_VALUE_CHECK("-1000000000000000.0001");
    
    input = "-1.0000000000000000001e16";
    PARSE_VALUE_CHECK("-10000000000000000.001");
    
    input = "-1.0000000000000000001e17";
    PARSE_VALUE_CHECK("-100000000000000000.01");
    
    input = "-1.0000000000000000001e18";
    bool exception = false;
    PARSE_EXCEPTION_CHECK
}

BOOST_AUTO_TEST_CASE(t013)
{
    /* TEST CASE 13: non-zero negative factional, negative exponent, walking
     * value positive+negative test cases
     */ 
    fixed_64_64 value;
    std::ostringstream output;
     
    const char* input = "-100000000000000000.1e-1";
    PARSE_VALUE_CHECK("-10000000000000000.01");
    
    input = "-100000000000000000.1e-2";
    PARSE_VALUE_CHECK("-1000000000000000.001");
    
    input = "-100000000000000000.1e-3";
    PARSE_VALUE_CHECK("-100000000000000.0001");
    
    input = "-100000000000000000.1e-4";
    PARSE_VALUE_CHECK("-10000000000000.00001");
    
    input = "-100000000000000000.1e-5";
    PARSE_VALUE_CHECK("-1000000000000.000001");
    
    input = "-100000000000000000.1e-6";
    PARSE_VALUE_CHECK("-100000000000.0000001");
    
    input = "-100000000000000000.1e-7";
    PARSE_VALUE_CHECK("-10000000000.00000001");
    
    input = "-100000000000000000.1e-8";
    PARSE_VALUE_CHECK("-1000000000.000000001");
    
    input = "-100000000000000000.1e-9";
    PARSE_VALUE_CHECK("-100000000.0000000001");
    
    input = "-100000000000000000.1e-10";
    PARSE_VALUE_CHECK("-10000000.00000000001");
    
    input = "-100000000000000000.1e-11";
    PARSE_VALUE_CHECK("-1000000.000000000001");
    
    input = "-100000000000000000.1e-12";
    PARSE_VALUE_CHECK("-100000.0000000000001");
    
    input = "-100000000000000000.1e-13";
    PARSE_VALUE_CHECK("-10000.00000000000001");
    
    input = "-100000000000000000.1e-14";
    PARSE_VALUE_CHECK("-1000.000000000000001");
    
    input = "-100000000000000000.1e-15";
    PARSE_VALUE_CHECK("-100.0000000000000001");
    
    input = "-100000000000000000.1e-16";
    PARSE_VALUE_CHECK("-10.00000000000000001");
    
    input = "-100000000000000000.1e-17";
    PARSE_VALUE_CHECK("-1.000000000000000001");
    
    input = "-100000000000000000.1e-18";
    PARSE_VALUE_CHECK("-0.1000000000000000001");
    
    input = "-100000000000000000.1e-19";
    bool exception = false;
    PARSE_EXCEPTION_CHECK
}

BOOST_AUTO_TEST_CASE(t014)
{
    /* TEST CASE 14: LEADING_ZERO=true; negative zero parse
     */ 
     
    fixed_64_64 value;
    std::ostringstream output;
     
    const char* input = "-0.9";
    PARSE_VALUE_CHECK("-0.9");
    
    input = "-0.99";
    PARSE_VALUE_CHECK("-0.99");

    input = "-0.999";
    PARSE_VALUE_CHECK("-0.999");

    input = "-0.9999";
    PARSE_VALUE_CHECK("-0.9999");

    input = "-0.99999";
    PARSE_VALUE_CHECK("-0.99999");

    input = "-0.999999";
    PARSE_VALUE_CHECK("-0.999999");

    input = "-0.9999999";
    PARSE_VALUE_CHECK("-0.9999999");

    input = "-0.99999999";
    PARSE_VALUE_CHECK("-0.99999999");

    input = "-0.999999999";
    PARSE_VALUE_CHECK("-0.999999999");

    input = "-0.9999999999";
    PARSE_VALUE_CHECK("-0.9999999999");

    input = "-0.99999999999";
    PARSE_VALUE_CHECK("-0.99999999999");

    input = "-0.999999999999";
    PARSE_VALUE_CHECK("-0.999999999999");

    input = "-0.9999999999999";
    PARSE_VALUE_CHECK("-0.9999999999999");

    input = "-0.99999999999999";
    PARSE_VALUE_CHECK("-0.99999999999999");

    input = "-0.999999999999999";
    PARSE_VALUE_CHECK("-0.999999999999999");

    input = "-0.9999999999999999";
    PARSE_VALUE_CHECK("-0.9999999999999999");

    input = "-0.99999999999999999";
    PARSE_VALUE_CHECK("-0.99999999999999999");

    input = "-0.999999999999999999";
    PARSE_VALUE_CHECK("-0.999999999999999999");

    input = "-0.9999999999999999999";
    PARSE_VALUE_CHECK("-0.9999999999999999999");
}

BOOST_AUTO_TEST_CASE(t015)
{
    /* TEST CASE 15: LEADING_ZERO=false; negative zero parse
     */ 
     
    fixed_64_64 value;
    std::ostringstream output;
     
    const char* input = "-.9";
    PARSE_VALUE_CHECK("-0.9");
    
    input = "-.99";
    PARSE_VALUE_CHECK("-0.99");

    input = "-.999";
    PARSE_VALUE_CHECK("-0.999");

    input = "-.9999";
    PARSE_VALUE_CHECK("-0.9999");

    input = "-.99999";
    PARSE_VALUE_CHECK("-0.99999");

    input = "-.999999";
    PARSE_VALUE_CHECK("-0.999999");

    input = "-.9999999";
    PARSE_VALUE_CHECK("-0.9999999");

    input = "-.99999999";
    PARSE_VALUE_CHECK("-0.99999999");

    input = "-.999999999";
    PARSE_VALUE_CHECK("-0.999999999");

    input = "-.9999999999";
    PARSE_VALUE_CHECK("-0.9999999999");

    input = "-.99999999999";
    PARSE_VALUE_CHECK("-0.99999999999");

    input = "-.999999999999";
    PARSE_VALUE_CHECK("-0.999999999999");

    input = "-.9999999999999";
    PARSE_VALUE_CHECK("-0.9999999999999");

    input = "-.99999999999999";
    PARSE_VALUE_CHECK("-0.99999999999999");

    input = "-.999999999999999";
    PARSE_VALUE_CHECK("-0.999999999999999");

    input = "-.9999999999999999";
    PARSE_VALUE_CHECK("-0.9999999999999999");

    input = "-.99999999999999999";
    PARSE_VALUE_CHECK("-0.99999999999999999");

    input = "-.999999999999999999";
    PARSE_VALUE_CHECK("-0.999999999999999999");

    input = "-.9999999999999999999";
    PARSE_VALUE_CHECK("-0.9999999999999999999");
}

BOOST_AUTO_TEST_CASE(t016)
{
    /* TEST CASE 16: negative zero comparison
     */ 
    fixed_64_64 val1;
    val1.parse("-0.9");
    
    fixed_64_64 val2;
    val2.parse("-0.9");
    
    //             -0.9 OP -0.9
    BOOST_CHECK(  (val1 == val2));
    BOOST_CHECK(! (val1 != val2));
    BOOST_CHECK(! (val1 > val2));
    BOOST_CHECK(! (val1 < val2));
    BOOST_CHECK(  (val1 >= val2));
    BOOST_CHECK(  (val1 <= val2));
    
    // 0.9
    val2.assignUnscaledFrac(0, 9, 0);
    
    //             -0.9 OP 0.9
    BOOST_CHECK(! (val1 == val2));
    BOOST_CHECK(  (val1 != val2));
    BOOST_CHECK(! (val1 > val2));
    BOOST_CHECK(  (val1 < val2));
    BOOST_CHECK(! (val1 >= val2));
    BOOST_CHECK(  (val1 <= val2));
}

BOOST_AUTO_TEST_CASE(t017)
{
    /* TEST CASE 17: positive divide by positive integer
     */ 
     
    fixed_64_64 value;
    std::ostringstream output;
     
    const char* input = "900000000000000000.0";
    value.parse(input);
    value = value / 1;
    VALUE_CHECK("900000000000000000.0");
    
    value = value / 10;
    VALUE_CHECK("90000000000000000.0");
    
    value = value / 10;
    VALUE_CHECK("9000000000000000.0");

    value = value / 10;
    VALUE_CHECK("900000000000000.0");

    value = value / 10;
    VALUE_CHECK("90000000000000.0");

    value = value / 10;
    VALUE_CHECK("9000000000000.0");

    value = value / 10;
    VALUE_CHECK("900000000000.0");

    value = value / 10;
    VALUE_CHECK("90000000000.0");

    value = value / 10;
    VALUE_CHECK("9000000000.0");

    value = value / 10;
    VALUE_CHECK("900000000.0");

    value = value / 10;
    VALUE_CHECK("90000000.0");

    value = value / 10;
    VALUE_CHECK("9000000.0");

    value = value / 10;
    VALUE_CHECK("900000.0");

    value = value / 10;
    VALUE_CHECK("90000.0");

    value = value / 10;
    VALUE_CHECK("9000.0");

    value = value / 10;
    VALUE_CHECK("900.0");

    value = value / 10;
    VALUE_CHECK("90.0");

    value = value / 10;
    VALUE_CHECK("9.0");

    // Cross over
    value = value / 10;
    VALUE_CHECK("0.9");

    value = value / 10;
    VALUE_CHECK("0.09");

    value = value / 10;
    VALUE_CHECK("0.009");

    value = value / 10;
    VALUE_CHECK("0.0009");

    value = value / 10;
    VALUE_CHECK("0.00009");

    value = value / 10;
    VALUE_CHECK("0.000009");

    value = value / 10;
    VALUE_CHECK("0.0000009");

    value = value / 10;
    VALUE_CHECK("0.00000009");

    value = value / 10;
    VALUE_CHECK("0.000000009");

    value = value / 10;
    VALUE_CHECK("0.0000000009");

    value = value / 10;
    VALUE_CHECK("0.00000000009");

    value = value / 10;
    VALUE_CHECK("0.000000000009");

    value = value / 10;
    VALUE_CHECK("0.0000000000009");

    value = value / 10;
    VALUE_CHECK("0.00000000000009");

    value = value / 10;
    VALUE_CHECK("0.000000000000009");

    value = value / 10;
    VALUE_CHECK("0.0000000000000009");

    value = value / 10;
    VALUE_CHECK("0.00000000000000009");

    value = value / 10;
    VALUE_CHECK("0.000000000000000009");

    value = value / 10;
    VALUE_CHECK("0.0000000000000000009");
}

BOOST_AUTO_TEST_CASE(t018)
{
    /* TEST CASE 18: negative divide by positive integer
     */ 
     
    fixed_64_64 value;
    std::ostringstream output;
     
    const char* input = "-900000000000000000.0";
    value.parse(input);
    
    value = value / 1;
    VALUE_CHECK("-900000000000000000.0");
    
    value = value / 10;
    VALUE_CHECK("-90000000000000000.0");

    value = value / 10;
    VALUE_CHECK("-9000000000000000.0");

    value = value / 10;
    VALUE_CHECK("-900000000000000.0");

    value = value / 10;
    VALUE_CHECK("-90000000000000.0");

    value = value / 10;
    VALUE_CHECK("-9000000000000.0");

    value = value / 10;
    VALUE_CHECK("-900000000000.0");

    value = value / 10;
    VALUE_CHECK("-90000000000.0");

    value = value / 10;
    VALUE_CHECK("-9000000000.0");

    value = value / 10;
    VALUE_CHECK("-900000000.0");

    value = value / 10;
    VALUE_CHECK("-90000000.0");

    value = value / 10;
    VALUE_CHECK("-9000000.0");

    value = value / 10;
    VALUE_CHECK("-900000.0");

    value = value / 10;
    VALUE_CHECK("-90000.0");

    value = value / 10;
    VALUE_CHECK("-9000.0");

    value = value / 10;
    VALUE_CHECK("-900.0");

    value = value / 10;
    VALUE_CHECK("-90.0");

    value = value / 10;
    VALUE_CHECK("-9.0");
    
    // Cross over
    value = value / 10;
    VALUE_CHECK("-0.9");

    value = value / 10;
    VALUE_CHECK("-0.09");

    value = value / 10;
    VALUE_CHECK("-0.009");

    value = value / 10;
    VALUE_CHECK("-0.0009");

    value = value / 10;
    VALUE_CHECK("-0.00009");

    value = value / 10;
    VALUE_CHECK("-0.000009");

    value = value / 10;
    VALUE_CHECK("-0.0000009");

    value = value / 10;
    VALUE_CHECK("-0.00000009");

    value = value / 10;
    VALUE_CHECK("-0.000000009");

    value = value / 10;
    VALUE_CHECK("-0.0000000009");

    value = value / 10;
    VALUE_CHECK("-0.00000000009");

    value = value / 10;
    VALUE_CHECK("-0.000000000009");

    value = value / 10;
    VALUE_CHECK("-0.0000000000009");

    value = value / 10;
    VALUE_CHECK("-0.00000000000009");

    value = value / 10;
    VALUE_CHECK("-0.000000000000009");

    value = value / 10;
    VALUE_CHECK("-0.0000000000000009");

    value = value / 10;
    VALUE_CHECK("-0.00000000000000009");

    value = value / 10;
    VALUE_CHECK("-0.000000000000000009");

    value = value / 10;
    VALUE_CHECK("-0.0000000000000000009");
}

BOOST_AUTO_TEST_CASE(t019)
{
    /* TEST CASE 19: positive divide by negative integer
     */ 
     
    fixed_64_64 value;
    std::ostringstream output;
     
    const char* input = "900000000000000000.0";
    value.parse(input);
    value = value / -1;
    VALUE_CHECK("-900000000000000000.0");
    
    value.absval();
    value = value / -10;
    VALUE_CHECK("-90000000000000000.0");
    
    value.absval();
    value = value / -10;
    VALUE_CHECK("-9000000000000000.0");

    value.absval();
    value = value / -10;
    VALUE_CHECK("-900000000000000.0");

    value.absval();
    value = value / -10;
    VALUE_CHECK("-90000000000000.0");

    value.absval();
    value = value / -10;
    VALUE_CHECK("-9000000000000.0");

    value.absval();
    value = value / -10;
    VALUE_CHECK("-900000000000.0");

    value.absval();
    value = value / -10;
    VALUE_CHECK("-90000000000.0");

    value.absval();
    value = value / -10;
    VALUE_CHECK("-9000000000.0");

    value.absval();
    value = value / -10;
    VALUE_CHECK("-900000000.0");

    value.absval();
    value = value / -10;
    VALUE_CHECK("-90000000.0");

    value.absval();
    value = value / -10;
    VALUE_CHECK("-9000000.0");

    value.absval();
    value = value / -10;
    VALUE_CHECK("-900000.0");

    value.absval();
    value = value / -10;
    VALUE_CHECK("-90000.0");

    value.absval();
    value = value / -10;
    VALUE_CHECK("-9000.0");

    value.absval();
    value = value / -10;
    VALUE_CHECK("-900.0");

    value.absval();
    value = value / -10;
    VALUE_CHECK("-90.0");

    value.absval();
    value = value / -10;
    VALUE_CHECK("-9.0");

    // Cross over
    value.absval();
    value = value / -10;
    VALUE_CHECK("-0.9");

    value.absval();
    value = value / -10;
    VALUE_CHECK("-0.09");

    value.absval();
    value = value / -10;
    VALUE_CHECK("-0.009");

    value.absval();
    value = value / -10;
    VALUE_CHECK("-0.0009");

    value.absval();
    value = value / -10;
    VALUE_CHECK("-0.00009");

    value.absval();
    value = value / -10;
    VALUE_CHECK("-0.000009");

    value.absval();
    value = value / -10;
    VALUE_CHECK("-0.0000009");

    value.absval();
    value = value / -10;
    VALUE_CHECK("-0.00000009");

    value.absval();
    value = value / -10;
    VALUE_CHECK("-0.000000009");

    value.absval();
    value = value / -10;
    VALUE_CHECK("-0.0000000009");

    value.absval();
    value = value / -10;
    VALUE_CHECK("-0.00000000009");

    value.absval();
    value = value / -10;
    VALUE_CHECK("-0.000000000009");

    value.absval();
    value = value / -10;
    VALUE_CHECK("-0.0000000000009");

    value.absval();
    value = value / -10;
    VALUE_CHECK("-0.00000000000009");

    value.absval();
    value = value / -10;
    VALUE_CHECK("-0.000000000000009");

    value.absval();
    value = value / -10;
    VALUE_CHECK("-0.0000000000000009");

    value.absval();
    value = value / -10;
    VALUE_CHECK("-0.00000000000000009");

    value.absval();
    value = value / -10;
    VALUE_CHECK("-0.000000000000000009");

    value.absval();
    value = value / -10;
    VALUE_CHECK("-0.0000000000000000009");
}

BOOST_AUTO_TEST_CASE(t020)
{
    /* TEST CASE 20: hegative divide by negative integer
     */ 
     
    fixed_64_64 value;
    std::ostringstream output;
     
    const char* input = "-900000000000000000.0";
    value.parse(input);
    value = value / -1;
    VALUE_CHECK("900000000000000000.0");
    
    value.negate();
    value = value / -10;
    VALUE_CHECK("90000000000000000.0");
    
    value.negate();
    value = value / -10;
    VALUE_CHECK("9000000000000000.0");

    value.negate();
    value = value / -10;
    VALUE_CHECK("900000000000000.0");

    value.negate();
    value = value / -10;
    VALUE_CHECK("90000000000000.0");

    value.negate();
    value = value / -10;
    VALUE_CHECK("9000000000000.0");

    value.negate();
    value = value / -10;
    VALUE_CHECK("900000000000.0");

    value.negate();
    value = value / -10;
    VALUE_CHECK("90000000000.0");

    value.negate();
    value = value / -10;
    VALUE_CHECK("9000000000.0");

    value.negate();
    value = value / -10;
    VALUE_CHECK("900000000.0");

    value.negate();
    value = value / -10;
    VALUE_CHECK("90000000.0");

    value.negate();
    value = value / -10;
    VALUE_CHECK("9000000.0");

    value.negate();
    value = value / -10;
    VALUE_CHECK("900000.0");

    value.negate();
    value = value / -10;
    VALUE_CHECK("90000.0");

    value.negate();
    value = value / -10;
    VALUE_CHECK("9000.0");

    value.negate();
    value = value / -10;
    VALUE_CHECK("900.0");

    value.negate();
    value = value / -10;
    VALUE_CHECK("90.0");

    value.negate();
    value = value / -10;
    VALUE_CHECK("9.0");

    // Cross over
    value.negate();
    value = value / -10;
    VALUE_CHECK("0.9");

    value.negate();
    value = value / -10;
    VALUE_CHECK("0.09");

    value.negate();
    value = value / -10;
    VALUE_CHECK("0.009");

    value.negate();
    value = value / -10;
    VALUE_CHECK("0.0009");

    value.negate();
    value = value / -10;
    VALUE_CHECK("0.00009");

    value.negate();
    value = value / -10;
    VALUE_CHECK("0.000009");

    value.negate();
    value = value / -10;
    VALUE_CHECK("0.0000009");

    value.negate();
    value = value / -10;
    VALUE_CHECK("0.00000009");

    value.negate();
    value = value / -10;
    VALUE_CHECK("0.000000009");

    value.negate();
    value = value / -10;
    VALUE_CHECK("0.0000000009");

    value.negate();
    value = value / -10;
    VALUE_CHECK("0.00000000009");

    value.negate();
    value = value / -10;
    VALUE_CHECK("0.000000000009");

    value.negate();
    value = value / -10;
    VALUE_CHECK("0.0000000000009");

    value.negate();
    value = value / -10;
    VALUE_CHECK("0.00000000000009");

    value.negate();
    value = value / -10;
    VALUE_CHECK("0.000000000000009");

    value.negate();
    value = value / -10;
    VALUE_CHECK("0.0000000000000009");

    value.negate();
    value = value / -10;
    VALUE_CHECK("0.00000000000000009");

    value.negate();
    value = value / -10;
    VALUE_CHECK("0.000000000000000009");

    value.negate();
    value = value / -10;
    VALUE_CHECK("0.0000000000000000009");
}