/****************************************************************************

**

** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the test suite of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include <QtTest/QtTest>

#include "../../shared/util.h"

#include "qlineedit.h"

#include "qapplication.h"

#include "qstringlist.h"

#include "qstyle.h"

#include "qvalidator.h"

#include "qcompleter.h"

#include "qstandarditemmodel.h"

#ifdef Q_WS_MAC

#include <Carbon/Carbon.h> // For the random function.

#include <cstdlib> // For the random function.

#endif

#include <qlineedit.h>

#include <qmenu.h>

#include <qlayout.h>

#include <qspinbox.h>

#include <qdebug.h>

//TESTED_CLASS=

//TESTED_FILES=

#include "qcommonstyle.h"

#include "qstyleoption.h"

QT_BEGIN_NAMESPACE

class QPainter;

QT_END_NAMESPACE

class StyleOptionTestStyle : public QCommonStyle

{

private:

    bool readOnly;

public:

    inline StyleOptionTestStyle() : QCommonStyle(), readOnly(false)

    {

    }

    inline void setReadOnly(bool readOnly)

    {

        this->readOnly = readOnly;

    }

    inline void drawPrimitive(PrimitiveElement pe, const QStyleOption *opt, QPainter *,

                                 const QWidget *) const

    {

        switch (pe) {

            case PE_PanelLineEdit:

            if (readOnly)

                QVERIFY(opt->state & QStyle::State_ReadOnly);

            else

                QVERIFY(!(opt->state & QStyle::State_ReadOnly));

            break;

            default:

            break;

        }

    }

};

class tst_QLineEdit : public QObject

{

Q_OBJECT

public:

    enum EventStates { Press, Release, Click };

    tst_QLineEdit();

    virtual ~tst_QLineEdit();

public slots:

    void initTestCase();

    void cleanupTestCase();

    void init();

    void cleanup();

private slots:

    void getSetCheck();

    void experimental();

    void upperAndLowercase();

    void setInputMask_data();

    void setInputMask();

    void inputMask_data();

    void inputMask();

    void clearInputMask();

    void keypress_inputMask_data();

    void keypress_inputMask();

    void inputMaskAndValidator_data();

    void inputMaskAndValidator();

    void hasAcceptableInputMask_data();

    void hasAcceptableInputMask();

    void hasAcceptableInputValidator();

    void redo_data();

    void redo();

    void isRedoAvailable();

    void undo_data();

    void undo();

    void isUndoAvailable();

    void undo_keypressevents_data();

    void undo_keypressevents();

    void clear();

    void text_data();

    void text();

    void textMask_data();

    void textMask();

    void maskCharacter();

    void maskCharacter_data();

    void setText();

    void displayText_data();

    void displayText();

    void setEchoMode();

    void echoMode();

    void passwordEchoOnEdit();

    void maxLength_mask_data();

    void maxLength_mask();

    void maxLength_data();

    void maxLength();

    void setMaxLength();

    void isReadOnly();

    void setReadOnly();

    void cursorPosition();

    void cursorPositionChanged_data();

    void cursorPositionChanged();

    void selectedText();

    void hasSelectedText();

    void deleteSelectedText();

    void textChangedAndTextEdited();

    void returnPressed();

    void returnPressed_maskvalidator_data();

    void returnPressed_maskvalidator();

    void setValidator();

    void validator();

    void clearValidator();

    void setValidator_QIntValidator_data();

    void setValidator_QIntValidator();

    void frame_data();

    void frame();

    void leftKeyOnSelectedText();

    void setAlignment_data();

    void setAlignment();

    void alignment();

    void isModified();

    void edited();

    void setEdited();

    void insert();

    void setSelection_data();

    void setSelection();

#ifndef QT_NO_CLIPBOARD

    void cut();

    void copy();

    void paste();

#endif

    void maxLengthAndInputMask();

    void returnPressedKeyEvent();

    void keepSelectionOnTabFocusIn();

    void readOnlyStyleOption();

    void validateOnFocusOut();

    void editInvalidText();

    void charWithAltOrCtrlModifier();

    void inlineCompletion();

    void noTextEditedOnClear();

    void cursor();

    void textMargin_data();

    void textMargin();

    // task-specific tests:

    void task180999_focus();

    void task174640_editingFinished();

#ifndef QT_NO_COMPLETER

    void task198789_currentCompletion();

    void task210502_caseInsensitiveInlineCompletion();

#endif

    void task229938_dontEmitChangedWhenTextIsNotChanged();

    void task233101_cursorPosAfterInputMethod_data();

    void task233101_cursorPosAfterInputMethod();

    void task241436_passwordEchoOnEditRestoreEchoMode();

    void task248948_redoRemovedSelection();

protected slots:

#ifdef QT3_SUPPORT

    void lostFocus();

#endif

    void editingFinished();

    void onTextChanged( const QString &newString );

    void onTextEdited( const QString &newString );

    void onReturnPressed();

    void onSelectionChanged();

    void onCursorPositionChanged(int oldpos, int newpos);

private:

    // keyClicks(..) is moved to QtTestCase

    void psKeyClick(QWidget *target, Qt::Key key, Qt::KeyboardModifiers pressState = 0);

    void psKeyClick(QTestEventList &keys, Qt::Key key, Qt::KeyboardModifiers pressState = 0);

    bool validInput;

    QString changed_string;

    int changed_count;

    int edited_count;

    int return_count;

    int selection_count;

    int lastCursorPos;

    int newCursorPos;

    QLineEdit *testWidget;

};

typedef QList<int> IntList;

Q_DECLARE_METATYPE(IntList)

Q_DECLARE_METATYPE(QLineEdit::EchoMode)

// Testing get/set functions

void tst_QLineEdit::getSetCheck()

{

    QLineEdit obj1;

    // const QValidator * QLineEdit::validator()

    // void QLineEdit::setValidator(const QValidator *)

    QIntValidator *var1 = new QIntValidator(0);

    obj1.setValidator(var1);

    QCOMPARE((const QValidator *)var1, obj1.validator());

    obj1.setValidator((QValidator *)0);

    QCOMPARE((const QValidator *)0, obj1.validator());

    delete var1;

    // bool QLineEdit::dragEnabled()

    // void QLineEdit::setDragEnabled(bool)

    obj1.setDragEnabled(false);

    QCOMPARE(false, obj1.dragEnabled());

    obj1.setDragEnabled(true);

    QCOMPARE(true, obj1.dragEnabled());

}

tst_QLineEdit::tst_QLineEdit()

{

    validInput = false;

}

tst_QLineEdit::~tst_QLineEdit()

{

}

void tst_QLineEdit::initTestCase()

{

    testWidget = new QLineEdit(0);

    testWidget->setObjectName("testWidget");

    connect(testWidget, SIGNAL(cursorPositionChanged(int, int)), this, SLOT(onCursorPositionChanged(int, int)));

    connect(testWidget, SIGNAL(textChanged(const QString&)), this, SLOT(onTextChanged(const QString&)));

    connect(testWidget, SIGNAL(textEdited(const QString&)), this, SLOT(onTextEdited(const QString&)));

    connect(testWidget, SIGNAL(returnPressed()), this, SLOT(onReturnPressed()));

    connect(testWidget, SIGNAL(selectionChanged()), this, SLOT(onSelectionChanged()));

    connect(testWidget, SIGNAL(editingFinished()), this, SLOT(editingFinished()));

#ifdef QT3_SUPPORT

    connect(testWidget, SIGNAL(lostFocus()), this, SLOT(lostFocus()));

#endif

    testWidget->resize(200,50);

    testWidget->show();

    QApplication::setActiveWindow(testWidget);

#ifdef Q_WS_X11

    // to be safe and avoid failing setFocus with window managers

    qt_x11_wait_for_window_manager(testWidget);

#endif

    QTRY_VERIFY(testWidget->hasFocus());

    changed_count = 0;

    edited_count = 0;

    selection_count = 0;

}

void tst_QLineEdit::cleanupTestCase()

{

    delete testWidget;

}

void tst_QLineEdit::init()

{

    return_count = 0;

    testWidget->clear();

    testWidget->setEchoMode(QLineEdit::Normal);

    testWidget->setMaxLength(32767);

    testWidget->setReadOnly(false);

    testWidget->setText("");

    testWidget->setInputMask("");

    testWidget->setFrame(true);

    testWidget->setValidator(0);

    testWidget->setDragEnabled(true);

}

void tst_QLineEdit::cleanup()

{

}

void tst_QLineEdit::experimental()

{

    QIntValidator intValidator(3, 7, 0);

    testWidget->setValidator(&intValidator);

    testWidget->setText("");

    // test the order of setting these

    testWidget->setInputMask("");

    testWidget->setText("abc123");

    testWidget->setInputMask("000.000.000.000");

    QCOMPARE(testWidget->text(), QString("123..."));

    testWidget->setText("");

}

void tst_QLineEdit::upperAndLowercase()

{

    testWidget->setInputMask("");

    testWidget->setText("");

    QTest::keyClicks(testWidget, "aAzZ`1234567890-=~!@#$%^&*()_+[]{}\\|;:'\",.<>/?");

    qApp->processEvents();

    QCOMPARE(testWidget->text(), QString("aAzZ`1234567890-=~!@#$%^&*()_+[]{}\\|;:'\",.<>/?"));

}

void tst_QLineEdit::setInputMask_data()

{

    QTest::addColumn<QString>("mask");

    QTest::addColumn<QString>("input");

    QTest::addColumn<QString>("expectedText");

    QTest::addColumn<QString>("expectedDisplay");

    QTest::addColumn<bool>("insert_text");

    // both keyboard and insert()

    for (int i=0; i<2; i++) {

        bool insert_text = i==0 ? false : true;

        QString insert_mode = "keys ";

        if (insert_text)

            insert_mode = "insert ";

        QTest::newRow(QString(insert_mode + "ip_localhost").toLatin1())

            << QString("000.000.000.000")

            << QString("127.0.0.1")

            << QString("127.0.0.1")

            << QString("127.0  .0  .1  ")

            << bool(insert_text);

        QTest::newRow(QString(insert_mode + "mac").toLatin1())

            << QString("HH:HH:HH:HH:HH:HH;#")

            << QString("00:E0:81:21:9E:8E")

            << QString("00:E0:81:21:9E:8E")

            << QString("00:E0:81:21:9E:8E")

            << bool(insert_text);

        QTest::newRow(QString(insert_mode + "mac2").toLatin1())

            << QString("<HH:>HH:!HH:HH:HH:HH;#")

            << QString("AAe081219E8E")

            << QString("aa:E0:81:21:9E:8E")

            << QString("aa:E0:81:21:9E:8E")

            << bool(insert_text);

        QTest::newRow(QString(insert_mode + "byte").toLatin1())

            << QString("BBBBBBBB;0")

            << QString("11011001")

            << QString("11111")

            << QString("11011001")

            << bool(insert_text);

        QTest::newRow(QString(insert_mode + "halfbytes").toLatin1())

            << QString("bbbb.bbbb;-")

            << QString("110. 0001")

            << QString("110.0001")

            << QString("110-.0001")

            << bool(insert_text);

        QTest::newRow(QString(insert_mode + "blank char same type as content").toLatin1())

            << QString("000.000.000.000;0")

            << QString("127.0.0.1")

            << QString("127...1")

            << QString("127.000.000.100")

            << bool(insert_text);

        QTest::newRow(QString(insert_mode + "parts of ip_localhost").toLatin1())

            << QString("000.000.000.000")

            << QString(".0.0.1")

            << QString(".0.0.1")

            << QString("   .0  .0  .1  ")

            << bool(insert_text);

        QTest::newRow(QString(insert_mode + "ip_null").toLatin1())

            << QString("000.000.000.000")

            << QString()

            << QString("...")

            << QString("   .   .   .   ")

            << bool(insert_text);

        QTest::newRow(QString(insert_mode + "ip_null_hash").toLatin1())

            << QString("000.000.000.000;#")

            << QString()

            << QString("...")

            << QString("###.###.###.###")

            << bool(insert_text);

        QTest::newRow(QString(insert_mode + "ip_overflow").toLatin1())

            << QString("000.000.000.000")

            << QString("1234123412341234")

            << QString("123.412.341.234")

            << QString("123.412.341.234")

            << bool(insert_text);

        QTest::newRow(QString(insert_mode + "uppercase").toLatin1())

            << QString(">AAAA")

            << QString("AbCd")

            << QString("ABCD")

            << QString("ABCD")

            << bool(insert_text);

        QTest::newRow(QString(insert_mode + "lowercase").toLatin1())

            << QString("<AAAA")

            << QString("AbCd")

            << QString("abcd")

            << QString("abcd")

            << bool(insert_text);

        QTest::newRow(QString(insert_mode + "nocase").toLatin1())

            << QString("!AAAA")

            << QString("AbCd")

            << QString("AbCd")

            << QString("AbCd")

            << bool(insert_text);

        QTest::newRow(QString(insert_mode + "nocase1").toLatin1())

            << QString("!A!A!A!A")

            << QString("AbCd")

            << QString("AbCd")

            << QString("AbCd")

            << bool(insert_text);

        QTest::newRow(QString(insert_mode + "nocase2").toLatin1())

            << QString("AAAA")

            << QString("AbCd")

            << QString("AbCd")

            << QString("AbCd")

            << bool(insert_text);

        QTest::newRow(QString(insert_mode + "reserved").toLatin1())

            << QString("{n}[0]")

            << QString("A9")

            << QString("A9")

            << QString("A9")

            << bool(insert_text);

        QTest::newRow(QString(insert_mode + "escape01").toLatin1())

            << QString("\\N\\n00")

            << QString("9")

            << QString("Nn9")

            << QString("Nn9 ")

            << bool(insert_text);

        QTest::newRow(QString(insert_mode + "escape02").toLatin1())

            << QString("\\\\00")

            << QString("0")

            << QString("\\0")

            << QString("\\0 ")

            << bool(insert_text);