← Back to branch summary

~ubuntu-branches/ubuntu/wily/qtbase-opensource-src/wily

« back to all changes in this revision

Viewing changes to tests/auto/corelib/tools/qbitarray/tst_qbitarray.cpp

  • Committer: Package Import Robot
  • Author(s): Timo Jyrinki
  • Date: 2013-02-05 12:46:17 UTC
  • Revision ID: package-import@ubuntu.com-20130205124617-c8jouts182j002fx
Tags: upstream-5.0.1+dfsg
Import upstream version 5.0.1+dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/auto/corelib/tools/qbitarray/tst_qbitarray.cpp
 
1
/****************************************************************************
 
2
**
 
3
** Copyright (C) 2012 Digia Plc and/or its subsidiary(-ies).
 
4
** Contact: http://www.qt-project.org/legal
 
5
**
 
6
** This file is part of the test suite of the Qt Toolkit.
 
7
**
 
8
** $QT_BEGIN_LICENSE:LGPL$
 
9
** Commercial License Usage
 
10
** Licensees holding valid commercial Qt licenses may use this file in
 
11
** accordance with the commercial license agreement provided with the
 
12
** Software or, alternatively, in accordance with the terms contained in
 
13
** a written agreement between you and Digia.  For licensing terms and
 
14
** conditions see http://qt.digia.com/licensing.  For further information
 
15
** use the contact form at http://qt.digia.com/contact-us.
 
16
**
 
17
** GNU Lesser General Public License Usage
 
18
** Alternatively, this file may be used under the terms of the GNU Lesser
 
19
** General Public License version 2.1 as published by the Free Software
 
20
** Foundation and appearing in the file LICENSE.LGPL included in the
 
21
** packaging of this file.  Please review the following information to
 
22
** ensure the GNU Lesser General Public License version 2.1 requirements
 
23
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 
24
**
 
25
** In addition, as a special exception, Digia gives you certain additional
 
26
** rights.  These rights are described in the Digia Qt LGPL Exception
 
27
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 
28
**
 
29
** GNU General Public License Usage
 
30
** Alternatively, this file may be used under the terms of the GNU
 
31
** General Public License version 3.0 as published by the Free Software
 
32
** Foundation and appearing in the file LICENSE.GPL included in the
 
33
** packaging of this file.  Please review the following information to
 
34
** ensure the GNU General Public License version 3.0 requirements will be
 
35
** met: http://www.gnu.org/copyleft/gpl.html.
 
36
**
 
37
**
 
38
** $QT_END_LICENSE$
 
39
**
 
40
****************************************************************************/
 
41
 
 
42
#include <QtTest/QtTest>
 
43
#include <QtCore/QBuffer>
 
44
#include <QtCore/QDataStream>
 
45
 
 
46
#include "qbitarray.h"
 
47
 
 
48
/**
 
49
 * Helper function to initialize a bitarray from a string
 
50
 */
 
51
static QBitArray QStringToQBitArray(const QString &str)
 
52
{
 
53
    QBitArray ba;
 
54
    ba.resize(str.length());
 
55
    int i;
 
56
    QChar tru('1');
 
57
    for (i = 0; i < str.length(); i++)
 
58
    {
 
59
        if (str.at(i) == tru)
 
60
        {
 
61
            ba.setBit(i, true);
 
62
        }
 
63
    }
 
64
    return ba;
 
65
}
 
66
 
 
67
class tst_QBitArray : public QObject
 
68
{
 
69
    Q_OBJECT
 
70
private slots:
 
71
    void size_data();
 
72
    void size();
 
73
    void countBits_data();
 
74
    void countBits();
 
75
    void countBits2();
 
76
    void isEmpty();
 
77
    void swap();
 
78
    void fill();
 
79
    void toggleBit_data();
 
80
    void toggleBit();
 
81
    // operator &=
 
82
    void operator_andeq_data();
 
83
    void operator_andeq();
 
84
    // operator |=
 
85
    void operator_oreq_data();
 
86
    void operator_oreq();
 
87
    // operator ^=
 
88
    void operator_xoreq_data();
 
89
    void operator_xoreq();
 
90
    // operator ~
 
91
    void operator_neg_data();
 
92
    void operator_neg();
 
93
    void datastream_data();
 
94
    void datastream();
 
95
    void invertOnNull() const;
 
96
    void operator_noteq_data();
 
97
    void operator_noteq();
 
98
 
 
99
    void resize();
 
100
};
 
