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

**

** 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.h>

//TESTED_CLASS=

//TESTED_FILES=gui/itemviews/qstandarditemmodel.h gui/itemviews/qstandarditemmodel.cpp

class tst_QStandardItem : public QObject

{

    Q_OBJECT

public:

    tst_QStandardItem();

    virtual ~tst_QStandardItem();

public slots:

    void init();

    void cleanup();

private slots:

    void ctor();

    void textCtor();

    void iconTextCtor();

    void rowsColumnsCtor();

    void getSetData();

    void getSetFlags();

    void getSetRowAndColumnCount();

    void getSetChild_data();

    void getSetChild();

    void parent();

    void insertColumn_data();

    void insertColumn();

    void insertColumns_data();

    void insertColumns();

    void insertRow_data();

    void insertRow();

    void insertRows_data();

    void insertRows();

    void appendColumn_data();

    void appendColumn();

    void appendRow_data();

    void appendRow();

    void takeChild();

    void takeColumn_data();

    void takeColumn();

    void takeRow_data();

    void takeRow();

    void streamItem();

    void deleteItem();

    void clone();

    void sortChildren();

    void subclassing();

};

tst_QStandardItem::tst_QStandardItem()

{

}

tst_QStandardItem::~tst_QStandardItem()

{

}

void tst_QStandardItem::init()

{

}

void tst_QStandardItem::cleanup()

{

}

void tst_QStandardItem::ctor()

{

    QStandardItem item;

    QVERIFY(!item.hasChildren());

}

void tst_QStandardItem::textCtor()

{

    QLatin1String text("text");

    QStandardItem item(text);

    QCOMPARE(item.text(), text);

    QVERIFY(!item.hasChildren());

}

void tst_QStandardItem::iconTextCtor()

{

    QPixmap pixmap(32, 32);

    pixmap.fill(Qt::red);

    QIcon icon(pixmap);

    QLatin1String text("text");

    QStandardItem item(icon, text);

    QCOMPARE(item.icon(), icon);

    QCOMPARE(item.text(), text);

    QVERIFY(!item.hasChildren());

}

void tst_QStandardItem::rowsColumnsCtor()

{

    const int rows = 5;

    const int columns = 12;

    QStandardItem item(rows, columns);

    QCOMPARE(item.rowCount(), rows);

    QCOMPARE(item.columnCount(), columns);

}

void tst_QStandardItem::getSetData()

