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

**

** 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 <QStandardItemModel>

#include <QStringListModel>

#include <qabstractitemmodel.h>

#include <qapplication.h>

#include <qheaderview.h>

#include <private/qheaderview_p.h>

#include <qitemdelegate.h>

#include <qtreewidget.h>

#include <qdebug.h>

typedef QList<int> IntList;

Q_DECLARE_METATYPE(IntList)

typedef QList<bool> BoolList;

Q_DECLARE_METATYPE(BoolList)

//TESTED_CLASS=

//TESTED_FILES=

// Will try to wait for the condition while allowing event processing

// for a maximum of 2 seconds.

#define WAIT_FOR_CONDITION(expr, expected) \

    do { \

        const int step = 100; \

        for (int i = 0; i < 2000 && expr != expected; i+=step) { \

            QTest::qWait(step); \

        } \

    } while(0)

class protected_QHeaderView : public QHeaderView

{

    Q_OBJECT

public:

    protected_QHeaderView(Qt::Orientation orientation) : QHeaderView(orientation) {

        resizeSections();

    };

    void testEvent();

    void testhorizontalOffset();

    void testverticalOffset();

    friend class tst_QHeaderView;

};

class tst_QHeaderView : public QObject

{

    Q_OBJECT

public:

    tst_QHeaderView();

    virtual ~tst_QHeaderView();

public slots:

    void initTestCase();

    void cleanupTestCase();

    void init();

    void cleanup();

private slots:

    void getSetCheck();

    void visualIndex();

    void visualIndexAt_data();

    void visualIndexAt();

    void noModel();

    void emptyModel();

    void removeRows();

    void removeCols();

    void clickable();

    void movable();

    void hidden();

    void stretch();

    void sectionSize_data();

    void sectionSize();

    void length();

    void offset();

    void sectionSizeHint();

    void logicalIndex();

    void logicalIndexAt();

    void swapSections();

    void moveSection_data();

    void moveSection();

    void resizeMode();

    void resizeSection_data();

    void resizeSection();

    void resizeAndMoveSection_data();

    void resizeAndMoveSection();

    void resizeHiddenSection_data();

    void resizeHiddenSection();

    void resizeAndInsertSection_data();

    void resizeAndInsertSection();

    void resizeWithResizeModes_data();

    void resizeWithResizeModes();

    void moveAndInsertSection_data();

    void moveAndInsertSection();

    void highlightSections();

    void showSortIndicator();

    void sortIndicatorTracking();

    void removeAndInsertRow();

    void unhideSection();

    void event();

    void headerDataChanged();

    void currentChanged();

    void horizontalOffset();

    void verticalOffset();

    void stretchSectionCount();

    void hiddenSectionCount();

    void focusPolicy();

    void moveSectionAndReset();

    void moveSectionAndRemove();

    void saveRestore();

    void defaultAlignment_data();

    void defaultAlignment();

    void globalResizeMode_data();

    void globalResizeMode();

    void sectionPressedSignal_data();

    void sectionPressedSignal();

    void sectionClickedSignal_data() { sectionPressedSignal_data(); }

    void sectionClickedSignal();

    void defaultSectionSize_data();

    void defaultSectionSize();

    void oneSectionSize();

    void hideAndInsert_data();

    void hideAndInsert();

    void removeSection();

    void preserveHiddenSectionWidth();

    void invisibleStretchLastSection();

    void emptySectionSpan();

    void task236450_hidden_data();

    void task236450_hidden();

    void task248050_hideRow();

protected:

    QHeaderView *view;

    QStandardItemModel *model;

};

class QtTestModel: public QAbstractTableModel

{

Q_OBJECT

public:

    QtTestModel(QObject *parent = 0): QAbstractTableModel(parent),

       cols(0), rows(0), wrongIndex(false) {}

    int rowCount(const QModelIndex&) const { return rows; }

    int columnCount(const QModelIndex&) const { return cols; }

    bool isEditable(const QModelIndex &) const { return true; }

    QVariant data(const QModelIndex &idx, int) const

    {

        if (idx.row() < 0 || idx.column() < 0 || idx.column() >= cols || idx.row() >= rows) {

            wrongIndex = true;

            qWarning("Invalid modelIndex [%d,%d,%p]", idx.row(), idx.column(), idx.internalPointer());

        }

        return QString("[%1,%2,%3]").arg(idx.row()).arg(idx.column()).arg(0);//idx.data());

    }

    void insertOneColumn(int col)

    {

        beginInsertColumns(QModelIndex(), col, col);

        --cols;

        endInsertColumns();

    }

    void removeLastRow()

    {

        beginRemoveRows(QModelIndex(), rows - 1, rows - 1);

        --rows;

        endRemoveRows();

    }

