← Back to branch summary

~ubuntu-branches/debian/sid/texstudio/sid

« back to all changes in this revision

Viewing changes to quazip/qztest/testquazipdir.cpp

  • Committer: Package Import Robot
  • Author(s): Tom Jampen
  • Date: 2015-05-08 06:42:01 UTC
  • mfrom: (1.1.10)
  • Revision ID: package-import@ubuntu.com-20150508064201-1cy70o5bdh9h9258
Tags: 2.9.4+debian-1
* Merging upstream version 2.9.4+debian.
* Regenerating 03-disable-auto-update.patch.
* Removing 05-use-libsynctex.patch as TeXstudio includes a modified
  version of the synctex parser.
* Removing libsynctex-dev from Build-Depends as TeXstudio includes a
  modified version of the synctex parser.
* Removing 06-fix-silent-file-saving.patch, fixed upstream.
* Adding 05-fix-mercurial-revision.patch in order to prevent TeXstudio's
  mercurial revision from being empty.
* Updating year in copyright file.
* Updating quazip's copyright information.
* Rebuilding upstream tarball without:
  - conflicting debian directory
  - unused hunspell directory
  - unused include_win32 directory
  - unused include_win32_qt5 directory
  - unused qt translations
  - unused dictionary and thesaurus files
  - unused TexTablet directory
  - unused poppler-data directory

Show diffs side-by-side

added added

removed removed

Lines of Context:
quazip/qztest/testquazipdir.cpp
1
 
#include "testquazipdir.h"
2
 
#include "qztest.h"
3
 
#include <QtTest/QtTest>
4
 
#include <quazip/quazip.h>
5
 
#include <quazip/quazipdir.h>
6
 
 
7
 
void TestQuaZipDir::entryList_data()
8
 