{

    QStandardItem item;

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

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

            QString text = QString("text %0").arg(i);

            item.setText(text);

            QCOMPARE(item.text(), text);

            QPixmap pixmap(32, 32);

            pixmap.fill((i == 1) ? Qt::red : Qt::green);

            QIcon icon(pixmap);

            item.setIcon(icon);

            QCOMPARE(item.icon(), icon);

            QString toolTip = QString("toolTip %0").arg(i);

            item.setToolTip(toolTip);

            QCOMPARE(item.toolTip(), toolTip);

            QString statusTip = QString("statusTip %0").arg(i);

            item.setStatusTip(statusTip);

            QCOMPARE(item.statusTip(), statusTip);

            QString whatsThis = QString("whatsThis %0").arg(i);

            item.setWhatsThis(whatsThis);

            QCOMPARE(item.whatsThis(), whatsThis);

            QSize sizeHint(64*i, 48*i);

            item.setSizeHint(sizeHint);

            QCOMPARE(item.sizeHint(), sizeHint);

            QFont font;

            item.setFont(font);

            QCOMPARE(item.font(), font);

            Qt::Alignment textAlignment((i == 1)

                                        ? Qt::AlignLeft|Qt::AlignVCenter

                                        : Qt::AlignRight);

            item.setTextAlignment(textAlignment);

            QCOMPARE(item.textAlignment(), textAlignment);

            QColor backgroundColor((i == 1) ? Qt::blue : Qt::yellow);

            item.setBackground(backgroundColor);

            QCOMPARE(item.background().color(), backgroundColor);

            QColor textColor((i == i) ? Qt::green : Qt::cyan);

            item.setForeground(textColor);

            QCOMPARE(item.foreground().color(), textColor);

            Qt::CheckState checkState((i == 1) ? Qt::PartiallyChecked : Qt::Checked);

            item.setCheckState(checkState);

            QCOMPARE(item.checkState(), checkState);

            QString accessibleText = QString("accessibleText %0").arg(i);

            item.setAccessibleText(accessibleText);

            QCOMPARE(item.accessibleText(), accessibleText);

            QString accessibleDescription = QString("accessibleDescription %0").arg(i);

            item.setAccessibleDescription(accessibleDescription);

            QCOMPARE(item.accessibleDescription(), accessibleDescription);

            QCOMPARE(item.text(), text);

            QCOMPARE(item.icon(), icon);

            QCOMPARE(item.toolTip(), toolTip);

            QCOMPARE(item.statusTip(), statusTip);

            QCOMPARE(item.whatsThis(), whatsThis);

            QCOMPARE(item.sizeHint(), sizeHint);

            QCOMPARE(item.font(), font);

            QCOMPARE(item.textAlignment(), textAlignment);

            QCOMPARE(item.background().color(), backgroundColor);

            QCOMPARE(item.foreground().color(), textColor);

            QCOMPARE(item.checkState(), checkState);

            QCOMPARE(item.accessibleText(), accessibleText);

            QCOMPARE(item.accessibleDescription(), accessibleDescription);

            QCOMPARE(qvariant_cast<QString>(item.data(Qt::DisplayRole)), text);

            QCOMPARE(qvariant_cast<QIcon>(item.data(Qt::DecorationRole)), icon);

            QCOMPARE(qvariant_cast<QString>(item.data(Qt::ToolTipRole)), toolTip);

            QCOMPARE(qvariant_cast<QString>(item.data(Qt::StatusTipRole)), statusTip);

            QCOMPARE(qvariant_cast<QString>(item.data(Qt::WhatsThisRole)), whatsThis);

            QCOMPARE(qvariant_cast<QSize>(item.data(Qt::SizeHintRole)), sizeHint);

            QCOMPARE(qvariant_cast<QFont>(item.data(Qt::FontRole)), font);

            QCOMPARE(qvariant_cast<int>(item.data(Qt::TextAlignmentRole)), int(textAlignment));

            QCOMPARE(qvariant_cast<QBrush>(item.data(Qt::BackgroundColorRole)), QBrush(backgroundColor));

            QCOMPARE(qvariant_cast<QBrush>(item.data(Qt::BackgroundRole)), QBrush(backgroundColor));

            QCOMPARE(qvariant_cast<QBrush>(item.data(Qt::TextColorRole)), QBrush(textColor));

            QCOMPARE(qvariant_cast<QBrush>(item.data(Qt::ForegroundRole)), QBrush(textColor));

            QCOMPARE(qvariant_cast<int>(item.data(Qt::CheckStateRole)), int(checkState));

            QCOMPARE(qvariant_cast<QString>(item.data(Qt::AccessibleTextRole)), accessibleText);

            QCOMPARE(qvariant_cast<QString>(item.data(Qt::AccessibleDescriptionRole)), accessibleDescription);

            item.setBackground(pixmap);

            QCOMPARE(item.background().texture(), pixmap);

            QCOMPARE(qvariant_cast<QBrush>(item.data(Qt::BackgroundRole)).texture(), pixmap);

        }

        item.setData(QVariant(), Qt::DisplayRole);

        item.setData(QVariant(), Qt::DecorationRole);

        item.setData(QVariant(), Qt::ToolTipRole);

        item.setData(QVariant(), Qt::StatusTipRole);

        item.setData(QVariant(), Qt::WhatsThisRole);

        item.setData(QVariant(), Qt::SizeHintRole);

        item.setData(QVariant(), Qt::FontRole);

        item.setData(QVariant(), Qt::TextAlignmentRole);

        item.setData(QVariant(), Qt::BackgroundRole);

        item.setData(QVariant(), Qt::ForegroundRole);

        item.setData(QVariant(), Qt::CheckStateRole);

        item.setData(QVariant(), Qt::AccessibleTextRole);

        item.setData(QVariant(), Qt::AccessibleDescriptionRole);

        QCOMPARE(item.data(Qt::DisplayRole), QVariant());

        QCOMPARE(item.data(Qt::DecorationRole), QVariant());

        QCOMPARE(item.data(Qt::ToolTipRole), QVariant());

        QCOMPARE(item.data(Qt::StatusTipRole), QVariant());

        QCOMPARE(item.data(Qt::WhatsThisRole), QVariant());

        QCOMPARE(item.data(Qt::SizeHintRole), QVariant());

        QCOMPARE(item.data(Qt::FontRole), QVariant());

        QCOMPARE(item.data(Qt::TextAlignmentRole), QVariant());

        QCOMPARE(item.data(Qt::BackgroundColorRole), QVariant());

        QCOMPARE(item.data(Qt::BackgroundRole), QVariant());

        QCOMPARE(item.data(Qt::TextColorRole), QVariant());

        QCOMPARE(item.data(Qt::ForegroundRole), QVariant());

        QCOMPARE(item.data(Qt::CheckStateRole), QVariant());

        QCOMPARE(item.data(Qt::AccessibleTextRole), QVariant());

        QCOMPARE(item.data(Qt::AccessibleDescriptionRole), QVariant());

    }

}