101
 
 
102
void tst_QBitArray::size_data()
 
103
{
 
104
    //create the testtable instance and define the elements
 
105
    QTest::addColumn<int>("count");
 
106
    QTest::addColumn<QString>("res");
 
107
 
 
108
    //next we fill it with data
 
109
    QTest::newRow( "data0" )  << 1 << QString("1");
 
110
    QTest::newRow( "data1" )  << 2 << QString("11");
 
111
    QTest::newRow( "data2" )  << 3 << QString("111");
 
112
    QTest::newRow( "data3" )  << 9 << QString("111111111");
 
113
    QTest::newRow( "data4" )  << 10 << QString("1111111111");
 
114
    QTest::newRow( "data5" )  << 17 << QString("11111111111111111");
 
115
    QTest::newRow( "data6" )  << 18 << QString("111111111111111111");
 
116
    QTest::newRow( "data7" )  << 19 << QString("1111111111111111111");
 
117
    QTest::newRow( "data8" )  << 20 << QString("11111111111111111111");
 
118
    QTest::newRow( "data9" )  << 21 << QString("111111111111111111111");
 
119
    QTest::newRow( "data10" )  << 22 << QString("1111111111111111111111");
 
120
    QTest::newRow( "data11" )  << 23 << QString("11111111111111111111111");
 
121
    QTest::newRow( "data12" )  << 24 << QString("111111111111111111111111");
 
122
    QTest::newRow( "data13" )  << 25 << QString("1111111111111111111111111");
 
123
    QTest::newRow( "data14" )  << 32 << QString("11111111111111111111111111111111");
 
124
}
 
125
 
 
126
void tst_QBitArray::size()
 
127
{
 
128
    QFETCH(int,count);
 
129
 
 
130
    QString S;
 
131
    QBitArray a(count);
 
132
    a.fill(1);
 
133
    int len = a.size();
 
134
    for (int j=0; j<len; j++) {
 
135
        bool b = a[j];
 
136
        if (b)
 
137
            S+= "1";
 
138
        else
 
139
            S+= "0";
 
140
    }
 
141
    QTEST(S,"res");
 
142
}
 
143
 
 
144
void tst_QBitArray::countBits_data()
 
145
{
 
146
    QTest::addColumn<QString>("bitField");
 
147
    QTest::addColumn<int>("numBits");
 
148
    QTest::addColumn<int>("onBits");
 
149
 
 
150
    QTest::newRow("empty") << QString() << 0 << 0;
 
151
    QTest::newRow("1") << QString("1") << 1 << 1;
 
152
    QTest::newRow("101") << QString("101") << 3 << 2;
 
153
    QTest::newRow("101100001") << QString("101100001") << 9 << 4;
 
154
    QTest::newRow("101100001101100001") << QString("101100001101100001") << 18 << 8;
 
155
    QTest::newRow("101100001101100001101100001101100001") << QString("101100001101100001101100001101100001") << 36 << 16;
 
156
    QTest::newRow("00000000000000000000000000000000000") << QString("00000000000000000000000000000000000") << 35 << 0;
 
157
    QTest::newRow("11111111111111111111111111111111111") << QString("11111111111111111111111111111111111") << 35 << 35;
 
158
    QTest::newRow("11111111111111111111111111111111") << QString("11111111111111111111111111111111") << 32 << 32;
 
159
    QTest::newRow("11111111111111111111111111111111111111111111111111111111")
 
160
        << QString("11111111111111111111111111111111111111111111111111111111") << 56 << 56;
 
161
    QTest::newRow("00000000000000000000000000000000000") << QString("00000000000000000000000000000000000") << 35 << 0;
 
162
    QTest::newRow("00000000000000000000000000000000") << QString("00000000000000000000000000000000") << 32 << 0;
 
163
    QTest::newRow("00000000000000000000000000000000000000000000000000000000")
 
164
        << QString("00000000000000000000000000000000000000000000000000000000") << 56 << 0;
 
165
}
 
166
 
 
167
void tst_QBitArray::countBits()
 
