1 /****************************************************************************

     2 **

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

     4 ** All rights reserved.

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

     6 **

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

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

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

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

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

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

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

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

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

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

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

    23 **

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

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

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

    27 **

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

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

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 

    43 #include <QtTest/QtTest>

    44 

    45 #include <QMimeData>

    46 

    47 class tst_QMimeData : public QObject

    48 {

    49     Q_OBJECT

    50 public:

    51     tst_QMimeData()

    52     {

    53     }

    54 

    55 private slots:

    56     void clear() const;

    57     void colorData() const;

    58     void data() const;

    59     void formats() const;

    60     void hasColor() const;

    61     void hasFormat() const;

    62     void hasHtml() const;

    63     void hasImage() const;

    64     // hasText() covered by setText()

    65     // hasUrls() covered by setUrls()

    66     // html() covered by setHtml()

    67     void imageData() const;

    68     void removeFormat() const;

    69     // setColorData() covered by hasColor()

    70     // setData() covered in a few different tests

    71     void setHtml() const;

    72     // setImageData() covered in a few tests

    73     void setText() const;

    74     void setUrls() const;

    75     // text() covered in setText()

    76     // urls() covered by setUrls()

    77 };

    78 

    79 void tst_QMimeData::clear() const

    80 {

    81     QMimeData mimeData;

    82 

    83     // set, clear, verify empty

    84     mimeData.setData("text/plain", "pirates");

    85     QVERIFY(mimeData.hasText());

    86     mimeData.clear();

    87     QVERIFY(mimeData.hasText() == false);

    88 

    89     // repopulate, verify not empty

    90     mimeData.setData("text/plain", "pirates");

    91     QVERIFY(mimeData.hasText());

    92 }

    93 

    94 void tst_QMimeData::colorData() const

    95 {

    96     QMimeData mimeData;

    97     QColor red = Qt::red;

    98     QColor blue = Qt::blue;

    99 

   100     // set, verify

   101     mimeData.setColorData(red);

   102     QVERIFY(mimeData.hasColor());

   103     QCOMPARE(qvariant_cast<QColor>(mimeData.colorData()), red);

   104 

   105     // change, verify

   106     mimeData.setColorData(Qt::blue);

   107     QVERIFY(mimeData.hasColor());

   108     QCOMPARE(qvariant_cast<QColor>(mimeData.colorData()), blue);

   109 }

   110 

   111 void tst_QMimeData::data() const

   112 {

   113     QMimeData mimeData;

   114 

   115     // set text, verify

   116     mimeData.setData("text/plain", "pirates");

   117     QCOMPARE(mimeData.data("text/plain"), QByteArray("pirates"));

   118     QVERIFY(mimeData.data("text/html").length() == 0);

   119 

   120     // html time

   121     mimeData.setData("text/html", "ninjas");

   122     QCOMPARE(mimeData.data("text/html"), QByteArray("ninjas"));

   123     QCOMPARE(mimeData.data("text/plain"), QByteArray("pirates")); // make sure text not damaged

   124     QCOMPARE(mimeData.data("text/html"), mimeData.html().toLatin1());

   125 }

   126 

   127 void tst_QMimeData::formats() const

   128 {

   129     QMimeData mimeData;

   130 

   131     // set text, verify

   132     mimeData.setData("text/plain", "pirates");

   133     QCOMPARE(mimeData.formats(), QStringList() << "text/plain");

   134 

   135     // set html, verify

   136     mimeData.setData("text/html", "ninjas");

   137     QCOMPARE(mimeData.formats(), QStringList() << "text/plain" << "text/html");

   138 

   139     // clear, verify

   140     mimeData.clear();

   141     QCOMPARE(mimeData.formats(), QStringList());

   142 

   143     // set an odd format, verify

   144     mimeData.setData("foo/bar", "somevalue");

   145     QCOMPARE(mimeData.formats(), QStringList() << "foo/bar");

   146 }

   147 

   148 void tst_QMimeData::hasColor() const

   149 {

   150     QMimeData mimeData;

   151 

   152     // initial state

   153     QVERIFY(mimeData.hasColor() == false);

   154 

   155     // set, verify

   156     mimeData.setColorData(QColor(Qt::red));

   157     QVERIFY(mimeData.hasColor());

   158 

   159     // clear, verify

   160     mimeData.clear();

   161     QVERIFY(mimeData.hasColor() == false);

   162 

   163     // set something else, verify

   164     mimeData.setData("text/plain", "pirates");

   165     QVERIFY(mimeData.hasColor() == false);

   166 }

   167 

   168 void tst_QMimeData::hasFormat() const

   169 {

   170     QMimeData mimeData;

   171 

   172     // initial state

   173     QVERIFY(mimeData.hasFormat("text/plain") == false);

   174 

   175     // add, verify

   176     mimeData.setData("text/plain", "pirates");

   177     QVERIFY(mimeData.hasFormat("text/plain"));

   178     QVERIFY(mimeData.hasFormat("text/html") == false);

   179 

   180     // clear, verify

   181     mimeData.clear();

   182     QVERIFY(mimeData.hasFormat("text/plain") == false);

   183     QVERIFY(mimeData.hasFormat("text/html") == false);

   184 }

   185 

   186 void tst_QMimeData::hasHtml() const

   187 {

   188     QMimeData mimeData;

   189 

   190     // initial state

   191     QVERIFY(mimeData.hasHtml() == false);

   192 

   193     // add plain, verify false

   194     mimeData.setData("text/plain", "pirates");

   195     QVERIFY(mimeData.hasHtml() == false);

   196 

   197     // add html, verify

   198     mimeData.setData("text/html", "ninjas");

   199     QVERIFY(mimeData.hasHtml());

   200 

   201     // clear, verify

   202     mimeData.clear();

   203     QVERIFY(mimeData.hasHtml() == false);

   204 

   205     // readd, verify

   206     mimeData.setData("text/html", "ninjas");

   207     QVERIFY(mimeData.hasHtml());

   208 }

   209 

   210 void tst_QMimeData::hasImage() const

   211 {

   212     QMimeData mimeData;

   213 

   214     // initial state

   215     QVERIFY(mimeData.hasImage() == false);

   216 

   217     // add text, verify false

   218     mimeData.setData("text/plain", "pirates");

   219     QVERIFY(mimeData.hasImage() == false);

   220 

   221     // add image

   222     mimeData.setImageData(QImage());

   223     QVERIFY(mimeData.hasImage());

   224 

   225     // clear, verify

   226     mimeData.clear();

   227     QVERIFY(mimeData.hasImage() == false);

   228 }

   229 

   230 void tst_QMimeData::imageData() const

   231 {

   232     QMimeData mimeData;

   233 

   234     // initial state

   235     QCOMPARE(mimeData.imageData(), QVariant());

   236 

   237     // set, test

   238     mimeData.setImageData(QImage());

   239     QVERIFY(mimeData.hasImage());

   240     QCOMPARE(mimeData.imageData(), QVariant(QImage()));

   241 

   242     // clear, verify

   243     mimeData.clear();

   244     QCOMPARE(mimeData.imageData(), QVariant());

   245 }

   246 

   247 void tst_QMimeData::removeFormat() const

   248 {

   249     QMimeData mimeData;

   250 

   251     // add, verify

   252     mimeData.setData("text/plain", "pirates");

   253     QVERIFY(mimeData.hasFormat("text/plain"));

   254 

   255     // add another, verify

   256     mimeData.setData("text/html", "ninjas");

   257     QVERIFY(mimeData.hasFormat("text/html"));

   258 

   259     // remove, verify

   260     mimeData.removeFormat("text/plain");

   261     QVERIFY(mimeData.hasFormat("text/plain") == false);

   262     QVERIFY(mimeData.hasFormat("text/html"));

   263 

   264     // remove, verify

   265     mimeData.removeFormat("text/html");

   266     QVERIFY(mimeData.hasFormat("text/plain") == false);

   267     QVERIFY(mimeData.hasFormat("text/html") == false);

   268 }

   269 

   270 void tst_QMimeData::setHtml() const

   271 {

   272     QMimeData mimeData;

   273 

   274     // initial state

   275     QVERIFY(mimeData.hasHtml() == false);

   276 

   277     // add html, verify

   278     mimeData.setHtml("ninjas");

   279     QVERIFY(mimeData.hasHtml());

   280     QCOMPARE(mimeData.html(), QLatin1String("ninjas"));

   281 

   282     // reset html

   283     mimeData.setHtml("pirates");

   284     QVERIFY(mimeData.hasHtml());

   285     QCOMPARE(mimeData.html(), QLatin1String("pirates"));

   286 }

   287 

   288 void tst_QMimeData::setText() const

   289 {

   290     QMimeData mimeData;

   291 

   292     // verify initial state

   293     QCOMPARE(mimeData.text(), QLatin1String(""));

   294     QVERIFY(mimeData.hasText() == false);

   295 

   296     // set, verify

   297     mimeData.setText("pirates");

   298     QVERIFY(mimeData.hasText());

   299     QCOMPARE(mimeData.text(), QLatin1String("pirates"));

   300     QCOMPARE(mimeData.text().toLatin1(), mimeData.data("text/plain"));

   301 

   302     // reset, verify

   303     mimeData.setText("ninjas");

   304     QVERIFY(mimeData.hasText());

   305     QCOMPARE(mimeData.text(), QLatin1String("ninjas"));

   306     QCOMPARE(mimeData.text().toLatin1(), mimeData.data("text/plain"));

   307 

   308     // clear, verify

   309     mimeData.clear();

   310     QCOMPARE(mimeData.text(), QLatin1String(""));

   311     QVERIFY(mimeData.hasText() == false);

   312 }

   313 

   314 void tst_QMimeData::setUrls() const

   315 {

   316     QMimeData mimeData;

   317     QList<QUrl> shortUrlList;

   318     QList<QUrl> longUrlList;

   319 

   320     // set up

   321     shortUrlList += QUrl("http://qt.nokia.com");

   322     longUrlList = shortUrlList;

   323     longUrlList += QUrl("http://www.google.com");

   324 

   325     // verify initial state

   326     QVERIFY(mimeData.hasUrls() == false);

   327 

   328     // set a few, verify

   329     mimeData.setUrls(shortUrlList);

   330     QCOMPARE(mimeData.urls(), shortUrlList);

   331 

   332     // change them, verify

   333     mimeData.setUrls(longUrlList);

   334     QCOMPARE(mimeData.urls(), longUrlList);

   335 

   336     // clear, verify

   337     mimeData.clear();

   338     QVERIFY(mimeData.hasUrls() == false);

   339 }

   340 

   341 

   342 QTEST_MAIN(tst_QMimeData)

   343 #include "tst_qmimedata.moc"