    void removeAllRows()

    {

        beginRemoveRows(QModelIndex(), 0, rows - 1);

        rows = 0;

        endRemoveRows();

    }

    void removeOneColumn(int col)

    {

        beginRemoveColumns(QModelIndex(), col, col);

        --cols;

        endRemoveColumns();

    }

    void removeLastColumn()

    {

        beginRemoveColumns(QModelIndex(), cols - 1, cols - 1);

        --cols;

        endRemoveColumns();

    }

    void removeAllColumns()

    {

        beginRemoveColumns(QModelIndex(), 0, cols - 1);

        cols = 0;

        endRemoveColumns();

    }

    void cleanup()

    {

        cols = 3;

        rows = 3;

        emit layoutChanged();

    }

    int cols, rows;

    mutable bool wrongIndex;

};

// Testing get/set functions

void tst_QHeaderView::getSetCheck()

{

    protected_QHeaderView obj1(Qt::Horizontal);

    // bool QHeaderView::highlightSections()

    // void QHeaderView::setHighlightSections(bool)

    obj1.setHighlightSections(false);

    QCOMPARE(false, obj1.highlightSections());

    obj1.setHighlightSections(true);

    QCOMPARE(true, obj1.highlightSections());

    // bool QHeaderView::stretchLastSection()

    // void QHeaderView::setStretchLastSection(bool)

    obj1.setStretchLastSection(false);

    QCOMPARE(false, obj1.stretchLastSection());

    obj1.setStretchLastSection(true);

    QCOMPARE(true, obj1.stretchLastSection());

    // int QHeaderView::defaultSectionSize()

    // void QHeaderView::setDefaultSectionSize(int)

    obj1.setDefaultSectionSize(0);

    QCOMPARE(0, obj1.defaultSectionSize());

    obj1.setDefaultSectionSize(INT_MIN);

    QCOMPARE(INT_MIN, obj1.defaultSectionSize());

    obj1.setDefaultSectionSize(INT_MAX);

    QCOMPARE(INT_MAX, obj1.defaultSectionSize());

    // ### the test above does not make sense for values below 0

    // int QHeaderView::minimumSectionSize()

    // void QHeaderView::setMinimumSectionSize(int)

    obj1.setMinimumSectionSize(0);

    QCOMPARE(0, obj1.minimumSectionSize());

    obj1.setMinimumSectionSize(INT_MIN);

    QCOMPARE(INT_MIN, obj1.minimumSectionSize());

    obj1.setMinimumSectionSize(INT_MAX);

    QCOMPARE(INT_MAX, obj1.minimumSectionSize());

    // ### the test above does not make sense for values below 0

    // int QHeaderView::offset()

    // void QHeaderView::setOffset(int)

    obj1.setOffset(0);

    QCOMPARE(0, obj1.offset());

    obj1.setOffset(INT_MIN);

    QCOMPARE(INT_MIN, obj1.offset());

    obj1.setOffset(INT_MAX);

    QCOMPARE(INT_MAX, obj1.offset());

}

tst_QHeaderView::tst_QHeaderView()

{

    qRegisterMetaType<int>("Qt::SortOrder");

}

tst_QHeaderView::~tst_QHeaderView()

{

}

void tst_QHeaderView::initTestCase()

{

#ifdef Q_OS_WINCE //disable magic for WindowsCE

    qApp->setAutoMaximizeThreshold(-1);

#endif

}

void tst_QHeaderView::cleanupTestCase()

{

}

void tst_QHeaderView::init()

{

    view = new QHeaderView(Qt::Vertical);

    // Some initial value tests before a model is added

    QCOMPARE(view->length(), 0);

    QVERIFY(view->sizeHint() == QSize(0,0));

    QCOMPARE(view->sectionSizeHint(0), -1);

    /*

    model = new QStandardItemModel(1, 1);

    view->setModel(model);

    //qDebug() << view->count();

    view->sizeHint();

    */

    int rows = 4;

    int columns = 4;

    model = new QStandardItemModel(rows, columns);

    /*

    for (int row = 0; row < rows; ++row) {

        for (int column = 0; column < columns; ++column) {

            QModelIndex index = model->index(row, column, QModelIndex());

            model->setData(index, QVariant((row+1) * (column+1)));

        }

    }

    */

    QSignalSpy spy(view, SIGNAL(sectionCountChanged(int, int)));

    view->setModel(model);

    QCOMPARE(spy.count(), 1);

    view->show();

}

void tst_QHeaderView::cleanup()

{

    delete view;

    view = 0;

    delete model;

    model = 0;

}

void tst_QHeaderView::noModel()

{

    QHeaderView emptyView(Qt::Vertical);

    QCOMPARE(emptyView.count(), 0);

}