168
{
 
169
    QFETCH(QString, bitField);
 
170
    QFETCH(int, numBits);
 
171
    QFETCH(int, onBits);
 
172
 
 
173
    QBitArray bits(bitField.size());
 
174
    for (int i = 0; i < bitField.size(); ++i) {
 
175
        if (bitField.at(i) == QLatin1Char('1'))
 
176
            bits.setBit(i);
 
177
    }
 
178
 
 
179
    QCOMPARE(bits.count(), numBits);
 
180
    QCOMPARE(bits.count(true), onBits);
 
181
    QCOMPARE(bits.count(false), numBits - onBits);
 
182
}
 
183
 
 
184
void tst_QBitArray::countBits2()
 
185
{
 
186
    QBitArray bitArray;
 
187
    for (int i = 0; i < 4017; ++i) {
 
188
        bitArray.resize(i);
 
189
        bitArray.fill(true);
 
190
        QCOMPARE(bitArray.count(true), i);
 
191
        QCOMPARE(bitArray.count(false), 0);
 
192
        bitArray.fill(false);
 
193
        QCOMPARE(bitArray.count(true), 0);
 
194
        QCOMPARE(bitArray.count(false), i);
 
195
    }
 
196
}
 
197
 
 
198
void tst_QBitArray::isEmpty()
 
199
{
 
200
    QBitArray a1;
 
201
    QVERIFY(a1.isEmpty());
 
202
    QVERIFY(a1.isNull());
 
203
    QVERIFY(a1.size() == 0);
 
204
 
 
205
    QBitArray a2(0, true);
 
206
    QVERIFY(a2.isEmpty());
 
207
    QVERIFY(!a2.isNull());
 
208
    QVERIFY(a2.size() == 0);
 
209
 
 
210
    QBitArray a3(1, true);
 
211
    QVERIFY(!a3.isEmpty());
 
212
    QVERIFY(!a3.isNull());
 
213
    QVERIFY(a3.size() == 1);
 
214
 
 
215
    a1.resize(0);
 
216
    QVERIFY(a1.isEmpty());
 
217
    QVERIFY(!a1.isNull());
 
218
    QVERIFY(a1.size() == 0);
 
219
 
 
220
    a2.resize(0);
 
221
    QVERIFY(a2.isEmpty());
 
222
    QVERIFY(!a2.isNull());
 
223
    QVERIFY(a2.size() == 0);
 
224
 
 
225
    a1.resize(1);
 
226
    QVERIFY(!a1.isEmpty());
 
227
    QVERIFY(!a1.isNull());
 
228
    QVERIFY(a1.size() == 1);
 
229
 
 
230
    a1.resize(2);
 
231
    QVERIFY(!a1.isEmpty());
 
232
    QVERIFY(!a1.isNull());
 
233
    QVERIFY(a1.size() == 2);
 
234
}
 
235
 
 
236
void tst_QBitArray::swap()
 
237
{
 
238
    QBitArray b1 = QStringToQBitArray("1"), b2 = QStringToQBitArray("10");
 
239
    b1.swap(b2);
 
240
    QCOMPARE(b1,QStringToQBitArray("10"));
 
241
    QCOMPARE(b2,QStringToQBitArray("1"));
 
242
}
 
243
 
 
244
void tst_QBitArray::fill()
 
245
{
 
246
    int N = 64;
 
247
    int M = 17;
 
248
    QBitArray a(N, false);
 
249
    int i, j;
 
250
 
 
251
    for (i = 0; i < N-M; ++i) {
 
252
        a.fill(true, i, i + M);
 
253
        for (j = 0; j < N; ++j) {
 
254
            if (j >= i && j < i + M) {
 
255
                QVERIFY(a.at(j));
 
256
            } else {
 
257
                QVERIFY(!a.at(j));
 
258
            }
 
259
        }
 
260
        a.fill(false, i, i + M);
 
261
    }
 
262
    for (i = 0; i < N; ++i)
 
263
        a.fill(i % 2 == 0, i, i + 1);
 
264
    for (i = 0; i < N; ++i) {
 
265
        QVERIFY(a.at(i) == (i % 2 == 0));
 
266
    }
 
267
}
 
268
 
 
269
void tst_QBitArray::toggleBit_data()
 