{
9
 
    QTest::addColumn<QString>("zipName");
10
 
    QTest::addColumn<QStringList>("fileNames");
11
 
    QTest::addColumn<QString>("dirName");
12
 
    QTest::addColumn<QStringList>("nameFilters");
13
 
    // QDir::Filters type breaks Qt meta type system on MSVC
14
 
    QTest::addColumn<int>("filter");
15
 
    QTest::addColumn<int>("sort");
16
 
    QTest::addColumn<QStringList>("entries");
17
 
    QTest::newRow("simple") << "simple.zip" << (
18
 
            QStringList() << "test0.txt" << "testdir1/test1.txt"
19
 
            << "testdir2/test2.txt" << "testdir2/subdir/test2sub.txt")
20
 
            << "testdir2" << QStringList()
21
 
            << static_cast<int>(QDir::NoFilter)
22
 
            << static_cast<int>(QDir::Unsorted)
23
 
            << (QStringList() << "test2.txt" << "subdir/");
24
 
    QTest::newRow("separate dir") << "sepdir.zip" << (
25
 
            QStringList() << "laj/" << "laj/lajfile.txt")
26
 
            << "" << QStringList()
27
 
            << static_cast<int>(QDir::NoFilter)
28
 
            << static_cast<int>(QDir::Unsorted)
29
 
            << (QStringList() << "laj/");
30
 
    QTest::newRow("separate dir (subdir listing)") << "sepdirsub.zip" << (
31
 
            QStringList() << "laj/" << "laj/lajfile.txt")
32
 
            << "laj" << QStringList()
33
 
            << static_cast<int>(QDir::NoFilter)
34
 
            << static_cast<int>(QDir::Unsorted)
35
 
            << (QStringList() << "lajfile.txt");
36
 
    QTest::newRow("dirs only") << "dirsonly.zip" << (
37
 
            QStringList() << "file" << "dir/")
38
 
            << "" << QStringList()
39
 
            << static_cast<int>(QDir::Dirs)
40
 
            << static_cast<int>(QDir::Unsorted)
41
 
            << (QStringList() << "dir/");
42
 
    QTest::newRow("files only") << "filesonly.zip" << (
43
 
            QStringList() << "file1" << "parent/dir/" << "parent/file2")
44
 
            << "parent" << QStringList()
45
 
            << static_cast<int>(QDir::Files)
46
 
            << static_cast<int>(QDir::Unsorted)
47
 
            << (QStringList() << "file2");
48
 
    QTest::newRow("sorted") << "sorted.zip" << (
49
 
            QStringList() << "file1" << "parent/subdir/" << "parent/subdir2/file3" << "parent/file2" << "parent/file0")
50
 
            << "parent" << QStringList()
51
 
            << static_cast<int>(QDir::NoFilter)
52
 
            << static_cast<int>(QDir::Name)
53
 
            << (QStringList() << "file0" << "file2" << "subdir/" << "subdir2/");
54
 
    QTest::newRow("sorted dirs first") << "sorted-dirs.zip" << (
55
 
            QStringList() << "file1" << "parent/subdir/" << "parent/subdir2/file3" << "parent/file2" << "parent/file0")
56
 
            << "parent" << QStringList()
57
 
            << static_cast<int>(QDir::NoFilter)
58
 
            << static_cast<int>(QDir::Name | QDir::DirsFirst)
59
 
            << (QStringList() << "subdir/" << "subdir2/" << "file0" << "file2");
60
 
    QTest::newRow("sorted dirs first reversed") << "sorted-reverse.zip" << (
61
 
            QStringList() << "file1" << "parent/subdir/" << "parent/subdir2/file3" << "parent/file2" << "parent/file0")
62
 
            << "parent" << QStringList()
63
 
            << static_cast<int>(QDir::NoFilter)
64
 
            << static_cast<int>(QDir::Name | QDir::DirsFirst | QDir::Reversed)
65
 
            << (QStringList() << "subdir2/" << "subdir/" << "file2" << "file0");
66
 
    QTest::newRow("sorted by size") << "sorted-size.zip" << (
67
 
            QStringList() << "file000" << "file10")
68
 
            << "/" << QStringList()
69
 
            << static_cast<int>(QDir::NoFilter)
70
 
            << static_cast<int>(QDir::Size)
71
 
            << (QStringList() << "file10" << "file000");
72
 
    QTest::newRow("sorted by time") << "sorted-time.zip" << (
73
 
            QStringList() << "file04" << "file03" << "file02" << "subdir/subfile")
74
 
            << "/" << QStringList()
75
 
            << static_cast<int>(QDir::NoFilter)
76
 
            << static_cast<int>(QDir::Time)
77
 
            << (QStringList() << "subdir/" << "file04" << "file02" << "file03");
78
 
    QTest::newRow("name filter") << "name-filter.zip" << (
79
 
            QStringList() << "file01" << "file02" << "laj")
80
 
            << "/" << QStringList("file*")
81
 
            << static_cast<int>(QDir::NoFilter)
82
 
            << static_cast<int>(QDir::Name)
83
 
            << (QStringList() << "file01" << "file02");
84
 
}
85
 
 
86
 
void TestQuaZipDir::entryList()
87
 
{
88
 
    QFETCH(QString, zipName);
89
 
    QFETCH(QStringList, fileNames);
90
 
    QFETCH(QString, dirName);
91
 
    QFETCH(QStringList, nameFilters);
92
 
    QFETCH(int, filter);
93
 
    QFETCH(int, sort);
94
 
    QDir::Filters filters = static_cast<QDir::Filters>(filter);
95
 
    QDir::SortFlags sorting = static_cast<QDir::SortFlags>(sort);
96
 
    QFETCH(QStringList, entries);
97
 
    QDir curDir;
98
 
    if (!createTestFiles(fileNames)) {
99
 
        QFAIL("Couldn't create test files");
100
 
    }
101
 
    if (!createTestArchive(zipName, fileNames)) {
102
 
        QFAIL("Couldn't create test archive");
103
 
    }
104
 
    removeTestFiles(fileNames);
105
 
    QuaZip zip(zipName);
106
 
    QVERIFY(zip.open(QuaZip::mdUnzip));
107
 
    QuaZipDir dir(&zip, dirName);
108
 
    QCOMPARE(dir.entryList(nameFilters, filters, sorting), entries);
109
 
    zip.close();
110
 
    curDir.remove(zipName);
111
 
}
112
 
 
113
 
