///////////////////////////////////////////////////////////////////////////////
// Name:        tests/validators/valnum.cpp
// Purpose:     Unit tests for numeric validators.
// Author:      Vadim Zeitlin
// Created:     2011-01-18
// Copyright:   (c) 2011 Vadim Zeitlin <vadim@wxwidgets.org>
///////////////////////////////////////////////////////////////////////////////

#include "testprec.h"


#ifndef WX_PRECOMP
    #include "wx/app.h"
    #include "wx/intl.h"
    #include "wx/textctrl.h"
    #include "wx/validate.h"
#endif // WX_PRECOMP

#include "wx/valnum.h"

#include "asserthelper.h"
#include "testableframe.h"

#include "wx/scopeguard.h"
#include "wx/uiaction.h"

#include "waitfor.h"

class NumValidatorTestCase
{
public:
    NumValidatorTestCase();
    ~NumValidatorTestCase();

protected:
    wxTextCtrl* const m_text;

    wxDECLARE_NO_COPY_CLASS(NumValidatorTestCase);
};

NumValidatorTestCase::NumValidatorTestCase()
    : m_text(new wxTextCtrl(wxTheApp->GetTopWindow(), wxID_ANY))
{
}

NumValidatorTestCase::~NumValidatorTestCase()
{
    delete m_text;
}

TEST_CASE_METHOD(NumValidatorTestCase, "ValNum::TransferInt", "[valnum]")
{
    int value = 0;
    wxIntegerValidator<int> valInt(&value);
    valInt.SetWindow(m_text);

    CHECK( valInt.TransferToWindow() );
    CHECK( m_text->GetValue() == "0" );

    value = 17;
    CHECK( valInt.TransferToWindow() );
    CHECK( m_text->GetValue() == "17" );


    m_text->ChangeValue("foobar");
    CHECK( !valInt.TransferFromWindow() );

    m_text->ChangeValue("-234");
    CHECK( valInt.TransferFromWindow() );
    CHECK( value == -234 );

    m_text->ChangeValue("9223372036854775808"); // == LLONG_MAX + 1
    CHECK( !valInt.TransferFromWindow() );

    m_text->Clear();
    CHECK( !valInt.TransferFromWindow() );
}

TEST_CASE_METHOD(NumValidatorTestCase, "ValNum::TransferUnsigned", "[valnum]")
{
    unsigned value = 0;
    wxIntegerValidator<unsigned> valUnsigned(&value);
    valUnsigned.SetWindow(m_text);

    CHECK( valUnsigned.TransferToWindow() );
    CHECK( m_text->GetValue() == "0" );

    value = 17;
    CHECK( valUnsigned.TransferToWindow() );
    CHECK( m_text->GetValue() == "17" );


    m_text->ChangeValue("foobar");
    CHECK( !valUnsigned.TransferFromWindow() );

    m_text->ChangeValue("-234");
    CHECK( !valUnsigned.TransferFromWindow() );

    m_text->ChangeValue("234");
    CHECK( valUnsigned.TransferFromWindow() );
    CHECK( value == 234 );

    m_text->ChangeValue("4294967295"); // == ULONG_MAX in 32 bits
    CHECK( valUnsigned.TransferFromWindow() );
    CHECK( value == wxUINT32_MAX );
    CHECK( valUnsigned.TransferToWindow() );
    CHECK( m_text->GetValue() == "4294967295" );

    m_text->ChangeValue("4294967296"); // == ULONG_MAX + 1
    CHECK( !valUnsigned.TransferFromWindow() );

    m_text->ChangeValue("18446744073709551616"); // == ULLONG_MAX + 1
    CHECK( !valUnsigned.TransferFromWindow() );

    m_text->Clear();
    CHECK( !valUnsigned.TransferFromWindow() );
}

TEST_CASE_METHOD(NumValidatorTestCase, "ValNum::TransferUnsignedRange", "[valnum]")
{
    unsigned value = 1;
    wxIntegerValidator<unsigned> valUnsigned(&value, 1, 20);
    valUnsigned.SetWindow(m_text);

    CHECK( valUnsigned.TransferToWindow() );
    CHECK( m_text->GetValue() == "1" );

    value = 17;
    CHECK( valUnsigned.TransferToWindow() );
    CHECK( m_text->GetValue() == "17" );

    m_text->ChangeValue("foobar");
    CHECK( !valUnsigned.TransferFromWindow() );

    m_text->ChangeValue("0");
    CHECK( !valUnsigned.TransferFromWindow() );

    m_text->ChangeValue("1");
    CHECK( valUnsigned.TransferFromWindow() );
    CHECK( value == 1);

    m_text->ChangeValue("20");
    CHECK( valUnsigned.TransferFromWindow() );
    CHECK( value == 20);

    m_text->ChangeValue("21");
    CHECK( !valUnsigned.TransferFromWindow() );

    m_text->Clear();
    CHECK( !valUnsigned.TransferFromWindow() );
}