270
{
 
271
    QTest::addColumn<int>("index");
 
272
    QTest::addColumn<QBitArray>("input");
 
273
    QTest::addColumn<QBitArray>("res");
 
274
    // 8 bits, toggle first bit
 
275
    QTest::newRow( "data0" )  << 0 << QStringToQBitArray(QString("11111111")) << QStringToQBitArray(QString("01111111"));
 
276
    // 8 bits
 
277
    QTest::newRow( "data1" )  << 1 << QStringToQBitArray(QString("11111111")) << QStringToQBitArray(QString("10111111"));
 
278
    // 11 bits, toggle last bit
 
279
    QTest::newRow( "data2" )  << 10 << QStringToQBitArray(QString("11111111111")) << QStringToQBitArray(QString("11111111110"));
 
280
 
 
281
}
 
282
 
 
283
void tst_QBitArray::toggleBit()
 
284
{
 
285
    QFETCH(int,index);
 
286
    QFETCH(QBitArray, input);
 
287
    QFETCH(QBitArray, res);
 
288
 
 
289
    input.toggleBit(index);
 
290
 
 
291
    QCOMPARE(input, res);
 
292
}
 
293
 
 
294
void tst_QBitArray::operator_andeq_data()
 
295
{
 
296
    QTest::addColumn<QBitArray>("input1");
 
297
    QTest::addColumn<QBitArray>("input2");
 
298
    QTest::addColumn<QBitArray>("res");
 
299
 
 
300
    QTest::newRow( "data0" )   << QStringToQBitArray(QString("11111111"))
 
301
                            << QStringToQBitArray(QString("00101100"))
 
302
                            << QStringToQBitArray(QString("00101100"));
 
303
 
 
304
 
 
305
    QTest::newRow( "data1" )   << QStringToQBitArray(QString("11011011"))
 
306
                            << QStringToQBitArray(QString("00101100"))
 
307
                            << QStringToQBitArray(QString("00001000"));
 
308
 
 
309
    QTest::newRow( "data2" )   << QStringToQBitArray(QString("11011011111"))
 
310
                            << QStringToQBitArray(QString("00101100"))
 
311
                            << QStringToQBitArray(QString("00001000000"));
 
312
 
 
313
    QTest::newRow( "data3" )   << QStringToQBitArray(QString("11011011"))
 
314
                            << QStringToQBitArray(QString("00101100111"))
 
315
                            << QStringToQBitArray(QString("00001000000"));
 
316
 
 
317
    QTest::newRow( "data4" )   << QStringToQBitArray(QString())
 
318
                            << QStringToQBitArray(QString("00101100111"))
 
319
                            << QStringToQBitArray(QString("00000000000"));
 
320
 
 
321
    QTest::newRow( "data5" ) << QStringToQBitArray(QString("00101100111"))
 
322
                             << QStringToQBitArray(QString())
 
323
                             << QStringToQBitArray(QString("00000000000"));
 
324
 
 
325
    QTest::newRow( "data6" ) << QStringToQBitArray(QString())
 
326
                             << QStringToQBitArray(QString())
 
327
                             << QStringToQBitArray(QString());
 
328
}
 
329
 
 
330
void tst_QBitArray::operator_andeq()
 
331
{
 
332
    QFETCH(QBitArray, input1);
 
333
    QFETCH(QBitArray, input2);
 
334
    QFETCH(QBitArray, res);
 
335
 
 
336
    input1&=input2;
 
337
 
 
338
    QCOMPARE(input1, res);
 
339
}
 
340
 
 
341
void tst_QBitArray::operator_oreq_data()
 
342
{
 
343
    QTest::addColumn<QBitArray>("input1");
 
344
    QTest::addColumn<QBitArray>("input2");
 
345
    QTest::addColumn<QBitArray>("res");
 
346
 
 
347
    QTest::newRow( "data0" )   << QStringToQBitArray(QString("11111111"))
 
348
                            << QStringToQBitArray(QString("00101100"))
 
349
                            << QStringToQBitArray(QString("11111111"));
 
350
 
 
351
 
 
352
    QTest::newRow( "data1" )   << QStringToQBitArray(QString("11011011"))
 
353
                            << QStringToQBitArray(QString("00101100"))
 
354
                            << QStringToQBitArray(QString("11111111"));
 
355
 
 
356
    QTest::newRow( "data2" )   << QStringToQBitArray(QString("01000010"))
 
357
                            << QStringToQBitArray(QString("10100001"))
 
358
                            << QStringToQBitArray(QString("11100011"));
 
359
 
 
360
    QTest::newRow( "data3" )   << QStringToQBitArray(QString("11011011"))
 
361
                            << QStringToQBitArray(QString("00101100000"))
 
362
                            << QStringToQBitArray(QString("11111111000"));
 
363
 
 
364
    QTest::newRow( "data4" )   << QStringToQBitArray(QString("11011011111"))
 
365
                            << QStringToQBitArray(QString("00101100"))
 
366
                            << QStringToQBitArray(QString("11111111111"));
 
367
 
 
368
    QTest::newRow( "data5" )   << QStringToQBitArray(QString())
 
369
                            << QStringToQBitArray(QString("00101100111"))
 
370
                            << QStringToQBitArray(QString("00101100111"));
 
371
 
 
372
    QTest::newRow( "data6" ) << QStringToQBitArray(QString("00101100111"))
 
373
                             << QStringToQBitArray(QString())
 
374
                             << QStringToQBitArray(QString("00101100111"));
 
375
 
 
376
    QTest::newRow( "data7" ) << QStringToQBitArray(QString())
 
377
                             << QStringToQBitArray(QString())
 
378
                             << QStringToQBitArray(QString());
 
379
}
 