void tst_QStandardItem::getSetFlags()

{

    QStandardItem item;

    item.setEnabled(true);

    QVERIFY(item.isEnabled());

    QVERIFY(item.flags() & Qt::ItemIsEnabled);

    item.setEditable(true);

    QVERIFY(item.isEditable());

    QVERIFY(item.flags() & Qt::ItemIsEditable);

    item.setSelectable(true);

    QVERIFY(item.isSelectable());

    QVERIFY(item.flags() & Qt::ItemIsSelectable);

    item.setCheckable(true);

    QVERIFY(item.isCheckable());

    QCOMPARE(item.checkState(), Qt::Unchecked);

    QVERIFY(item.flags() & Qt::ItemIsUserCheckable);

    item.setTristate(true);

    QVERIFY(item.isTristate());

    QVERIFY(item.flags() & Qt::ItemIsTristate);

#ifndef QT_NO_DRAGANDDROP

    item.setDragEnabled(true);

    QVERIFY(item.isDragEnabled());

    QVERIFY(item.flags() & Qt::ItemIsDragEnabled);

    item.setDropEnabled(true);

    QVERIFY(item.isDropEnabled());

    QVERIFY(item.flags() & Qt::ItemIsDropEnabled);

#endif

    QVERIFY(item.isEnabled());

    item.setEnabled(false);

    QVERIFY(!item.isEnabled());

    QVERIFY(!(item.flags() & Qt::ItemIsEnabled));

    QVERIFY(item.isEditable());

    item.setEditable(false);

    QVERIFY(!item.isEditable());

    QVERIFY(!(item.flags() & Qt::ItemIsEditable));

    QVERIFY(item.isSelectable());

    item.setSelectable(false);

    QVERIFY(!item.isSelectable());

    QVERIFY(!(item.flags() & Qt::ItemIsSelectable));

    QVERIFY(item.isCheckable());

    item.setCheckable(false);

    QVERIFY(!item.isCheckable());

    QVERIFY(!(item.flags() & Qt::ItemIsUserCheckable));

    QVERIFY(item.isTristate());

    item.setTristate(false);

    QVERIFY(!item.isTristate());

    QVERIFY(!(item.flags() & Qt::ItemIsTristate));

#ifndef QT_NO_DRAGANDDROP

    QVERIFY(item.isDragEnabled());

    item.setDragEnabled(false);

    QVERIFY(!item.isDragEnabled());

    QVERIFY(!(item.flags() & Qt::ItemIsDragEnabled));

    QVERIFY(item.isDropEnabled());

    item.setDropEnabled(false);

    QVERIFY(!item.isDropEnabled());

    QVERIFY(!(item.flags() & Qt::ItemIsDropEnabled));

#endif

    item.setCheckable(false);

    item.setCheckState(Qt::Checked);

    item.setCheckable(true);

    QCOMPARE(item.checkState(), Qt::Checked);

}    