void TestQuaZipDir::cd_data()
114
 
{
115
 
    QTest::addColumn<QString>("zipName");
116
 
    QTest::addColumn<QStringList>("fileNames");
117
 
    QTest::addColumn<QString>("dirName");
118
 
    QTest::addColumn<QString>("targetDirName");
119
 
    QTest::addColumn<QString>("result");
120
 
    QTest::newRow("cdDown") << "simple.zip" << (
121
 
            QStringList() << "cddown.txt" << "testdir1/test1.txt"
122
 
            << "testdir2/test2.txt" << "testdir2/subdir/test2sub.txt")
123
 
            << "" << "testdir1" << "testdir1";
124
 
    QTest::newRow("cdUp") << "cdup.zip" << (
125
 
            QStringList() << "test0.txt" << "testdir1/test1.txt"
126
 
            << "testdir2/test2.txt" << "testdir2/subdir/test2sub.txt")
127
 
            << "testdir1" << ".." << "";
128
 
    QTest::newRow("cdSide") << "cdside.zip" << (
129
 
            QStringList() << "test0.txt" << "testdir1/test1.txt"
130
 
            << "testdir2/test2.txt" << "testdir2/subdir/test2sub.txt")
131
 
            << "testdir1" << "../testdir2" << "testdir2";
132
 
    QTest::newRow("cdDownUp") << "cdside.zip" << (
133
 
            QStringList() << "test0.txt" << "testdir1/test1.txt"
134
 
            << "testdir2/test2.txt" << "testdir2/subdir/test2sub.txt")
135
 
            << "" << "testdir1/.." << "";
136
 
    QTest::newRow("cdDeep") << "cdside.zip" << (
137
 
            QStringList() << "test0.txt" << "testdir1/test1.txt"
138
 
            << "testdir2/test2.txt" << "testdir2/subdir/test2sub.txt")
139
 
            << "" << "testdir2/subdir" << "testdir2/subdir";
140
 
    QTest::newRow("cdDeeper") << "cdside.zip" << (
141
 
            QStringList() << "test0.txt" << "testdir1/test1.txt"
142
 
            << "testdir2/test2.txt" << "testdir2/subdir/subdir2/subdir3/test2sub.txt")
143
 
            << "testdir2/subdir" << "subdir2/subdir3" << "testdir2/subdir/subdir2/subdir3";
144
 
    QTest::newRow("cdRoot") << "cdup.zip" << (
145
 
            QStringList() << "test0.txt" << "testdir1/test1.txt"
146
 
            << "testdir2/test2.txt" << "testdir2/subdir/test2sub.txt")
147
 
            << "testdir1" << "/" << "";
148
 
}
149
 
 
150
 
void TestQuaZipDir::cd()
151
 
{
152
 
    QFETCH(QString, zipName);
153
 
    QFETCH(QStringList, fileNames);
154
 
    QFETCH(QString, dirName);
155
 
    QFETCH(QString, targetDirName);
156
 
    QFETCH(QString, result);
157
 
    QDir curDir;
158
 
    if (!createTestFiles(fileNames)) {
159
 
        QFAIL("Couldn't create test files");
160
 
    }
161
 
    if (!createTestArchive(zipName, fileNames)) {
162
 
        QFAIL("Couldn't create test archive");
163
 
    }
164
 
    removeTestFiles(fileNames);
165
 
    QuaZip zip(zipName);
166
 
    QVERIFY(zip.open(QuaZip::mdUnzip));
167
 
    QuaZipDir dir(&zip, dirName);
168
 
    QVERIFY(dir.cd(targetDirName));
169
 
    QCOMPARE(dir.path(), result);
170
 
    zip.close();
171
 
    curDir.remove(zipName);
172
 
}
 