380
 
 
381
void tst_QBitArray::operator_oreq()
 
382
{
 
383
    QFETCH(QBitArray, input1);
 
384
    QFETCH(QBitArray, input2);
 
385
    QFETCH(QBitArray, res);
 
386
 
 
387
    input1|=input2;
 
388
 
 
389
    QCOMPARE(input1, res);
 
390
}
 
391
 
 
392
void tst_QBitArray::operator_xoreq_data()
 
393
{
 
394
    QTest::addColumn<QBitArray>("input1");
 
395
    QTest::addColumn<QBitArray>("input2");
 
396
    QTest::addColumn<QBitArray>("res");
 
397
    QTest::newRow( "data0" )   << QStringToQBitArray(QString("11111111"))
 
398
                            << QStringToQBitArray(QString("00101100"))
 
399
                            << QStringToQBitArray(QString("11010011"));
 
400
 
 
401
    QTest::newRow( "data1" )   << QStringToQBitArray(QString("11011011"))
 
402
                            << QStringToQBitArray(QString("00101100"))
 
403
                            << QStringToQBitArray(QString("11110111"));
 
404
 
 
405
    QTest::newRow( "data2" )   << QStringToQBitArray(QString("01000010"))
 
406
                            << QStringToQBitArray(QString("10100001"))
 
407
                            << QStringToQBitArray(QString("11100011"));
 
408
 
 
409
    QTest::newRow( "data3" )   << QStringToQBitArray(QString("01000010"))
 
410
                            << QStringToQBitArray(QString("10100001101"))
 
411
                            << QStringToQBitArray(QString("11100011101"));
 
412
 
 
413
    QTest::newRow( "data4" )   << QStringToQBitArray(QString("01000010111"))
 
414
                            << QStringToQBitArray(QString("101000011"))
 
415
                            << QStringToQBitArray(QString("11100011011"));
 
416
 
 
417
    QTest::newRow( "data5" )   << QStringToQBitArray(QString())
 
418
                            << QStringToQBitArray(QString("00101100111"))
 
419
                            << QStringToQBitArray(QString("00101100111"));
 
420
 
 
421
    QTest::newRow( "data6" ) << QStringToQBitArray(QString("00101100111"))
 
422
                             << QStringToQBitArray(QString())
 
423
                             << QStringToQBitArray(QString("00101100111"));
 
424
 
 
425
    QTest::newRow( "data7" ) << QStringToQBitArray(QString())
 
426
                             << QStringToQBitArray(QString())
 
427
                             << QStringToQBitArray(QString());
 
428
}
 
429
 
 
430
void tst_QBitArray::operator_xoreq()
 
431
{
 
432
    QFETCH(QBitArray, input1);
 
433
    QFETCH(QBitArray, input2);
 
434
    QFETCH(QBitArray, res);
 
435
 
 
436
    input1^=input2;
 
437
 
 
438
    QCOMPARE(input1, res);
 
439
}
 
440
 
 
441
 
 
442
void tst_QBitArray::operator_neg_data()
 
