1/****************************************************************************
2**
3** Copyright (C) 2016 The Qt Company Ltd.
4** Copyright (C) 2014 by Southwest Research Institute (R)
5** Contact: https://www.qt.io/licensing/
6**
7** This file is part of the QtCore module of the Qt Toolkit.
8**
9** $QT_BEGIN_LICENSE:GPL-EXCEPT$
10** Commercial License Usage
11** Licensees holding valid commercial Qt licenses may use this file in
12** accordance with the commercial license agreement provided with the
13** Software or, alternatively, in accordance with the terms contained in
14** a written agreement between you and The Qt Company. For licensing terms
15** and conditions see https://www.qt.io/terms-conditions. For further
16** information use the contact form at https://www.qt.io/contact-us.
17**
18** GNU General Public License Usage
19** Alternatively, this file may be used under the terms of the GNU
20** General Public License version 3 as published by the Free Software
21** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
22** included in the packaging of this file. Please review the following
23** information to ensure the GNU General Public License requirements will
24** be met: https://www.gnu.org/licenses/gpl-3.0.html.
25**
26** $QT_END_LICENSE$
27**
28****************************************************************************/
29
30#include <QtTest/QtTest>
31#include <qbytearraylist.h>
32
33#include <qmetatype.h>
34
35Q_DECLARE_METATYPE(QByteArrayList)
36
37class tst_QByteArrayList : public QObject
38{
39 Q_OBJECT
40private slots:
41 void join() const;
42 void join_data() const;
43 void joinByteArray() const;
44 void joinByteArray_data() const;
45 void joinChar() const;
46 void joinChar_data() const;
47 void joinEmptiness() const;
48
49 void operator_plus() const;
50 void operator_plus_data() const;
51
52 void indexOf_data() const;
53 void indexOf() const;
54
55 void initializerList() const;
56};
57
58void tst_QByteArrayList::join() const
59{
60 QFETCH(QByteArrayList, input);
61 QFETCH(QByteArray, expectedResult);
62
63 QCOMPARE(input.join(), expectedResult);
64}
65
66void tst_QByteArrayList::join_data() const
67{
68 QTest::addColumn<QByteArrayList>(name: "input");
69 QTest::addColumn<QByteArray>(name: "expectedResult");
70
71 QTest::newRow(dataTag: "data1") << QByteArrayList()
72 << QByteArray();
73
74 QTest::newRow(dataTag: "data2") << (QByteArrayList() << "one")
75 << QByteArray("one");
76
77 QTest::newRow(dataTag: "data3") << (QByteArrayList() << "a" << "b")
78 << QByteArray("ab");
79
80 QTest::newRow(dataTag: "data4") << (QByteArrayList() << "a" << "b" << "c")
81 << QByteArray("abc");
82}
83
84void tst_QByteArrayList::joinByteArray() const
85{
86 QFETCH(QByteArrayList, input);
87 QFETCH(QByteArray, separator);
88 QFETCH(QByteArray, expectedResult);
89
90 QCOMPARE(input.join(separator), expectedResult);
91}
92
93void tst_QByteArrayList::joinByteArray_data() const
94{
95 QTest::addColumn<QByteArrayList>(name: "input");
96 QTest::addColumn<QByteArray>(name: "separator");
97 QTest::addColumn<QByteArray>(name: "expectedResult");
98
99 QTest::newRow(dataTag: "data1") << QByteArrayList()
100 << QByteArray()
101 << QByteArray();
102
103 QTest::newRow(dataTag: "data2") << QByteArrayList()
104 << QByteArray("separator")
105 << QByteArray();
106
107 QTest::newRow(dataTag: "data3") << (QByteArrayList() << "one")
108 << QByteArray("separator")
109 << QByteArray("one");
110
111 QTest::newRow(dataTag: "data4") << (QByteArrayList() << "a" << "b")
112 << QByteArray(" ")
113 << QByteArray("a b");
114
115 QTest::newRow(dataTag: "data5") << (QByteArrayList() << "a" << "b" << "c")
116 << QByteArray(" ")
117 << QByteArray("a b c");
118
119 QTest::newRow(dataTag: "data6") << (QByteArrayList() << "a" << "b" << "c")
120 << QByteArray()
121 << QByteArray("abc");
122
123 QTest::newRow(dataTag: "data7") << (QByteArrayList() << "a" << "b" << "c")
124 << QByteArray("") //empty
125 << QByteArray("abc");
126}
127
128void tst_QByteArrayList::joinChar() const
129{
130 QFETCH(QByteArrayList, input);
131 QFETCH(char, separator);
132 QFETCH(QByteArray, expectedResult);
133
134 QCOMPARE(input.join(separator), expectedResult);
135}
136
137void tst_QByteArrayList::joinChar_data() const
138{
139 QTest::addColumn<QByteArrayList>(name: "input");
140 QTest::addColumn<char>(name: "separator");
141 QTest::addColumn<QByteArray>(name: "expectedResult");
142
143 QTest::newRow(dataTag: "data1") << QByteArrayList()
144 << ' '
145 << QByteArray();
146
147 QTest::newRow(dataTag: "data2") << (QByteArrayList() << "a a" << "b")
148 << ' '
149 << QByteArray("a a b");
150
151 QTest::newRow(dataTag: "data3") << (QByteArrayList() << "a" << "b" << "c c")
152 << ' '
153 << QByteArray("a b c c");
154}
155
156void tst_QByteArrayList::joinEmptiness() const
157{
158 QByteArrayList list;
159 QByteArray string = list.join(sep: QByteArray());
160
161 QVERIFY(string.isEmpty());
162 QVERIFY(string.isNull());
163}
164
165void tst_QByteArrayList::operator_plus() const
166{
167 QFETCH(QByteArrayList, lhs);
168 QFETCH(QByteArrayList, rhs);
169 QFETCH(QByteArrayList, expectedResult);
170
171 // operator+ for const lvalues
172 {
173 const QByteArrayList bal1 = lhs;
174 const QByteArrayList bal2 = rhs;
175 QCOMPARE(bal1 + bal2, expectedResult);
176 }
177 {
178 const QList<QByteArray> lba1 = lhs;
179 const QByteArrayList bal2 = rhs;
180 QCOMPARE(lba1 + bal2, expectedResult);
181 }
182 {
183 const QByteArrayList bal1 = lhs;
184 const QList<QByteArray> lba2 = rhs;
185 QCOMPARE(bal1 + lba2, expectedResult);
186 }
187 {
188 const QList<QByteArray> lba1 = lhs;
189 const QList<QByteArray> lba2 = rhs;
190 QCOMPARE(lba1 + lba2, QList<QByteArray>(expectedResult)); // check we don't mess with old code
191 }
192
193 // operator+ for rvalues (only lhs)
194 {
195 QByteArrayList bal1 = lhs;
196 const QByteArrayList bal2 = rhs;
197 QCOMPARE(std::move(bal1) + bal2, expectedResult);
198 }
199 {
200 QList<QByteArray> lba1 = lhs;
201 const QByteArrayList bal2 = rhs;
202 QCOMPARE(std::move(lba1) + bal2, expectedResult);
203 }
204 {
205 QByteArrayList bal1 = lhs;
206 const QList<QByteArray> lba2 = rhs;
207 QCOMPARE(std::move(bal1) + lba2, expectedResult);
208 }
209 {
210 QList<QByteArray> lba1 = lhs;
211 const QList<QByteArray> lba2 = rhs;
212 QCOMPARE(std::move(lba1) + lba2, QList<QByteArray>(expectedResult)); // check we don't mess with old code
213 }
214
215 // operator += for const lvalues
216 {
217 QByteArrayList bal1 = lhs;
218 const QByteArrayList bal2 = rhs;
219 QCOMPARE(bal1 += bal2, expectedResult);
220 }
221 {
222 QByteArrayList bal1 = lhs;
223 const QList<QByteArray> lba2 = rhs;
224 QCOMPARE(bal1 += lba2, expectedResult);
225 }
226 {
227 QList<QByteArray> lba1 = lhs;
228 const QByteArrayList bal2 = rhs;
229 QCOMPARE(lba1 += bal2, QList<QByteArray>(expectedResult));
230 }
231
232 QByteArrayList t1 = lhs;
233 QByteArrayList t2 = rhs;
234
235 QCOMPARE(std::move(t1) + t2, expectedResult);
236}
237
238void tst_QByteArrayList::operator_plus_data() const
239{
240 QTest::addColumn<QByteArrayList>(name: "lhs");
241 QTest::addColumn<QByteArrayList>(name: "rhs");
242 QTest::addColumn<QByteArrayList>(name: "expectedResult");
243
244 QTest::newRow(dataTag: "simpl") << ( QByteArrayList() << "a" )
245 << ( QByteArrayList() << "b" << "c" )
246 << ( QByteArrayList() << "a" << "b" << "c" );
247
248 QTest::newRow(dataTag: "blank1") << QByteArrayList()
249 << QByteArrayList()
250 << QByteArrayList();
251
252 QTest::newRow(dataTag: "blank2") << ( QByteArrayList() )
253 << ( QByteArrayList() << "b" << "c" )
254 << ( QByteArrayList() << "b" << "c" );
255
256 QTest::newRow(dataTag: "empty1") << ( QByteArrayList() << "" )
257 << ( QByteArrayList() << "b" << "c" )
258 << ( QByteArrayList() << "" << "b" << "c" );
259
260 QTest::newRow(dataTag: "empty2") << ( QByteArrayList() << "a" )
261 << ( QByteArrayList() << "" << "c" )
262 << ( QByteArrayList() << "a" << "" << "c" );
263}
264
265void tst_QByteArrayList::indexOf_data() const
266{
267 QTest::addColumn<QByteArrayList>(name: "list");
268 QTest::addColumn<QByteArray>(name: "item");
269 QTest::addColumn<int>(name: "expectedResult");
270
271 QTest::newRow(dataTag: "empty") << QByteArrayList() << QByteArray("a") << -1;
272 QTest::newRow(dataTag: "found_1") << ( QByteArrayList() << "a" ) << QByteArray("a") << 0;
273 QTest::newRow(dataTag: "not_found_1") << ( QByteArrayList() << "a" ) << QByteArray("b") << -1;
274 QTest::newRow(dataTag: "found_2") << ( QByteArrayList() << "hello" << "world" ) << QByteArray("world") << 1;
275 QTest::newRow(dataTag: "returns_first") << ( QByteArrayList() << "hello" << "world" << "hello" << "again" ) << QByteArray("hello") << 0;
276}
277
278void tst_QByteArrayList::indexOf() const
279{
280 QFETCH(QByteArrayList, list);
281 QFETCH(QByteArray, item);
282 QFETCH(int, expectedResult);
283
284 QCOMPARE(list.indexOf(item), expectedResult);
285 QCOMPARE(list.indexOf(item.constData()), expectedResult);
286}
287
288void tst_QByteArrayList::initializerList() const
289{
290 // constructor
291 QByteArrayList v1 = {QByteArray("hello"),"world",QByteArray("plop")};
292 QCOMPARE(v1, (QByteArrayList() << "hello" << "world" << "plop"));
293 QCOMPARE(v1, (QByteArrayList{"hello","world","plop"}));
294 // assignment operator (through implicit temporary)
295 QByteArrayList v2;
296 v2 = {QByteArray("hello"),"world",QByteArray("plop")};
297 QCOMPARE(v2, v1);
298}
299
300QTEST_APPLESS_MAIN(tst_QByteArrayList)
301#include "tst_qbytearraylist.moc"
302

source code of qtbase/tests/auto/corelib/text/qbytearraylist/tst_qbytearraylist.cpp