TEST_CASE_METHOD(NumValidatorTestCase, "ValNum::TransferULL", "[valnum]")
{
    unsigned long long value = 0;
    wxIntegerValidator<unsigned long long> valULL(&value);
    valULL.SetWindow(m_text);

    SECTION("LLONG_MAX")
    {
        m_text->ChangeValue("9223372036854775807"); // == LLONG_MAX
        REQUIRE( valULL.TransferFromWindow() );
        CHECK( value == static_cast<wxULongLong_t>(wxINT64_MAX) );

        REQUIRE( valULL.TransferToWindow() );
        CHECK( m_text->GetValue() == "9223372036854775807" );
    }

    SECTION("LLONG_MAX+1")
    {
        m_text->ChangeValue("9223372036854775808"); // == LLONG_MAX + 1
        REQUIRE( valULL.TransferFromWindow() );
        CHECK( value == static_cast<wxULongLong_t>(wxINT64_MAX) + 1 );

        REQUIRE( valULL.TransferToWindow() );
        CHECK( m_text->GetValue() == "9223372036854775808" );
    }

    SECTION("ULLONG_MAX")
    {
        m_text->ChangeValue("18446744073709551615"); // == ULLONG_MAX
        REQUIRE( valULL.TransferFromWindow() );
        CHECK( value == wxUINT64_MAX );

        REQUIRE( valULL.TransferToWindow() );
        CHECK( m_text->GetValue() == "18446744073709551615" );
    }

    SECTION("ULLONG_MAX+1")
    {
        m_text->ChangeValue("18446744073709551616"); // == ULLONG_MAX + 1
        CHECK( !valULL.TransferFromWindow() );
    }
}

TEST_CASE_METHOD(NumValidatorTestCase, "ValNum::TransferFloat", "[valnum]")
{
    // We need a locale with point as decimal separator.
    wxLocale loc(wxLANGUAGE_ENGLISH_UK, wxLOCALE_DONT_LOAD_DEFAULT);

    float value = 0;
    wxFloatingPointValidator<float> valFloat(3, &value);
    valFloat.SetWindow(m_text);

    CHECK( valFloat.TransferToWindow() );
    CHECK( m_text->GetValue() == "0.000" );

    value = 1.234f;
    CHECK( valFloat.TransferToWindow() );
    CHECK( m_text->GetValue() == "1.234" );

    value = 1.2345678f;
    CHECK( valFloat.TransferToWindow() );
    CHECK( m_text->GetValue() == "1.235" );


    m_text->ChangeValue("foobar");
    CHECK( !valFloat.TransferFromWindow() );

    m_text->ChangeValue("-234.567");
    CHECK( valFloat.TransferFromWindow() );
    CHECK( value == -234.567f );

    m_text->Clear();
    CHECK( !valFloat.TransferFromWindow() );
}

TEST_CASE_METHOD(NumValidatorTestCase, "ValNum::ZeroAsBlank", "[valnum]")
{
    long value = 0;
    m_text->SetValidator(
        wxMakeIntegerValidator(&value, wxNUM_VAL_ZERO_AS_BLANK));

    wxValidator * const val = m_text->GetValidator();

    CHECK( val->TransferToWindow() );
    CHECK( m_text->GetValue() == "" );

    value++;
    CHECK( val->TransferFromWindow() );
    CHECK( value == 0 );

    // Check that switching focus to another control doesn't change the value:
    // we need to trigger the "kill focus" event for m_text, so create another
    // control which can be focused and give it the focus and also mark this
    // control as "modified" because we we avoid changing its contents if it
    // has never been modified at all.
    m_text->SetSize(100, 50);
    m_text->MarkDirty();
    m_text->SetFocus();
    std::unique_ptr<wxTextCtrl>
        text2(new wxTextCtrl(wxTheApp->GetTopWindow(), wxID_ANY, "Test",
                             wxPoint(0, 100), wxSize(100, 50)));
    text2->SetFocus();
    WaitFor("the other control to become focused", [&text2]() {
        return text2->HasFocus();
    });
    CHECK( m_text->GetValue() == "" );
}

TEST_CASE_METHOD(NumValidatorTestCase, "ValNum::NoTrailingZeroes", "[valnum]")
{
    // We need a locale with point as decimal separator.
    wxLocale loc(wxLANGUAGE_ENGLISH_UK, wxLOCALE_DONT_LOAD_DEFAULT);

    double value = 1.2;
    m_text->SetValidator(
        wxMakeFloatingPointValidator(3, &value, wxNUM_VAL_NO_TRAILING_ZEROES));

    wxValidator * const val = m_text->GetValidator();

    CHECK( val->TransferToWindow() );
    CHECK( m_text->GetValue() == "1.2" );

    value = 1.234;
    CHECK( val->TransferToWindow() );
    CHECK( m_text->GetValue() == "1.234" );
}