void tst_QStandardItem::getSetRowAndColumnCount()

{

    QStandardItem item;

    item.setRowCount(-1);

    QCOMPARE(item.rowCount(), 0);

    item.setColumnCount(-1);

    QCOMPARE(item.columnCount(), 0);

    item.setRowCount(1);

    QCOMPARE(item.rowCount(), 1);

    QCOMPARE(item.columnCount(), 0);

    item.setColumnCount(1);

    QCOMPARE(item.columnCount(), 1);

    QCOMPARE(item.rowCount(), 1);

    item.setColumnCount(10);

    QCOMPARE(item.columnCount(), 10);

    QCOMPARE(item.rowCount(), 1);

    item.setRowCount(20);

    QCOMPARE(item.rowCount(), 20);

    QCOMPARE(item.columnCount(), 10);

    item.setRowCount(-1);

    QCOMPARE(item.rowCount(), 20);

    item.setColumnCount(-1);

    QCOMPARE(item.columnCount(), 10);

    item.setColumnCount(0);

    QCOMPARE(item.columnCount(), 0);

    QCOMPARE(item.rowCount(), 20);

    item.setRowCount(0);

    QCOMPARE(item.rowCount(), 0);

}

void tst_QStandardItem::getSetChild_data()

{

    QTest::addColumn<int>("rows");

    QTest::addColumn<int>("columns");

    QTest::addColumn<int>("row");

    QTest::addColumn<int>("column");

    QTest::newRow("0x0 children, child at (-1,-1)") << 0 << 0 << -1 << -1;

    QTest::newRow("0x0 children, child at (0,0)") << 0 << 0 << 0 << 0;

}

void tst_QStandardItem::getSetChild()

{

    QFETCH(int, rows);

    QFETCH(int, columns);

    QFETCH(int, row);

    QFETCH(int, column);

    QStandardItem item(rows, columns);

    bool shouldHaveChildren = (rows > 0) && (columns > 0);

    QCOMPARE(item.hasChildren(), shouldHaveChildren);

    QCOMPARE(item.child(row, column), static_cast<QStandardItem*>(0));

    QStandardItem *child = new QStandardItem;

    item.setChild(row, column, child);

    if ((row >= 0) && (column >= 0)) {

        QCOMPARE(item.rowCount(), qMax(rows, row + 1));

        QCOMPARE(item.columnCount(), qMax(columns, column + 1));

        QCOMPARE(item.child(row, column), child);

        QCOMPARE(child->row(), row);

        QCOMPARE(child->column(), column);

        QStandardItem *anotherChild = new QStandardItem;

        item.setChild(row, column, anotherChild);

        QCOMPARE(item.child(row, column), anotherChild);

        QCOMPARE(anotherChild->row(), row);

        QCOMPARE(anotherChild->column(), column);

        item.setChild(row, column, 0);

    } else {

        delete child;

    }

    QCOMPARE(item.child(row, column), static_cast<QStandardItem*>(0));

}

void tst_QStandardItem::parent()

{

    {

        QStandardItem item;

        QStandardItem *child = new QStandardItem;

        QCOMPARE(child->parent(), static_cast<QStandardItem*>(0));

        item.setChild(0, 0, child);

        QCOMPARE(child->parent(), &item);

        QStandardItem *childOfChild = new QStandardItem;

        child->setChild(0, 0, childOfChild);

        QCOMPARE(childOfChild->parent(), child);

    }

    {

        QStandardItemModel model;

        QStandardItem *item = new QStandardItem;

        model.appendRow(item);

        // parent of a top-level item should be 0

        QCOMPARE(item->parent(), static_cast<QStandardItem*>(0));

    }

}

void tst_QStandardItem::insertColumn_data()