443
{
 
444
    QTest::addColumn<QBitArray>("input");
 
445
    QTest::addColumn<QBitArray>("res");
 
446
 
 
447
    QTest::newRow( "data0" )   << QStringToQBitArray(QString("11111111"))
 
448
                               << QStringToQBitArray(QString("00000000"));
 
449
 
 
450
    QTest::newRow( "data1" )   << QStringToQBitArray(QString("11011011"))
 
451
                               << QStringToQBitArray(QString("00100100"));
 
452
 
 
453
    QTest::newRow( "data2" )   << QStringToQBitArray(QString("00000000"))
 
454
                               << QStringToQBitArray(QString("11111111"));
 
455
 
 
456
    QTest::newRow( "data3" )   << QStringToQBitArray(QString())
 
457
                               << QStringToQBitArray(QString());
 
458
 
 
459
    QTest::newRow( "data4" )   << QStringToQBitArray("1")
 
460
                               << QStringToQBitArray("0");
 
461
 
 
462
    QTest::newRow( "data5" )   << QStringToQBitArray("0")
 
463
                               << QStringToQBitArray("1");
 
464
 
 
465
    QTest::newRow( "data6" )   << QStringToQBitArray("01")
 
466
                               << QStringToQBitArray("10");
 
467
 
 
468
    QTest::newRow( "data7" )   << QStringToQBitArray("1110101")
 
469
                               << QStringToQBitArray("0001010");
 
470
 
 
471
    QTest::newRow( "data8" )   << QStringToQBitArray("01110101")
 
472
                               << QStringToQBitArray("10001010");
 
473
 
 
474
    QTest::newRow( "data9" )   << QStringToQBitArray("011101010")
 
475
                               << QStringToQBitArray("100010101");
 
476
 
 
477
    QTest::newRow( "data10" )   << QStringToQBitArray("0111010101111010")
 
478
                                << QStringToQBitArray("1000101010000101");
 
479
}
 
480
 
 
481
void tst_QBitArray::operator_neg()
 
482
{
 
483
    QFETCH(QBitArray, input);
 
484
    QFETCH(QBitArray, res);
 
485
 
 
486
    input = ~input;
 
487
 
 
488
    QCOMPARE(input, res);
 
489
}
 
490
 
 
491
void tst_QBitArray::datastream_data()
 
492
{
 
493
    QTest::addColumn<QString>("bitField");
 
494
    QTest::addColumn<int>("numBits");
 
495
    QTest::addColumn<int>("onBits");
 
496
 
 
497
    QTest::newRow("empty") << QString() << 0 << 0;
 
498
    QTest::newRow("1") << QString("1") << 1 << 1;
 
499
    QTest::newRow("101") << QString("101") << 3 << 2;
 
500
    QTest::newRow("101100001") << QString("101100001") << 9 << 4;
 
501
    QTest::newRow("101100001101100001") << QString("101100001101100001") << 18 << 8;
 
502
    QTest::newRow("101100001101100001101100001101100001") << QString("101100001101100001101100001101100001") << 36 << 16;
 
503
    QTest::newRow("00000000000000000000000000000000000") << QString("00000000000000000000000000000000000") << 35 << 0;
 
504
    QTest::newRow("11111111111111111111111111111111111") << QString("11111111111111111111111111111111111") << 35 << 35;
 
505
    QTest::newRow("11111111111111111111111111111111") << QString("11111111111111111111111111111111") << 32 << 32;
 
506
    QTest::newRow("11111111111111111111111111111111111111111111111111111111")
 
507
        << QString("11111111111111111111111111111111111111111111111111111111") << 56 << 56;
 
508
    QTest::newRow("00000000000000000000000000000000000") << QString("00000000000000000000000000000000000") << 35 << 0;
 
509
    QTest::newRow("00000000000000000000000000000000") << QString("00000000000000000000000000000000") << 32 << 0;
 
510
    QTest::newRow("00000000000000000000000000000000000000000000000000000000")
 
511
        << QString("00000000000000000000000000000000000000000000000000000000") << 56 << 0;
 
512
}
 
513
 
 
514
void tst_QBitArray::datastream()
 