void tst_QHeaderView::emptyModel()

{

    QtTestModel testmodel;

    view->setModel(&testmodel);

    QVERIFY(!testmodel.wrongIndex);

    QCOMPARE(view->count(), testmodel.rows);

    view->setModel(model);

}

void tst_QHeaderView::removeRows()

{

    QtTestModel model;

    model.rows = model.cols = 10;

    QHeaderView vertical(Qt::Vertical);

    QHeaderView horizontal(Qt::Horizontal);

    vertical.setModel(&model);

    horizontal.setModel(&model);

    vertical.show();

    horizontal.show();

    QCOMPARE(vertical.count(), model.rows);

    QCOMPARE(horizontal.count(), model.cols);

    model.removeLastRow();

    QVERIFY(!model.wrongIndex);

    QCOMPARE(vertical.count(), model.rows);

    QCOMPARE(horizontal.count(), model.cols);

    model.removeAllRows();

    QVERIFY(!model.wrongIndex);

    QCOMPARE(vertical.count(), model.rows);

    QCOMPARE(horizontal.count(), model.cols);

}

void tst_QHeaderView::removeCols()

{

    QtTestModel model;

    model.rows = model.cols = 10;

    QHeaderView vertical(Qt::Vertical);

    QHeaderView horizontal(Qt::Horizontal);

    vertical.setModel(&model);

    horizontal.setModel(&model);

    vertical.show();

    horizontal.show();

    QCOMPARE(vertical.count(), model.rows);

    QCOMPARE(horizontal.count(), model.cols);

    model.removeLastColumn();

    QVERIFY(!model.wrongIndex);

    QCOMPARE(vertical.count(), model.rows);

    QCOMPARE(horizontal.count(), model.cols);

    model.removeAllColumns();

    QVERIFY(!model.wrongIndex);

    QCOMPARE(vertical.count(), model.rows);

    QCOMPARE(horizontal.count(), model.cols);

}

void tst_QHeaderView::movable()

{

    QCOMPARE(view->isMovable(), false);

    view->setMovable(false);

    QCOMPARE(view->isMovable(), false);

    view->setMovable(true);

    QCOMPARE(view->isMovable(), true);

}

void tst_QHeaderView::clickable()

{

    QCOMPARE(view->isClickable(), false);

    view->setClickable(false);

    QCOMPARE(view->isClickable(), false);

    view->setClickable(true);

    QCOMPARE(view->isClickable(), true);

}

void tst_QHeaderView::hidden()

{

    //hideSection() & showSection call setSectionHidden

    // Test bad arguments

    QCOMPARE(view->isSectionHidden(-1), false);

    QCOMPARE(view->isSectionHidden(view->count()), false);

    QCOMPARE(view->isSectionHidden(999999), false);

    view->setSectionHidden(-1, true);

    view->setSectionHidden(view->count(), true);

    view->setSectionHidden(999999, true);

    view->setSectionHidden(-1, false);

    view->setSectionHidden(view->count(), false);

    view->setSectionHidden(999999, false);

    // Hidden sections shouldn't have visual properties (except position)

    int pos = view->defaultSectionSize();

    view->setSectionHidden(1, true);

    QCOMPARE(view->sectionSize(1), 0);

    QCOMPARE(view->sectionPosition(1), pos);

    view->resizeSection(1, 100);

    QCOMPARE(view->sectionViewportPosition(1), pos);

    QCOMPARE(view->sectionSize(1), 0);

    view->setSectionHidden(1, false);

    QCOMPARE(view->isSectionHidden(0), false);

    QCOMPARE(view->sectionSize(0), view->defaultSectionSize());

}

void tst_QHeaderView::stretch()

{

    // Show before resize and setStrechLastSection

#if defined(Q_OS_WINCE)

    QSize viewSize(200,300);

#else

    QSize viewSize(500, 500);

#endif

    view->resize(viewSize);

    view->setStretchLastSection(true);

    QCOMPARE(view->stretchLastSection(), true);

    view->show();

    QCOMPARE(view->width(), viewSize.width());

    QCOMPARE(view->visualIndexAt(view->viewport()->height() - 5), 3);

    view->setSectionHidden(3, true);

    QCOMPARE(view->visualIndexAt(view->viewport()->height() - 5), 2);

    view->setStretchLastSection(false);

    QCOMPARE(view->stretchLastSection(), false);

}

void tst_QHeaderView::oneSectionSize()

{

    //this ensures that if there is only one section, it gets a correct width (more than 0)

    QHeaderView view (Qt::Vertical);

    QtTestModel model;

    model.cols = 1;

    model.rows = 1;

    view.setResizeMode(QHeaderView::Interactive);

    view.setModel(&model);