1
/*
 
2
Copyright (C) 2005-2014 Sergey A. Tachenov
 
3
 
 
4
This file is part of QuaZIP test suite.
 
5
 
 
6
QuaZIP is free software: you can redistribute it and/or modify
 
7
it under the terms of the GNU Lesser General Public License as published by
 
8
the Free Software Foundation, either version 2.1 of the License, or
 
9
(at your option) any later version.
 
10
 
 
11
QuaZIP is distributed in the hope that it will be useful,
 
12
but WITHOUT ANY WARRANTY; without even the implied warranty of
 
13
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
14
GNU Lesser General Public License for more details.
 
15
 
 
16
You should have received a copy of the GNU Lesser General Public License
 
17
along with QuaZIP.  If not, see <http://www.gnu.org/licenses/>.
 
18
 
 
19
See COPYING file for the full LGPL text.
 
20
 
 
21
Original ZIP package is copyrighted by Gilles Vollant and contributors,
 
22
see quazip/(un)zip.h files for details. Basically it's the zlib license.
 
23
*/
 
24
 
 
25
#include "testquazipdir.h"
 
26
#include "qztest.h"
 
27
#include <QtTest/QtTest>
 
28
#include <quazip/quazip.h>
 
29
#include <quazip/quazipdir.h>
 
30
 
 
31
void TestQuaZipDir::entryList_data()
 