{

    QTest::addColumn<int>("rows");

    QTest::addColumn<int>("columns");

    QTest::addColumn<int>("column");

    QTest::addColumn<int>("count");

    QTest::newRow("insert 0 at -1 in 0x0") << 0 << 0 << -1 << 0;

    QTest::newRow("insert 0 at 0 in 0x0") << 0 << 0 << 0 << 0;

    QTest::newRow("insert 0 at 0 in 1x0") << 1 << 0 << 0 << 0;

    QTest::newRow("insert 0 at 0 in 0x1") << 0 << 1 << 0 << 0;

    QTest::newRow("insert 0 at 0 in 1x1") << 1 << 1 << 0 << 0;

    QTest::newRow("insert 1 at -1 in 0x0") << 0 << 0 << -1 << 1;

    QTest::newRow("insert 1 at 0 in 0x0") << 0 << 0 << 0 << 1;

    QTest::newRow("insert 1 at 0 in 1x0") << 1 << 0 << 0 << 1;

    QTest::newRow("insert 1 at 0 in 0x1") << 0 << 1 << 0 << 1;

    QTest::newRow("insert 1 at 0 in 1x1") << 1 << 1 << 0 << 1;

    QTest::newRow("insert 1 at 1 in 1x1") << 1 << 1 << 1 << 1;

    QTest::newRow("insert 1 at 0 in 2x1") << 2 << 1 << 0 << 1;

    QTest::newRow("insert 1 at 1 in 2x1") << 2 << 1 << 1 << 1;

    QTest::newRow("insert 1 at 0 in 1x2") << 1 << 2 << 0 << 1;

    QTest::newRow("insert 1 at 1 in 1x2") << 1 << 2 << 1 << 1;

    QTest::newRow("insert 1 at 0 in 8x4") << 8 << 4 << 0 << 1;

    QTest::newRow("insert 1 at 1 in 8x4") << 8 << 4 << 1 << 1;

    QTest::newRow("insert 1 at 2 in 8x4") << 8 << 4 << 2 << 1;

    QTest::newRow("insert 1 at 3 in 8x4") << 8 << 4 << 3 << 1;

    QTest::newRow("insert 1 at 4 in 8x4") << 8 << 4 << 4 << 1;

    QTest::newRow("insert 4 at 0 in 8x4") << 8 << 4 << 0 << 4;

    QTest::newRow("insert 4 at 4 in 8x4") << 8 << 4 << 4 << 4;

    QTest::newRow("insert 6 at 0 in 8x4") << 8 << 4 << 0 << 6;

    QTest::newRow("insert 6 at 4 in 8x4") << 8 << 4 << 4 << 6;

}

void tst_QStandardItem::insertColumn()

{

    QFETCH(int, rows);

    QFETCH(int, columns);

    QFETCH(int, column);

    QFETCH(int, count);

    QStandardItem item(rows, columns);

    // make items for a new column

    QList<QStandardItem*> columnItems;

    for (int i = 0; i < count; ++i)

        columnItems.append(new QStandardItem);

    item.insertColumn(column, columnItems);

    if (column >= 0) {

        QCOMPARE(item.columnCount(), columns + 1);

        QCOMPARE(item.rowCount(), qMax(rows, count));

        // check to make sure items were inserted in correct place

        for (int i = 0; i < count; ++i)

            QCOMPARE(item.child(i, column), columnItems.at(i));

        for (int i = count; i < item.rowCount(); ++i)

            QCOMPARE(item.child(i, column), static_cast<QStandardItem*>(0));

    } else {

        QCOMPARE(item.columnCount(), columns);

        QCOMPARE(item.rowCount(), rows);

        qDeleteAll(columnItems);

    }

}

void tst_QStandardItem::insertColumns_data()

{

}

void tst_QStandardItem::insertColumns()

{

}

void tst_QStandardItem::insertRow_data()

{

    QTest::addColumn<int>("rows");

    QTest::addColumn<int>("columns");

    QTest::addColumn<int>("row");

    QTest::addColumn<int>("count");

    QTest::newRow("insert 0 at -1 in 0x0") << 0 << 0 << -1 << 0;

    QTest::newRow("insert 0 at 0 in 0x0") << 0 << 0 << 0 << 0;