58     void constructors() const;

    59     void append() const;

    60     void at() const;

    61     void capacity() const;

    62     void clear() const;

    63     void constData() const;

    64     void contains() const;

    65     void count() const;

    66     void data() const;

    67     void empty() const;

    68     void endsWith() const;

    69     void fill() const;

    70     void first() const;

    71     void fromList() const;

    72     void fromStdVector() const;

    73     void indexOf() const;

    74     void insert() const;

    75     void isEmpty() const;

    76     void last() const;

    77     void lastIndexOf() const;

    78     void mid() const;

    79     void prepend() const;

    80     void remove() const;

    81     void size() const;

    82     void startsWith() const;

    83     void toList() const;

    84     void toStdVector() const;

    85     void value() const;

    86 

    87     void testOperators() const;

    88 

    92 

    93 void tst_QVector::constructors() const

    94 {

    95     // pre-reserve capacity

    96     {

    97         QVector<int> myvec(5);

    98 

    99         QVERIFY(myvec.capacity() == 5);

   100     }

   101 

   102     // default-initialise items

   103     {

   104         QVector<int> myvec(5, 42);

   105 

   106         QVERIFY(myvec.capacity() == 5);

   107 

   108         // make sure all items are initialised ok

   109         foreach (int meaningoflife, myvec) {

   110             QCOMPARE(meaningoflife, 42);

   111         }

   112     }

   113 }

   114 

   115 void tst_QVector::append() const

   116 {

   117     QVector<int> myvec;

   118     myvec.append(42);

   119     myvec.append(43);

   120     myvec.append(44);

   121 

   122     QVERIFY(myvec.size() == 3);

   123     QCOMPARE(myvec, QVector<int>() << 42 << 43 << 44);

   124 }

   125 

   126 void tst_QVector::at() const

   127 {

   128     QVector<QString> myvec;

   129     myvec << "foo" << "bar" << "baz";

   130 

   131     QVERIFY(myvec.size() == 3);

   132     QCOMPARE(myvec.at(0), QLatin1String("foo"));

   133     QCOMPARE(myvec.at(1), QLatin1String("bar"));

   134     QCOMPARE(myvec.at(2), QLatin1String("baz"));

   135 

   136     // append an item

   137     myvec << "hello";

   138     QVERIFY(myvec.size() == 4);

   139     QCOMPARE(myvec.at(0), QLatin1String("foo"));

   140     QCOMPARE(myvec.at(1), QLatin1String("bar"));

   141     QCOMPARE(myvec.at(2), QLatin1String("baz"));

   142     QCOMPARE(myvec.at(3), QLatin1String("hello"));

   143 

   144     // remove an item

   145     myvec.remove(1);

   146     QVERIFY(myvec.size() == 3);

   147     QCOMPARE(myvec.at(0), QLatin1String("foo"));

   148     QCOMPARE(myvec.at(1), QLatin1String("baz"));

   149     QCOMPARE(myvec.at(2), QLatin1String("hello"));

   150 }

   151 

   152 void tst_QVector::capacity() const

   153 {

   154     QVector<QString> myvec;

   155 

   156     // TODO: is this guarenteed? seems a safe assumption, but I suppose preallocation of a

   157     // few items isn't an entirely unforseeable possibility.

   158     QVERIFY(myvec.capacity() == 0);

   159 

   160     // test it gets a size

   161     myvec << "aaa" << "bbb" << "ccc";

   162     QVERIFY(myvec.capacity() >= 3);

   163 

   164     // make sure it grows ok

   165     myvec << "aaa" << "bbb" << "ccc";

   166     QVERIFY(myvec.capacity() >= 6);

   167 

   168     // let's try squeeze a bit

   169     myvec.remove(3);

   170     myvec.remove(3);

   171     myvec.remove(3);

   172     // TODO: is this a safe assumption? presumably it won't release memory until shrink(), but can we asser that is true?

   173     QVERIFY(myvec.capacity() >= 6);

   174     myvec.squeeze();

   175     QVERIFY(myvec.capacity() >= 3);

   176 

   177     myvec.remove(0);

   178     myvec.remove(0);

   179     myvec.remove(0);

   180     // TODO: as above note

   181     QVERIFY(myvec.capacity() >= 3);

   182     myvec.squeeze();

   183     QVERIFY(myvec.capacity() == 0);

   184 }

   185 

   186 void tst_QVector::clear() const

   187 {

   188     QVector<QString> myvec;

   189     myvec << "aaa" << "bbb" << "ccc";

   190 

   191     QVERIFY(myvec.size() == 3);

   192     myvec.clear();

   193     QVERIFY(myvec.size() == 0);

   194     QVERIFY(myvec.capacity() == 0);

   195 }

   196 

   197 void tst_QVector::constData() const

   198 {

   199     int arr[] = { 42, 43, 44 };

   200     QVector<int> myvec;

   201     myvec << 42 << 43 << 44;

   202 

   203     QVERIFY(memcmp(myvec.constData(), reinterpret_cast<const int *>(&arr), sizeof(int) * 3) == 0);

   204 }

   205 

   206 void tst_QVector::contains() const

   207 {

   208     QVector<QString> myvec;

   209     myvec << "aaa" << "bbb" << "ccc";

   210 

   211     QVERIFY(myvec.contains(QLatin1String("aaa")));

   212     QVERIFY(myvec.contains(QLatin1String("bbb")));

   213     QVERIFY(myvec.contains(QLatin1String("ccc")));

   214     QVERIFY(!myvec.contains(QLatin1String("I don't exist")));

   215 

   216     // add it and make sure it does :)

   217     myvec.append(QLatin1String("I don't exist"));

   218     QVERIFY(myvec.contains(QLatin1String("I don't exist")));

   219 }

   220 

   221 void tst_QVector::count() const

   222 {

   223     // total size

   224     {

   225         // zero size

   226         QVector<int> myvec;

   227         QVERIFY(myvec.count() == 0);

   228 

   229         // grow

   230         myvec.append(42);

   231         QVERIFY(myvec.count() == 1);

   232         myvec.append(42);

   233         QVERIFY(myvec.count() == 2);

   234 

   235         // shrink

   236         myvec.remove(0);

   237         QVERIFY(myvec.count() == 1);

   238         myvec.remove(0);

   239         QVERIFY(myvec.count() == 0);

   240     }

   241 

   242     // count of items

   243     {

   244         QVector<QString> myvec;

   245         myvec << "aaa" << "bbb" << "ccc";

   246 

   247         // initial tests

   248         QVERIFY(myvec.count(QLatin1String("aaa")) == 1);

   249         QVERIFY(myvec.count(QLatin1String("pirates")) == 0);

   250 

   251         // grow

   252         myvec.append(QLatin1String("aaa"));

   253         QVERIFY(myvec.count(QLatin1String("aaa")) == 2);

   254 

   255         // shrink

   256         myvec.remove(0);

   257         QVERIFY(myvec.count(QLatin1String("aaa")) == 1);

   258     }

   259 }

   260 

   261 void tst_QVector::data() const

   262 {

   263     QVector<int> myvec;

   264     myvec << 42 << 43 << 44;

   265 

   266     // make sure it starts off ok

   267     QCOMPARE(*(myvec.data() + 1), 43);

   268 

   269     // alter it

   270     *(myvec.data() + 1) = 69;

   271 

   272     // check it altered

   273     QCOMPARE(*(myvec.data() + 1), 69);

   274 

   275     int arr[] = { 42, 69, 44 };

   276     QVERIFY(memcmp(myvec.data(), reinterpret_cast<int *>(&arr), sizeof(int) * 3) == 0);

   277 }

   278 

   279 void tst_QVector::empty() const

   280 {

   281     QVector<int> myvec;

   282 

   283     // starts empty

   284     QVERIFY(myvec.empty());

   285 

   286     // not empty

   287     myvec.append(1);

   288     QVERIFY(!myvec.empty());

   289 

   290     // empty again

   291     myvec.remove(0);

   292     QVERIFY(myvec.empty());

   293 }

   294 

   295 void tst_QVector::endsWith() const

   296 {

   297     QVector<int> myvec;

   298 

   299     // empty vector

   300     QVERIFY(!myvec.endsWith(1));

   301 

   302     // add the one, should work

   303     myvec.append(1);

   304     QVERIFY(myvec.endsWith(1));

   305 

   306     // add something else, fails now

   307     myvec.append(3);

   308     QVERIFY(!myvec.endsWith(1));

   309 

   310     // remove it again :)

   311     myvec.remove(1);

   312     QVERIFY(myvec.endsWith(1));

   313 }

   314 

   315 void tst_QVector::fill() const

   316 {

   317     QVector<int> myvec;

   318 

   319     // resize

   320     myvec.resize(5);

   321     myvec.fill(69);

   322     QCOMPARE(myvec, QVector<int>() << 69 << 69 << 69 << 69 << 69);

   323 

   324     // make sure it can resize itself too

   325     myvec.fill(42, 10);

   326     QCOMPARE(myvec, QVector<int>() << 42 << 42 << 42 << 42 << 42 << 42 << 42 << 42 << 42 << 42);

   327 }

   328 

   329 void tst_QVector::first() const

   330 {

   331     QVector<int> myvec;

   332     myvec << 69 << 42 << 3;

   333 

   334     // test it starts ok

   335     QCOMPARE(myvec.first(), 69);

   336 

   337     // test removal changes

   338     myvec.remove(0);

   339     QCOMPARE(myvec.first(), 42);

   340 

   341     // test prepend changes

   342     myvec.prepend(23);

   343     QCOMPARE(myvec.first(), 23);

   344 }

   345 

   346 void tst_QVector::fromList() const

   347 {

   348     QList<QString> list;

   349     list << "aaa" << "bbb" << "ninjas" << "pirates";

   350 

   351     QVector<QString> myvec;

   352     myvec = QVector<QString>::fromList(list);

   353 

   354     // test it worked ok

   355     QCOMPARE(myvec, QVector<QString>() << "aaa" << "bbb" << "ninjas" << "pirates");

   356     QCOMPARE(list, QList<QString>() << "aaa" << "bbb" << "ninjas" << "pirates");

   357 }

   358 

   359 void tst_QVector::fromStdVector() const

   360 {

   361     // stl = :(

   362     std::vector<QString> svec;

   363     svec.push_back(QLatin1String("aaa"));

   364     svec.push_back(QLatin1String("bbb"));

   365     svec.push_back(QLatin1String("ninjas"));

   366     svec.push_back(QLatin1String("pirates"));

   367     QVector<QString> myvec = QVector<QString>::fromStdVector(svec);

   368 

   369     // test it converts ok

   370     QCOMPARE(myvec, QVector<QString>() << "aaa" << "bbb" << "ninjas" << "pirates");

   371 }

   372 

   373 void tst_QVector::indexOf() const

   374 {

   375     QVector<QString> myvec;

   376     myvec << "A" << "B" << "C" << "B" << "A";

   377 

   378     QVERIFY(myvec.indexOf("B") == 1);

   379     QVERIFY(myvec.indexOf("B", 1) == 1);

   380     QVERIFY(myvec.indexOf("B", 2) == 3);

   381     QVERIFY(myvec.indexOf("X") == -1);

   382     QVERIFY(myvec.indexOf("X", 2) == -1);

   383 

   384     // add an X

   385     myvec << "X";

   386     QVERIFY(myvec.indexOf("X") == 5);

   387     QVERIFY(myvec.indexOf("X", 5) == 5);

   388     QVERIFY(myvec.indexOf("X", 6) == -1);

   389 

   390     // remove first A

   391     myvec.remove(0);

   392     QVERIFY(myvec.indexOf("A") == 3);

   393     QVERIFY(myvec.indexOf("A", 3) == 3);

   394     QVERIFY(myvec.indexOf("A", 4) == -1);

   395 }

   396 

   397 void tst_QVector::insert() const

   398 {

   399     QVector<QString> myvec;

   400     myvec << "A" << "B" << "C";

   401 

   402     // first position

   403     QCOMPARE(myvec.at(0), QLatin1String("A"));

   404     myvec.insert(0, QLatin1String("X"));

   405     QCOMPARE(myvec.at(0), QLatin1String("X"));

   406     QCOMPARE(myvec.at(1), QLatin1String("A"));

   407 

   408     // middle

   409     myvec.insert(1, QLatin1String("Z"));

   410     QCOMPARE(myvec.at(0), QLatin1String("X"));

   411     QCOMPARE(myvec.at(1), QLatin1String("Z"));

   412     QCOMPARE(myvec.at(2), QLatin1String("A"));

   413 

   414     // end

   415     myvec.insert(5, QLatin1String("T"));

   416     QCOMPARE(myvec.at(5), QLatin1String("T"));

   417     QCOMPARE(myvec.at(4), QLatin1String("C"));

   418 

   419     // insert a lot of garbage in the middle

   420     myvec.insert(2, 2, QLatin1String("infinity"));

   421     QCOMPARE(myvec, QVector<QString>() << "X" << "Z" << "infinity" << "infinity"

   422              << "A" << "B" << "C" << "T");

   423 }

   424 

   425 void tst_QVector::isEmpty() const

   426 {

   427     QVector<QString> myvec;

   428 

   429     // starts ok

   430     QVERIFY(myvec.isEmpty());

   431 

   432     // not empty now

   433     myvec.append(QLatin1String("hello there"));

   434     QVERIFY(!myvec.isEmpty());

   435 

   436     // empty again

   437     myvec.remove(0);

   438     QVERIFY(myvec.isEmpty());

   439 }

   440 

   441 void tst_QVector::last() const

   442 {

   443     QVector<QString> myvec;

   444     myvec << "A" << "B" << "C";

   445 

   446     // test starts ok

   447     QCOMPARE(myvec.last(), QLatin1String("C"));

   448 

   449     // test it changes ok

   450     myvec.append(QLatin1String("X"));

   451     QCOMPARE(myvec.last(), QLatin1String("X"));

   452 

   453     // and remove again

   454     myvec.remove(3);

   455     QCOMPARE(myvec.last(), QLatin1String("C"));

   456 }

   457 

   458 void tst_QVector::lastIndexOf() const

   459 {

   460     QVector<QString> myvec;

   461     myvec << "A" << "B" << "C" << "B" << "A";

   462 

   463     QVERIFY(myvec.lastIndexOf("B") == 3);

   464     QVERIFY(myvec.lastIndexOf("B", 2) == 1);

   465     QVERIFY(myvec.lastIndexOf("X") == -1);

   466     QVERIFY(myvec.lastIndexOf("X", 2) == -1);

   467 

   468     // add an X

   469     myvec << "X";

   470     QVERIFY(myvec.lastIndexOf("X") == 5);

   471     QVERIFY(myvec.lastIndexOf("X", 5) == 5);

   472     QVERIFY(myvec.lastIndexOf("X", 3) == -1);

   473 

   474     // remove first A

   475     myvec.remove(0);

   476     QVERIFY(myvec.lastIndexOf("A") == 3);

   477     QVERIFY(myvec.lastIndexOf("A", 3) == 3);

   478     QVERIFY(myvec.lastIndexOf("A", 2) == -1);

   479 }

   480 

   481 void tst_QVector::mid() const

   482 {

   483     QVector<QString> list;

   484     list << "foo" << "bar" << "baz" << "bak" << "buck" << "hello" << "kitty";

   485 

   486     QCOMPARE(list.mid(3, 3), QVector<QString>() << "bak" << "buck" << "hello");

   487     QCOMPARE(list.mid(4), QVector<QString>() << "buck" << "hello" << "kitty");

   488 }

   489 

   490 void tst_QVector::prepend() const

   491 {

   492     QVector<QString> myvec;

   493     myvec << "A" << "B" << "C";

   494 

   495     // starts ok

   496     QVERIFY(myvec.size() == 3);

   497     QCOMPARE(myvec.at(0), QLatin1String("A"));

   498 

   499     // add something

   500     myvec.prepend(QLatin1String("X"));

   501     QCOMPARE(myvec.at(0), QLatin1String("X"));

   502     QCOMPARE(myvec.at(1), QLatin1String("A"));

   503     QVERIFY(myvec.size() == 4);

   504 

   505     // something else

   506     myvec.prepend(QLatin1String("Z"));

   507     QCOMPARE(myvec.at(0), QLatin1String("Z"));

   508     QCOMPARE(myvec.at(1), QLatin1String("X"));

   509     QCOMPARE(myvec.at(2), QLatin1String("A"));

   510     QVERIFY(myvec.size() == 5);

   511 

   512     // clear and append to an empty vector

   513     myvec.clear();

   514     QVERIFY(myvec.size() == 0);

   515     myvec.prepend(QLatin1String("ninjas"));

   516     QVERIFY(myvec.size() == 1);

   517     QCOMPARE(myvec.at(0), QLatin1String("ninjas"));

   518 }

   519 

   520 void tst_QVector::remove() const

   521 {

   522     QVector<QString> myvec;

   523     myvec << "A" << "B" << "C";

   524 

   525     // remove middle

   526     myvec.remove(1);

   527     QCOMPARE(myvec, QVector<QString>() << "A" << "C");

   528 

   529     // remove rest

   530     myvec.remove(0, 2);

   531     QCOMPARE(myvec, QVector<QString>());

   532 }

   533 

   534 // ::reserve() is really hard to think of tests for, so not doing it.

   535 // ::resize() is tested in ::capacity().

   536 

   537 void tst_QVector::size() const

   538 {

   539     // total size

   540     {

   541         // zero size

   542         QVector<int> myvec;

   543         QVERIFY(myvec.size() == 0);

   544 

   545         // grow

   546         myvec.append(42);

   547         QVERIFY(myvec.size() == 1);

   548         myvec.append(42);

   549         QVERIFY(myvec.size() == 2);

   550 

   551         // shrink

   552         myvec.remove(0);

   553         QVERIFY(myvec.size() == 1);

   554         myvec.remove(0);

   555         QVERIFY(myvec.size() == 0);

   556     }

   557 }

   558 

   559 // ::squeeze() is tested in ::capacity().

   560 

   561 void tst_QVector::startsWith() const

   562 {

   563     QVector<int> myvec;

   564 

   565     // empty vector

   566     QVERIFY(!myvec.startsWith(1));

   567 

   568     // add the one, should work

   569     myvec.prepend(1);

   570     QVERIFY(myvec.startsWith(1));

   571 

   572     // add something else, fails now

   573     myvec.prepend(3);

   574     QVERIFY(!myvec.startsWith(1));

   575 

   576     // remove it again :)

   577     myvec.remove(0);

   578     QVERIFY(myvec.startsWith(1));

   579 }

   580 

   581 void tst_QVector::toList() const

   582 {

   583     QVector<QString> myvec;

   584     myvec << "A" << "B" << "C";

   585 

   586     // make sure it converts and doesn't modify the original vector

   587     QCOMPARE(myvec.toList(), QList<QString>() << "A" << "B" << "C");

   588     QCOMPARE(myvec, QVector<QString>() << "A" << "B" << "C");

   589 }

   590 

   591 void tst_QVector::toStdVector() const

   592 {

   593     QVector<QString> myvec;

   594     myvec << "A" << "B" << "C";

   595 

   596     std::vector<QString> svec = myvec.toStdVector();

   597     QCOMPARE(svec.at(0), QLatin1String("A"));

   598     QCOMPARE(svec.at(1), QLatin1String("B"));

   599     QCOMPARE(svec.at(2), QLatin1String("C"));

   600 

   601     QCOMPARE(myvec, QVector<QString>() << "A" << "B" << "C");

   602 }

   603 

   604 void tst_QVector::value() const

   605 {

   606     QVector<QString> myvec;

   607     myvec << "A" << "B" << "C";

   608 

   609     // valid calls

   610     QCOMPARE(myvec.value(0), QLatin1String("A"));

   611     QCOMPARE(myvec.value(1), QLatin1String("B"));

   612     QCOMPARE(myvec.value(2), QLatin1String("C"));

   613 

   614     // default calls

   615     QCOMPARE(myvec.value(-1), QString());

   616     QCOMPARE(myvec.value(3), QString());

   617 

   618     // test calls with a provided default, valid calls

   619     QCOMPARE(myvec.value(0, QLatin1String("default")), QLatin1String("A"));

   620     QCOMPARE(myvec.value(1, QLatin1String("default")), QLatin1String("B"));

   621     QCOMPARE(myvec.value(2, QLatin1String("default")), QLatin1String("C"));

   622 

   623     // test calls with a provided default that will return the default

   624     QCOMPARE(myvec.value(-1, QLatin1String("default")), QLatin1String("default"));

   625     QCOMPARE(myvec.value(3, QLatin1String("default")), QLatin1String("default"));

   626 }

   627 

   628 void tst_QVector::testOperators() const

   629 {

   630     QVector<QString> myvec;

   631     myvec << "A" << "B" << "C";

   632     QVector<QString> myvectwo;

   633     myvectwo << "D" << "E" << "F";

   634     QVector<QString> combined;

   635     combined << "A" << "B" << "C" << "D" << "E" << "F";

   636 

   637     // !=

   638     QVERIFY(myvec != myvectwo);

   639 

   640     // +

   641     QCOMPARE(myvec + myvectwo, combined);

   642     QCOMPARE(myvec, QVector<QString>() << "A" << "B" << "C");

   643     QCOMPARE(myvectwo, QVector<QString>() << "D" << "E" << "F");

   644 

   645     // +=

   646     myvec += myvectwo;

   647     QCOMPARE(myvec, combined);

   648 

   649     // ==

   650     QVERIFY(myvec == combined);

   651 

   652     // []

   653     QCOMPARE(myvec[0], QLatin1String("A"));

   654     QCOMPARE(myvec[1], QLatin1String("B"));

   655     QCOMPARE(myvec[2], QLatin1String("C"));

   656     QCOMPARE(myvec[3], QLatin1String("D"));

   657     QCOMPARE(myvec[4], QLatin1String("E"));

   658     QCOMPARE(myvec[5], QLatin1String("F"));

   659 }

   660