32
{
 
33
    QTest::addColumn<QString>("zipName");
 
34
    QTest::addColumn<QStringList>("fileNames");
 
35
    QTest::addColumn<QString>("dirName");
 
36
    QTest::addColumn<QStringList>("nameFilters");
 
37
    // QDir::Filters type breaks Qt meta type system on MSVC
 
38
    QTest::addColumn<int>("filter");
 
39
    QTest::addColumn<int>("sort");
 
40
    QTest::addColumn<QStringList>("entries");
 
41
    QTest::addColumn<int>("caseSensitivity");
 
42
    QTest::newRow("simple") << "simple.zip" << (
 
43
            QStringList() << "test0.txt" << "testdir1/test1.txt"
 
44
            << "testdir2/test2.txt" << "testdir2/subdir/test2sub.txt")
 
45
            << "testdir2" << QStringList()
 
46
            << static_cast<int>(QDir::NoFilter)
 
47
            << static_cast<int>(QDir::Unsorted)
 
48
            << (QStringList() << "test2.txt" << "subdir/") << -1;
 
49
    QTest::newRow("separate dir") << "sepdir.zip" << (
 
50
            QStringList() << "laj/" << "laj/lajfile.txt")
 
51
            << "" << QStringList()
 
52
            << static_cast<int>(QDir::NoFilter)
 
53
            << static_cast<int>(QDir::Unsorted)
 
54
            << (QStringList() << "laj/") << -1;
 
55
    QTest::newRow("separate dir (subdir listing)") << "sepdirsub.zip" << (
 
56
            QStringList() << "laj/" << "laj/lajfile.txt")
 
57
            << "laj" << QStringList()
 
58
            << static_cast<int>(QDir::NoFilter)
 
59
            << static_cast<int>(QDir::Unsorted)
 
60
            << (QStringList() << "lajfile.txt") << -1;
 
61
    QTest::newRow("dirs only") << "dirsonly.zip" << (
 
62
            QStringList() << "file" << "dir/")
 
63
            << "" << QStringList()
 
64
            << static_cast<int>(QDir::Dirs)
 
65
            << static_cast<int>(QDir::Unsorted)
 
66
            << (QStringList() << "dir/") << -1;
 
67
    QTest::newRow("files only") << "filesonly.zip" << (
 
68
            QStringList() << "file1" << "parent/dir/" << "parent/file2")
 
69
            << "parent" << QStringList()
 
70
            << static_cast<int>(QDir::Files)
 
71
            << static_cast<int>(QDir::Unsorted)
 
72
            << (QStringList() << "file2") << -1;
 
73
    QTest::newRow("sorted") << "sorted.zip" << (
 
74
            QStringList() << "file1" << "parent/subdir/" << "parent/subdir2/file3" << "parent/file2" << "parent/file0")
 
75
            << "parent" << QStringList()
 
76
            << static_cast<int>(QDir::NoFilter)
 
77
            << static_cast<int>(QDir::Name)
 
78
            << (QStringList() << "file0" << "file2" << "subdir/" << "subdir2/")
 
79
            << -1;
 
80
    QTest::newRow("sorted dirs first") << "sorted-dirs.zip" << (
 
81
            QStringList() << "file1" << "parent/subdir/" << "parent/subdir2/file3" << "parent/file2" << "parent/file0")
 
82
            << "parent" << QStringList()
 
83
            << static_cast<int>(QDir::NoFilter)
 
84
            << static_cast<int>(QDir::Name | QDir::DirsFirst)
 
85
            << (QStringList() << "subdir/" << "subdir2/" << "file0" << "file2")
 
86
            << -1;
 
87
    QTest::newRow("sorted dirs first reversed") << "sorted-reverse.zip" << (
 
88
            QStringList() << "file1" << "parent/subdir/" << "parent/subdir2/file3" << "parent/file2" << "parent/file0")
 
89
            << "parent" << QStringList()
 
90
            << static_cast<int>(QDir::NoFilter)
 
91
            << static_cast<int>(QDir::Name | QDir::DirsFirst | QDir::Reversed)
 
92
            << (QStringList() << "subdir2/" << "subdir/" << "file2" << "file0")
 
93
            << -1;
 
94
    QTest::newRow("sorted by size") << "sorted-size.zip" << (
 
95
            QStringList() << "file000" << "file10")
 
96
            << "/" << QStringList()
 
97
            << static_cast<int>(QDir::NoFilter)
 
98
            << static_cast<int>(QDir::Size)
 
99
            << (QStringList() << "file10" << "file000") << -1;
 
100
    QTest::newRow("sorted by time") << "sorted-time.zip" << (
 
101
            QStringList() << "file04" << "file03" << "file02" << "subdir/subfile")
 
102
            << "/" << QStringList()
 
103
            << static_cast<int>(QDir::NoFilter)
 
104
            << static_cast<int>(QDir::Time)
 
105
            << (QStringList() << "subdir/" << "file04" << "file02" << "file03")
 
106
            << -1;
 
107
    QTest::newRow("sorted by type") << "sorted-type.zip" << (
 
108
            QStringList() << "file1.txt" << "file2.dat")
 
109
            << "/" << QStringList()
 
110
            << static_cast<int>(QDir::NoFilter)
 
111
            << static_cast<int>(QDir::Type)
 
112
            << (QStringList() << "file2.dat" << "file1.txt") << -1;
 
113
    QTest::newRow("name filter") << "name-filter.zip" << (
 
114
            QStringList() << "file01" << "file02" << "laj")
 
115
            << "/" << QStringList("file*")
 
116
            << static_cast<int>(QDir::NoFilter)
 
117
            << static_cast<int>(QDir::Name)
 
118
            << (QStringList() << "file01" << "file02") << -1;
 
119
    QTest::newRow("case sensitive") << "case-sensitive.zip" << (
 
120
            QStringList() << "a" << "B")
 
121
            << "/" << QStringList()
 
122
            << static_cast<int>(QDir::NoFilter)
 
123
            << static_cast<int>(QDir::Name)
 
124
            << (QStringList() << "B" << "a")
 
125
            << static_cast<int>(QuaZip::csSensitive);
 
126
    QTest::newRow("case insensitive") << "case-insensitive.zip" << (
 
127
            QStringList() << "B" << "a")
 
128
            << "/" << QStringList()
 
129
            << static_cast<int>(QDir::NoFilter)
 
130
            << static_cast<int>(QDir::Name)
 
131
            << (QStringList() << "a" << "B")
 
132
            << static_cast<int>(QuaZip::csInsensitive);
 
133
}
 