TEST_CASE_METHOD(NumValidatorTestCase, "ValNum::SignPlus", "[valnum]")
{
    double value = 1.2;
    m_text->SetValidator(
        wxMakeFloatingPointValidator(3, &value, wxNUM_VAL_NO_TRAILING_ZEROES |
                                                wxNUM_VAL_SIGN_PLUS));

    wxValidator * const val = m_text->GetValidator();

    CHECK( val->TransferToWindow() );
    CHECK( m_text->GetValue() == "+1.2" );

    value = 1.234;
    CHECK( val->TransferToWindow() );
    CHECK( m_text->GetValue() == "+1.234" );
}

TEST_CASE_METHOD(NumValidatorTestCase, "ValNum::SignSpace", "[valnum]")
{
    double value = 1.2;
    m_text->SetValidator(
        wxMakeFloatingPointValidator(3, &value, wxNUM_VAL_NO_TRAILING_ZEROES |
                                                wxNUM_VAL_SIGN_SPACE));

    wxValidator * const val = m_text->GetValidator();

    CHECK( val->TransferToWindow() );
    CHECK( m_text->GetValue() == " 1.2" );

    value = 1.234;
    CHECK( val->TransferToWindow() );
    CHECK( m_text->GetValue() == " 1.234" );
}

#if wxUSE_UIACTIONSIMULATOR

TEST_CASE_METHOD(NumValidatorTestCase, "ValNum::Interactive", "[valnum]")
{
    // Set a locale using comma as thousands separator character.
    wxLocale loc(wxLANGUAGE_ENGLISH_UK, wxLOCALE_DONT_LOAD_DEFAULT);

    m_text->SetValidator(
        wxIntegerValidator<unsigned>(nullptr, wxNUM_VAL_THOUSANDS_SEPARATOR));

    // Create a sibling text control to be able to switch focus and thus
    // trigger the control validation/normalization.
    wxTextCtrl * const text2 = new wxTextCtrl(m_text->GetParent(), wxID_ANY);
    wxON_BLOCK_EXIT_OBJ0( *text2, wxWindow::Destroy );
    text2->Move(10, 80); // Just to see it better while debugging...
    wxFloatingPointValidator<float> valFloat(3);
    valFloat.SetRange(-10., 10.);
    text2->SetValidator(valFloat);

    wxUIActionSimulator sim;

    // Entering '-' in a control with positive range is not allowed.
    m_text->SetFocus();
    wxYield();
    sim.Char('-');
    wxYield();
    CHECK( m_text->GetValue() == "" );

    // Neither is entering '.' or any non-digit character.
    sim.Text(".a+/");
    wxYield();
    CHECK( m_text->GetValue() == "" );

    // Entering digits should work though and after leaving the control the
    // contents should be normalized.
    sim.Text("1234567");
    wxYield();
    text2->SetFocus();
    wxYield();
    if ( loc.IsOk() )
        CHECK( m_text->GetValue() == "1,234,567" );
    else
        CHECK( m_text->GetValue() == "1234567" );


    // Entering both '-' and '.' in this control should work but only in the
    // correct order.
    sim.Char('-');
    wxYield();
    CHECK( text2->GetValue() == "-" );

    text2->SetInsertionPoint(0);
    sim.Char('.');
    wxYield();
    CHECK( text2->GetValue() == "-" );

    text2->SetInsertionPointEnd();
    sim.Char('.');
    wxYield();
    CHECK( text2->GetValue() == "-." );

    // Adding up to three digits after the point should work.
    sim.Text("987");
    wxYield();
    CHECK( text2->GetValue() == "-.987" );

    // But no more.
    sim.Text("654");
    wxYield();
    CHECK( text2->GetValue() == "-.987" );

    // We can remove one digit and another one though.
    sim.Char(WXK_BACK);
    sim.Char(WXK_BACK);
    sim.Char('6');
    wxYield();
    CHECK( text2->GetValue() == "-.96" );


    // Also test the range constraint.
    valFloat.SetRange(10., 20.);
    text2->SetValidator(valFloat);
    text2->Clear();

    // Entering a value which is out of range but within
    // the extended input range is allowed.
    sim.Char('9');
    wxYield();
    CHECK( text2->GetValue() == "9" );

    // Entering a value greater than the positive range maximum
    // is not allowed.
    sim.Char('9');
    wxYield();
    CHECK( text2->GetValue() == "9" );

    // A value that is out of range but within the extended input
    // range must be clamped to the valid range on focus loss.
    m_text->SetFocus();
    wxYield();
    CHECK( text2->GetValue() == "10.000" );

    // Repeat the test with a negative invalid value.
    valFloat.SetRange(-20., -10.);
    text2->SetValidator(valFloat);
    text2->Clear();
    text2->SetFocus();

    sim.Text("-2");
    wxYield();
    CHECK( text2->GetValue() == "-2" );

    sim.Char('2');
    wxYield();
    CHECK( text2->GetValue() == "-2" );

    m_text->SetFocus();
    wxYield();
    CHECK( text2->GetValue() == "-10.000" );
}

#endif // wxUSE_UIACTIONSIMULATOR