515
{
 
516
    QFETCH(QString, bitField);
 
517
    QFETCH(int, numBits);
 
518
    QFETCH(int, onBits);
 
519
 
 
520
    QBuffer buffer;
 
521
    QVERIFY(buffer.open(QBuffer::ReadWrite));
 
522
    QDataStream stream(&buffer);
 
523
 
 
524
    QBitArray bits(bitField.size());
 
525
    for (int i = 0; i < bitField.size(); ++i) {
 
526
        if (bitField.at(i) == QLatin1Char('1'))
 
527
            bits.setBit(i);
 
528
    }
 
529
 
 
530
    QCOMPARE(bits.count(), numBits);
 
531
    QCOMPARE(bits.count(true), onBits);
 
532
    QCOMPARE(bits.count(false), numBits - onBits);
 
533
 
 
534
    stream << bits << bits << bits;
 
535
    buffer.close();
 
536
 
 
537
    QCOMPARE(stream.status(), QDataStream::Ok);
 
538
 
 
539
    QVERIFY(buffer.open(QBuffer::ReadWrite));
 
540
    QDataStream stream2(&buffer);
 
541
 
 
542
    QBitArray array1, array2, array3;
 
543
    stream2 >> array1 >> array2 >> array3;
 
544
 
 
545
    QCOMPARE(array1.count(), numBits);
 
546
    QCOMPARE(array1.count(true), onBits);
 
547
    QCOMPARE(array1.count(false), numBits - onBits);
 
548
 
 
549
    QCOMPARE(array1, bits);
 
550
    QCOMPARE(array2, bits);
 
551
    QCOMPARE(array3, bits);
 
552
}
 
553
 
 
554
void tst_QBitArray::invertOnNull() const
 
555
{
 
556
    QBitArray a;
 
557
    QCOMPARE(a = ~a, QBitArray());
 
558
}
 
559
 
 
560
void tst_QBitArray::operator_noteq_data()
 
561
{
 
562
    QTest::addColumn<QBitArray>("input1");
 
563
    QTest::addColumn<QBitArray>("input2");
 
564
    QTest::addColumn<bool>("res");
 
565
 
 
566
    QTest::newRow("data0") << QStringToQBitArray(QString("11111111"))
 
567
                           << QStringToQBitArray(QString("00101100"))
 
568
                           << true;
 
569
 
 
570
    QTest::newRow("data1") << QStringToQBitArray(QString("11011011"))
 
571
                           << QStringToQBitArray(QString("11011011"))
 
572
                           << false;
 
573
 
 
574
    QTest::newRow("data2") << QStringToQBitArray(QString())
 
575
                           << QStringToQBitArray(QString("00101100111"))
 
576
                           << true;
 
577
 
 
578
    QTest::newRow("data3") << QStringToQBitArray(QString())
 
579
                           << QStringToQBitArray(QString())
 
580
                           << false;
 
581
 
 
582
    QTest::newRow("data4") << QStringToQBitArray(QString("00101100"))
 
583
                           << QStringToQBitArray(QString("11111111"))
 
584
                           << true;
 
585
 
 
586
    QTest::newRow("data5") << QStringToQBitArray(QString("00101100111"))
 
587
                           << QStringToQBitArray(QString())
 
588
                           << true;
 
589
}
 
590
 
 
591
void tst_QBitArray::operator_noteq()
 
592
{
 
593
    QFETCH(QBitArray, input1);
 
594
    QFETCH(QBitArray, input2);
 
595
    QFETCH(bool, res);
 
596
 
 
597
    bool b = input1 != input2;
 
598
    QCOMPARE(b, res);
 
599
}
 
600
 
 
601
void tst_QBitArray::resize()
 
602
{
 
603
    // -- check that a resize handles the bits correctly
 
604
    QBitArray a = QStringToQBitArray(QString("11"));
 
605
    a.resize(10);
 
606
    QVERIFY(a.size() == 10);
 
607
    QCOMPARE( a, QStringToQBitArray(QString("1100000000")) );
 
608
 
 
609
    a.setBit(9);
 
610
    a.resize(9);
 
611
    // now the bit in a should have been gone:
 
612
    QCOMPARE( a, QStringToQBitArray(QString("110000000")) );
 
613
 
 
614
    // grow the array back and check the new bit
 
615
    a.resize(10);
 
616
    QCOMPARE( a, QStringToQBitArray(QString("1100000000")) );
 
617
 
 
618
    // other test with and
 
619
    a.resize(9);
 
620
    QBitArray b = QStringToQBitArray(QString("1111111111"));
 
621
    b &= a;
 
622
    QCOMPARE( b, QStringToQBitArray(QString("1100000000")) );
 
623
 
 
624
}
 
625
 
 
626
QTEST_APPLESS_MAIN(tst_QBitArray)
 
627
#include "tst_qbitarray.moc"