134
 
 
135
void TestQuaZipDir::entryList()
 
136
{
 
137
    QFETCH(QString, zipName);
 
138
    QFETCH(QStringList, fileNames);
 
139
    QFETCH(QString, dirName);
 
140
    QFETCH(QStringList, nameFilters);
 
141
    QFETCH(int, filter);
 
142
    QFETCH(int, sort);
 
143
    QDir::Filters filters = static_cast<QDir::Filters>(filter);
 
144
    QDir::SortFlags sorting = static_cast<QDir::SortFlags>(sort);
 
145
    QFETCH(QStringList, entries);
 
146
    QFETCH(int, caseSensitivity);
 
147
    QDir curDir;
 
148
    if (!createTestFiles(fileNames)) {
 
149
        QFAIL("Couldn't create test files");
 
150
    }
 
151
    if (!createTestArchive(zipName, fileNames)) {
 
152
        QFAIL("Couldn't create test archive");
 
153
    }
 
154
    removeTestFiles(fileNames);
 
155
    QuaZip zip(zipName);
 
156
    QVERIFY(zip.open(QuaZip::mdUnzip));
 
157
    QuaZipDir dir(&zip, dirName);
 
158
    QVERIFY(dir.exists());
 
159
    if (caseSensitivity != -1) {
 
160
        dir.setCaseSensitivity(static_cast<QuaZip::CaseSensitivity>(
 
161
                                   caseSensitivity));
 
162
        QCOMPARE(dir.caseSensitivity(), static_cast<QuaZip::CaseSensitivity>(
 
163
                     caseSensitivity));
 
164
    }
 
165
    QCOMPARE(dir.entryList(nameFilters, filters, sorting), entries);
 
166
    // Test default sorting setting.
 
167
    dir.setSorting(sorting);
 
168
    QCOMPARE(dir.sorting(), sorting);
 
169
    QCOMPARE(dir.entryList(nameFilters, filters), entries);
 
170
    // Test default name filter setting.
 
171
    dir.setNameFilters(nameFilters);
 
172
    QCOMPARE(dir.nameFilters(), nameFilters);
 
173
    QCOMPARE(dir.entryList(filters), entries);
 
174
    // Test default filters.
 
175
    dir.setFilter(filters);
 
176
    QCOMPARE(dir.filter(), filters);
 
177
    QCOMPARE(dir.entryList(), entries);
 
178
    QCOMPARE(dir.entryList().count(), static_cast<int>(dir.count()));
 
179
    zip.close();
 
180
    curDir.remove(zipName);
 
181
}
 
182
 
 
183
void TestQuaZipDir::cd_data()
 
184
{
 
185
    QTest::addColumn<QString>("zipName");
 
186
    QTest::addColumn<QStringList>("fileNames");
 
187
    QTest::addColumn<QString>("dirName");
 
188
    QTest::addColumn<QString>("targetDirName");
 
189
    QTest::addColumn<QString>("result");
 
190
    QTest::newRow("cdDown") << "simple.zip" << (
 
191
            QStringList() << "cddown.txt" << "testdir1/test1.txt"
 
192
            << "testdir2/test2.txt" << "testdir2/subdir/test2sub.txt")
 
193
            << "" << "testdir1" << "testdir1";
 
194
    QTest::newRow("cdUp") << "cdup.zip" << (
 
195
            QStringList() << "test0.txt" << "testdir1/test1.txt"
 
196
            << "testdir2/test2.txt" << "testdir2/subdir/test2sub.txt")
 
197
            << "testdir1" << ".." << "";
 
198
    QTest::newRow("cdSide") << "cdside.zip" << (
 
199
            QStringList() << "test0.txt" << "testdir1/test1.txt"
 
200
            << "testdir2/test2.txt" << "testdir2/subdir/test2sub.txt")
 
201
            << "testdir1" << "../testdir2" << "testdir2";
 
202
    QTest::newRow("cdDownUp") << "cdside.zip" << (
 
203
            QStringList() << "test0.txt" << "testdir1/test1.txt"
 
204
            << "testdir2/test2.txt" << "testdir2/subdir/test2sub.txt")
 
205
            << "" << "testdir1/.." << "";
 
206
    QTest::newRow("cdDeep") << "cdside.zip" << (
 
207
            QStringList() << "test0.txt" << "testdir1/test1.txt"
 
208
            << "testdir2/test2.txt" << "testdir2/subdir/test2sub.txt")
 
209
            << "" << "testdir2/subdir" << "testdir2/subdir";
 
210
    QTest::newRow("cdDeeper") << "cdside.zip" << (
 
211
            QStringList() << "test0.txt" << "testdir1/test1.txt"
 
212
            << "testdir2/test2.txt" << "testdir2/subdir/subdir2/subdir3/test2sub.txt")
 
213
            << "testdir2/subdir" << "subdir2/subdir3" << "testdir2/subdir/subdir2/subdir3";
 
214
    QTest::newRow("cdRoot") << "cdup.zip" << (
 
215
            QStringList() << "test0.txt" << "testdir1/test1.txt"
 
216
            << "testdir2/test2.txt" << "testdir2/subdir/test2sub.txt")
 
217
            << "testdir1" << "/" << "";
 
218
}
 
219
 
 
220
void TestQuaZipDir::cd()
 
221
{
 
222
    QFETCH(QString, zipName);
 
223
    QFETCH(QStringList, fileNames);
 
224
    QFETCH(QString, dirName);
 
225
    QFETCH(QString, targetDirName);
 
226
    QFETCH(QString, result);
 
227
    QDir curDir;
 
228
    if (!createTestFiles(fileNames)) {
 
229
        QFAIL("Couldn't create test files");
 
230
    }
 
231
    if (!createTestArchive(zipName, fileNames)) {
 
232
        QFAIL("Couldn't create test archive");
 
233
    }
 
234
    removeTestFiles(fileNames);
 
235
    QuaZip zip(zipName);
 
236
    QVERIFY(zip.open(QuaZip::mdUnzip));
 
237
    QuaZipDir dir(&zip, dirName);
 
238
    if (dirName.startsWith('/')) {
 
239
        dirName = dirName.mid(1);
 
240
    }
 
241
    if (dirName.endsWith('/')) {
 
242
        dirName.chop(1);
 
243
    }
 
244
    QCOMPARE(dir.path(), dirName);
 
245
    {
 
246
        int lastSlash = dirName.lastIndexOf('/');
 
247
        if (lastSlash == -1) {
 
248
            // dirName is just a single name
 
249
            if (dirName.isEmpty()) {
 
250
                QCOMPARE(dir.dirName(), QString::fromLatin1("."));
 
251
            } else {
 
252
                QCOMPARE(dir.dirName(), dirName);
 
253
            }
 
254
        } else {
 
255
            // dirName is a sequence
 
256
            QCOMPARE(dir.dirName(), dirName.mid(lastSlash + 1));
 
257
        }
 
258
    }
 
259
    if (targetDirName == "..") {
 
260
        QVERIFY(dir.cdUp());
 
261
    } else {
 
262
        QVERIFY(dir.cd(targetDirName));
 
263
    }
 
264
    QCOMPARE(dir.path(), result);
 
265
    // Try to go back
 
266
    dir.setPath(dirName);
 
267
    QCOMPARE(dir.path(), dirName);
 
268
    zip.close();
 
269
    curDir.remove(zipName);
 
270
}
 
271
 
 
272
void TestQuaZipDir::entryInfoList()
 
273
{
 
274
    QString zipName = "entryInfoList.zip";
 
275
    QStringList fileNames;
 
276
    fileNames << "test.txt";
 
277
    if (!createTestFiles(fileNames)) {
 
278
        QFAIL("Couldn't create test files");
 
279
    }
 
280
    if (!createTestArchive(zipName, fileNames)) {
 
281
        QFAIL("Couldn't create test archive");
 
282
    }
 
283
    removeTestFiles(fileNames);
 
284
    QuaZip zip(zipName);
 
285
    QDir curDir;
 
286
    QVERIFY(zip.open(QuaZip::mdUnzip));
 
287
    QuaZipDir dir(&zip, "/");
 
288
    QCOMPARE(dir.entryInfoList().size(), 1);
 
289
    QCOMPARE(dir.entryInfoList64().size(), 1);
 
290
    zip.close();
 
291
    curDir.remove(zipName);
 
292
}
 
293
 
 
294
void TestQuaZipDir::operators()
 
295
{
 
296
    QString zipName = "zipDirOperators.zip";
 
297
    QStringList fileNames;
 
298
    fileNames << "dir/test.txt" << "root.txt";
 
299
    if (!createTestFiles(fileNames)) {
 
300
        QFAIL("Couldn't create test files");
 
301
    }
 
302
    if (!createTestArchive(zipName, fileNames)) {
 
303
        QFAIL("Couldn't create test archive");
 
304
    }
 
305
    removeTestFiles(fileNames);
 
306
    QuaZip zip(zipName);
 
307
    QDir curDir;
 
308
    QVERIFY(zip.open(QuaZip::mdUnzip));
 
309
    QuaZipDir dir(&zip, "dir");
 
310
    QuaZipDir dir2 = dir; // Copy constructor
 
311
    QCOMPARE(dir2.path(), QString::fromLatin1("dir"));
 
312
    dir2.cdUp();
 
313
    QCOMPARE(dir2.path(), QString::fromLatin1(""));
 
314
    QCOMPARE(dir.path(), QString::fromLatin1("dir"));
 
315
    dir2 = dir; // operator=()
 
316
    QCOMPARE(dir2.path(), QString::fromLatin1("dir"));
 
317
    QVERIFY(dir2 == dir); // opertor==
 
318
    dir.cd("/");
 
319
    QCOMPARE(dir[0], QString::fromLatin1("dir/"));
 
320
    QCOMPARE(dir[1], QString::fromLatin1("root.txt"));
 
321
    zip.close();
 
322
    curDir.remove(zipName);
 
323
}
 
324
 
 
325
void TestQuaZipDir::filePath()
 
326
{
 
327
    QString zipName = "entryInfoList.zip";
 
328
    QStringList fileNames;
 
329
    fileNames << "root.txt" << "dir/test.txt";
 
330
    if (!createTestFiles(fileNames)) {
 
331
        QFAIL("Couldn't create test files");
 
332
    }
 
333
    if (!createTestArchive(zipName, fileNames)) {
 
334
        QFAIL("Couldn't create test archive");
 
335
    }
 
336
    removeTestFiles(fileNames);
 
337
    QuaZip zip(zipName);
 
338
    QDir curDir;
 
339
    QVERIFY(zip.open(QuaZip::mdUnzip));
 
340
    QuaZipDir dir(&zip);
 
341
    QVERIFY(dir.cd("dir"));
 
342
    QCOMPARE(dir.relativeFilePath("/root.txt"),
 
343
             QString::fromLatin1("../root.txt"));
 
344
    QCOMPARE(dir.filePath("test.txt"),
 
345
             QString::fromLatin1("dir/test.txt"));
 
346
    zip.close();
 
347
    curDir.remove(zipName);
 
348
}