← Back to branch summary

~ubuntu-branches/ubuntu/saucy/digikam/saucy

« back to all changes in this revision

Viewing changes to tests/advancedrenametest.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Scott Kitterman
  • Date: 2010-12-21 23:19:11 UTC
  • mfrom: (1.2.33 upstream) (3.1.7 experimental)
  • Revision ID: james.westby@ubuntu.com-20101221231911-z9jip7s5aht1jqn9
Tags: 2:1.7.0-1ubuntu1
* Merge from Debian Experimental. Remaining Ubuntu changes:
  - Export .pot name and copy to plugins in debian/rules
  - Version build-depends on kipi-plugins-dev to ensure build is against the
    same version on all archs
* Drop debian/patches/kubuntu_01_linker.diff, incoporated upstream
* Remove patches directory and unused patches

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/advancedrenametest.cpp
 
1
/* ============================================================
 
2
 *
 
3
 * This file is a part of digiKam project
 
4
 * http://www.digikam.org
 
5
 *
 
6
 * Date        : 2009-06-09
 
7
 * Description : a test for the AdvancedRename utility
 
8
 *
 
9
 * Copyright (C) 2009-2010 by Andi Clemens <andi dot clemens at gmx dot net>
 
10
 *
 
11
 * This program is free software; you can redistribute it
 
12
 * and/or modify it under the terms of the GNU General
 
13
 * Public License as published by the Free Software Foundation;
 
14
 * either version 2, or (at your option)
 
15
 * any later version.
 
16
 *
 
17
 * This program is distributed in the hope that it will be useful,
 
18
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
19
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
20
 * GNU General Public License for more details.
 
21
 *
 
22
 * ============================================================ */
 
23
 
 
24
#include "advancedrenametest.moc"
 
25
 
 
26
// Qt includes
 
27
 
 
28
#include <QFileInfo>
 
29
 
 
30
// KDE includes
 
31
 
 
32
#include <KUrl>
 
33
#include <qtest_kde.h>
 
34
 
 
35
using namespace Digikam;
 
36
 
 
37
QTEST_KDEMAIN(AdvancedRenameWidgetTest, GUI)
 
38
 
 
39
const QString fileName("advancedrename_testimage.jpg");
 
40
const QString filePath(KDESRCDIR+fileName);
 
41
 
 
42
void AdvancedRenameWidgetTest::testFileNameToken()
 
43
{
 
44
    QList<ParseSettings> files;
 
45
    ParseSettings ps;
 
46
    KUrl url(filePath);
 
47
    ps.fileUrl = KUrl(filePath);
 
48
    files << ps;
 
49
    AdvancedRenameManager manager(files);
 
50
    manager.parseFiles("[file]");
 
51
 
 
52
    QString parsed = manager.newName(filePath);
 
53
    QCOMPARE(parsed, fileName);
 
54
}
 
55
 
 
56
void AdvancedRenameWidgetTest::testFileExtensionToken_data()
 
57
{
 
58
    QTest::addColumn<QString>("parseString");
 
59
    QTest::addColumn<QString>("result");
 
60
 
 
61
    QTest::newRow(fileName.toAscii())  << QString("[ext]") << QString("jpg.jpg");
 
62
    QTest::newRow("[ext]_lala_####") << QString("[ext]_lala_####") << QString("jpg_lala_0001.jpg");
 
63
    QTest::newRow("[ext]_lala_####[ext]") << QString("[ext]_lala_####[ext]") << QString("jpg_lala_0001jpg.jpg");
 
64
    QTest::newRow("[ext]_lala_####.[ext]") << QString("[ext]_lala_####.[ext]") << QString("jpg_lala_0001.jpg");
 
65
    QTest::newRow("[ext]_lala_####.[ext]{upper}") << QString("[ext]_lala_####.[ext]{upper}") << QString("jpg_lala_0001.JPG");
 
66
    QTest::newRow("[ext]_lala_####[ext]{upper}") << QString("[ext]_lala_####[ext]{upper}") << QString("jpg_lala_0001JPG.jpg");
 
67
}
 
68
 
 
69
void AdvancedRenameWidgetTest::testFileExtensionToken()
 
70
{
 
71
    QFETCH(QString,   parseString);
 
72
    QFETCH(QString,   result);
 
73
 
 
74
    QList<ParseSettings> files;
 
75
    ParseSettings ps;
 
76
    KUrl url(filePath);
 
77
    ps.fileUrl = KUrl(filePath);
 
78
    files << ps;
 
79
    AdvancedRenameManager manager(files);
 
80
    manager.parseFiles(parseString);
 
81
 
 
82
    QString parsed = manager.newName(filePath);
 
83
    QCOMPARE(parsed, result);
 
84
}
 
85
 
 
86
void AdvancedRenameWidgetTest::testFileOwnerToken()
 
87
{
 
88
    ParseSettings settings;
 
89
    DefaultRenameParser parser;
 
90
 
 
91
    settings.fileUrl     = KUrl(KDESRCDIR"/test.png");
 
92
    settings.parseString = "[user]";
 
93
 
 
94
    QFileInfo fi(settings.fileUrl.toLocalFile());
 
95
    QVERIFY(fi.exists());
 
96
    QVERIFY(fi.isReadable());
 
97
 
 
98
    QString userName = fi.owner();
 
99
    QVERIFY(!userName.isEmpty());
 
100
 
 
101
    QString result = userName + ".png";
 
102
    QString parsed = parser.parse(settings);
 
103
 
 
104
    QCOMPARE(parsed, result);
 
105
}
 
106
 
 
107
void AdvancedRenameWidgetTest::testFileGroupToken()
 
108
{
 
109
    ParseSettings settings;
 
110
    DefaultRenameParser parser;
 
111
 
 
112
    settings.fileUrl     = KUrl(KDESRCDIR"/test.png");
 
113
    settings.parseString = "[group]";
 
114
 
 
115
    QFileInfo fi(settings.fileUrl.toLocalFile());
 
116
    QVERIFY(fi.exists());
 
117
    QVERIFY(fi.isReadable());
 
118
 
 
119
    QString groupName = fi.group();
 
120
    QVERIFY(!groupName.isEmpty());
 
121
 
 
122
    QString result = groupName + ".png";
 
123
    QString parsed = parser.parse(settings);
 
124
 
 
125
    QCOMPARE(parsed, result);
 
126
}
 
127
 
 
128
void AdvancedRenameWidgetTest::testDirectoryNameToken_data()
 
129
{
 
130
    QTest::addColumn<QString>("parseString");
 
131
    QTest::addColumn<QString>("result");
 
132
 
 
133
    QTest::newRow("[dir]")          << QString("[dir]")          << QString("tests.jpg");
 
134
    QTest::newRow("[dir.]")         << QString("[dir.]")         << QString("digikam.jpg");
 
135
    QTest::newRow("[dir.]_[dir]")   << QString("[dir.]_[dir]")   << QString("digikam_tests.jpg");
 
136
    QTest::newRow("[dir.......]")   << QString("[dir.......]")   << fileName;
 
137
}
 
138
 
 
139
void AdvancedRenameWidgetTest::testDirectoryNameToken()
 
140
{
 
141
    QFETCH(QString,   parseString);
 
142
    QFETCH(QString,   result);
 
143
 
 
144
    QList<ParseSettings> files;
 
145
    ParseSettings ps;
 
146
    KUrl url(filePath);
 
147
    ps.fileUrl = KUrl(filePath);
 
148
    files << ps;
 
149
    AdvancedRenameManager manager(files);
 
150
    manager.parseFiles(parseString);
 
151
 
 
152
    QString parsed = manager.newName(filePath);
 
153
    QCOMPARE(parsed, result);
 
154
}
 
155
 
 
156
void AdvancedRenameWidgetTest::testNumberToken_data()
 
157
{
 
158
    QTest::addColumn<QString>("parseString");
 
159
    QTest::addColumn<QString>("result");
 
160
 
 
161
    QTest::newRow("#")                      << QString("#")                      << QString("1.jpg");
 
162
    QTest::newRow("####[2,3]")              << QString("####[2,3]")              << QString("0002.jpg");
 
163
    QTest::newRow("####[2,3]_bla_## ###")   << QString("####[2,3]_bla_## ###")   << QString("0002_bla_01 001.jpg");
 
164
    QTest::newRow("####[2,3]_bla_## ###")   << QString("####[2,3]_bla_## ###")   << QString("0002_bla_01 001.jpg");
 
165
    QTest::newRow("####[2,3]_bla_## ###")   << QString("####[2,3]_bla_## ###")   << QString("0002_bla_01 001.jpg");
 
166
    QTest::newRow("###[100]_bla")           << QString("###[100]_bla")           << QString("100_bla.jpg");
 
167
    QTest::newRow("###[e,1,100]_bla")       << QString("###[e,1,100]_bla")       << QString("001_bla.jpg");
 
168
}
 
169
 
 
170
void AdvancedRenameWidgetTest::testNumberToken()
 
171
{
 
172
    QFETCH(QString,   parseString);
 
173
    QFETCH(QString,   result);
 
174
 
 
175
    QList<ParseSettings> files;
 
176
    ParseSettings ps;
 
177
    KUrl url(filePath);
 
178
    ps.fileUrl = KUrl(filePath);
 
179
    files << ps;
 
180
    AdvancedRenameManager manager(files);
 
181
    manager.parseFiles(parseString);
 
182
 
 
183
    QString parsed = manager.newName(filePath);
 
184
    QCOMPARE(parsed, result);
 
185
}
 
186
 
 
187
void AdvancedRenameWidgetTest::testFirstLetterOfEachWordUppercaseModifier()
 
188
{
 
189
    QList<ParseSettings> files;
 
190
    ParseSettings ps;
 
191
    KUrl url(filePath);
 
192
    ps.fileUrl = KUrl(filePath);
 
193
    files << ps;
 
194
    AdvancedRenameManager manager(files);
 
195
    manager.parseFiles("[file]{firstupper}");
 
196
 
 
197
    QString parsed = manager.newName(filePath);
 
198
    QCOMPARE(parsed, QString("Advancedrename_Testimage.jpg"));
 
199
}
 
200
 
 
201
void AdvancedRenameWidgetTest::testChainedModifiers_data()
 
202
{
 
203
    QTest::addColumn<QString>("parseString");
 
204
    QTest::addColumn<QString>("result");
 
205
 
 
206
    QTest::newRow("[file]*{upper}") << QString("[file]{firstupper}{upper}") << QString("ADVANCEDRENAME_TESTIMAGE.jpg");
 
207
    QTest::newRow("[file]{range:3,}*") << QString("[file]{range:3,}{firstupper}")    << QString("Vancedrename_Testimage.jpg");
 
208
 
 
209
    QTest::newRow("[file]{range:3,}{replace:\"name\",\"age\"}{firstupper}")
 
210
            << QString("[file]{range:3,}{replace:\"name\",\"age\"}{firstupper}")
 
211
            << QString("Vancedreage_Testimage.jpg");
 
212
}
 
213
 
 
214
void AdvancedRenameWidgetTest::testChainedModifiers()
 
215
{
 
216
    QFETCH(QString,   parseString);
 
217
    QFETCH(QString,   result);
 
218
 
 
219
    QList<ParseSettings> files;
 
220
    ParseSettings ps;
 
221
    KUrl url(filePath);
 
222
    ps.fileUrl = KUrl(filePath);
 
223
    files << ps;
 
224
    AdvancedRenameManager manager(files);
 
225
    manager.parseFiles(parseString);
 
226
 
 
227
    QString parsed = manager.newName(filePath);
 
228
    QCOMPARE(parsed, result);
 
229
}
 
230
 
 
231
void AdvancedRenameWidgetTest::testUppercaseModifier()
 
232
{
 
233
    ParseSettings settings;
 
234
    DefaultRenameParser parser;
 
235
 
 
236
    settings.fileUrl     = filePath;
 
237
    settings.parseString = "[file]{upper}";
 
238
 
 
239
    QString parsed = parser.parse(settings);
 
240
    QFileInfo fi(filePath);
 
241
    QCOMPARE(parsed, fi.baseName().toUpper() + "." + fi.suffix());
 
242
}
 
243
 
 
244
//void AdvancedRenameWidgetTest::testUniqueModifier()
 
245
//{
 
246
//    ParseSettings settings;
 
247
//    DefaultRenameParser parser;
 
248
//
 
249
//    settings.fileUrl     = filePath;
 
250
//    settings.cameraName  = QString("Nikon D50");
 
251
//    settings.parseString = QString("[file]{unique}_T[date:hhmmss]{unique}_[cam]{unique}");
 
252
//
 
253
//#define DIGITS_STR(VALUE, DIGITS) QString("%1").arg(VALUE, DIGITS, 10, QChar('0'))
 
254
//
 
255
//    QStringList validResults;
 
256
//    validResults << QString("advancedrename_testimage_T100012_Nikon D50.jpg");
 
257
//    validResults << QString("advancedrename_testimage_%1_T100012_%2_Nikon D50_%3.jpg")
 
258
//            .arg(DIGITS_STR(1, 1)).arg(DIGITS_STR(1, 1)).arg(DIGITS_STR(1, 1));
 
259
//    validResults << QString("advancedrename_testimage_%1_T214536_Nikon D50_%2.jpg")
 
260
//            .arg(DIGITS_STR(2, 1)).arg(DIGITS_STR(2, 1));
 
261
//    validResults << QString("advancedrename_testimage_%1_T214536_%2_Nikon D50_%3.jpg")
 
262
//            .arg(DIGITS_STR(3, 1)).arg(DIGITS_STR(1, 1)).arg(DIGITS_STR(3, 1));
 
263
//    validResults << QString("advancedrename_testimage_%1_T214536_%2_Nikon D50_%3.jpg")
 
264
//            .arg(DIGITS_STR(4, 1)).arg(DIGITS_STR(2, 1)).arg(DIGITS_STR(4, 1));
 
265
//
 
266
//    QTime t1;
 
267
//    t1.setHMS(10, 00, 12);
 
268
//
 
269
//    QTime t2;
 
270
//    t2.setHMS(21, 45, 36);
 
271
//
 
272
//    QDateTime date = QDateTime::currentDateTime();
 
273
//    date.setTime(t1);
 
274
//    settings.dateTime = date;
 
275
//
 
276
//    QStringList results;
 
277
//    results << parser.parse(settings);
 
278
//    results << parser.parse(settings);
 
279
//    date.setTime(t2);
 
280
//    settings.dateTime = date;
 
281
//    results << parser.parse(settings);
 
282
//    results << parser.parse(settings);
 
283
//    results << parser.parse(settings);
 
284
//
 
285
//    QCOMPARE(results, validResults);
 
286
//
 
287
//    // --------------------------------------------------------
 
288
//
 
289
//    settings.parseString = QString("[file]{unique:2}_T[date:hhmmss]{unique}_[cam]{unique:4}");
 
290
//    results.clear();
 
291
//    validResults.clear();
 
292
//    parser.reset();
 
293
//    date.setTime(t1);
 
294
//    settings.dateTime = date;
 
295
//    validResults << QString("advancedrename_testimage_T100012_Nikon D50.jpg");
 
296
//    validResults << QString("advancedrename_testimage_%1_T100012_%2_Nikon D50_%3.jpg")
 
297
//            .arg(DIGITS_STR(1, 2)).arg(DIGITS_STR(1, 1)).arg(DIGITS_STR(1, 4));
 
298
//    validResults << QString("advancedrename_testimage_%1_T214536_Nikon D50_%2.jpg")
 
299
//            .arg(DIGITS_STR(2, 2)).arg(DIGITS_STR(2, 4));
 
300
//    validResults << QString("advancedrename_testimage_%1_T214536_%2_Nikon D50_%3.jpg")
 
301
//            .arg(DIGITS_STR(3, 2)).arg(DIGITS_STR(1, 1)).arg(DIGITS_STR(3, 4));
 
302
//    validResults << QString("advancedrename_testimage_%1_T214536_%2_Nikon D50_%3.jpg")
 
303
//            .arg(DIGITS_STR(4, 2)).arg(DIGITS_STR(2, 1)).arg(DIGITS_STR(4, 4));
 
304
//
 
305
//    results << parser.parse(settings);
 
306
//    results << parser.parse(settings);
 
307
//    date.setTime(t2);
 
308
//    settings.dateTime = date;
 
309
//    results << parser.parse(settings);
 
310
//    results << parser.parse(settings);
 
311
//    results << parser.parse(settings);
 
312
//
 
313
//    QCOMPARE(results, validResults);
 
314
//
 
315
//#undef DIGITS_STR
 
316
//}
 
317
 
 
318
void AdvancedRenameWidgetTest::testReplaceModifier_data()
 
319
{
 
320
    QTest::addColumn<QString>("parseString");
 
321
    QTest::addColumn<QString>("result");
 
322
 
 
323
    QTest::newRow("[file]{replace:\"adv\",\"AAA\"}")
 
324
            << QString("[file]{replace:\"adv\",\"AAA\"}") << QString("AAAancedrename_testimage.jpg");
 
325
 
 
326
    QTest::newRow("[file]{replace:\"Adv\",\"AAA\"}")
 
327
            << QString("[file]{replace:\"Adv\",\"AAA\"}") << QString("advancedrename_testimage.jpg");
 
328
 
 
329
    QTest::newRow("[file]{replace:\"Adv\",\"AAA\",i}")
 
330
            << QString("[file]{replace:\"Adv\",\"AAA\",i}") << QString("AAAancedrename_testimage.jpg");
 
331
 
 
332
    QTest::newRow("[file]{replace:\"Adv\",\"AAA\",ri}")
 
333
            << QString("[file]{replace:\"Adv\",\"AAA\",ri}") << QString("AAAancedrename_testimage.jpg");
 
334
 
 
335
    QTest::newRow("[file]{replace:\"Adv\",\"AAA\",ir}")
 
336
            << QString("[file]{replace:\"Adv\",\"AAA\",ir}") << QString("AAAancedrename_testimage.jpg");
 
337
 
 
338
    QTest::newRow("[file]{replace:\"a.v\",\"AAA\"}")
 
339
            << QString("[file]{replace:\"a.v\",\"AAA\"}") << QString("advancedrename_testimage.jpg");
 
340
 
 
341
    QTest::newRow("[file]{replace:\"a.v\",\"AAA\",r}")
 
342
            << QString("[file]{replace:\"a.v\",\"AAA\",r}") << QString("AAAancedrename_testimage.jpg");
 
343
}
 
344
 
 
345
void AdvancedRenameWidgetTest::testReplaceModifier()
 
346
{
 
347
    QFETCH(QString,   parseString);
 
348
    QFETCH(QString,   result);
 
349
 
 
350
    QList<ParseSettings> files;
 
351
    ParseSettings ps;
 
352
    KUrl url(filePath);
 
353
    ps.fileUrl = KUrl(filePath);
 
354
    files << ps;
 
355
    AdvancedRenameManager manager(files);
 
356
    manager.parseFiles(parseString);
 
357
 
 
358
    QString parsed = manager.newName(filePath);
 
359
    QCOMPARE(parsed, result);
 
360
}
 
361
 
 
362
void AdvancedRenameWidgetTest::testRangeModifier_data()
 
363
{
 
364
    QTest::addColumn<QString>("parseString");
 
365
    QTest::addColumn<QString>("result");
 
366
 
 
367
    QDateTime curdate = QDateTime::currentDateTime();
 
368
 
 
369
    QTest::newRow("[file]{range:1}")    << QString("[file]{range:1}")   << QString("a.jpg");
 
370
    QTest::newRow("[file]{range:3}")    << QString("[file]{range:3}")   << QString("v.jpg");
 
371
    QTest::newRow("[file]{range:1,3}")  << QString("[file]{range:1,3}") << QString("adv.jpg");
 
372
    QTest::newRow("[file]{range:3,}")   << QString("[file]{range:3,}")  << QString("vancedrename_testimage.jpg");
 
373
}
 
374
 
 
375
void AdvancedRenameWidgetTest::testRangeModifier()
 
376
{
 
377
    QFETCH(QString,   parseString);
 
378
    QFETCH(QString,   result);
 
379
 
 
380
    QList<ParseSettings> files;
 
381
    ParseSettings ps;
 
382
    KUrl url(filePath);
 
383
    ps.fileUrl = KUrl(filePath);
 
384
    files << ps;
 
385
    AdvancedRenameManager manager(files);
 
386
    manager.parseFiles(parseString);
 
387
 
 
388
    QString parsed = manager.newName(filePath);
 
389
    QCOMPARE(parsed, result);
 
390
}
 
391
 
 
392
void AdvancedRenameWidgetTest::testDefaultValueModifier_data()
 
393
{
 
394
    QTest::addColumn<QString>("parseString");
 
395
    QTest::addColumn<QString>("result");
 
396
 
 
397
    QDateTime curdate = QDateTime::currentDateTime();
 
398
 
 
399
    QTest::newRow("[meta:Iptc.Application2.Keywords]_[file]") << QString("[meta:Iptc.Application2.Keywords]{default:\"Unknown\"}_[file]")
 
400
            << QString("Colca Canyon_advancedrename_testimage.jpg");
 
401
 
 
402
    QTest::newRow("[meta:Exif.GPSInfo.GPSAltitude]_[file]") << QString("[meta:Exif.GPSInfo.GPSAltitude]{default:\"Unknown\"}_[file]")
 
403
            << QString("Unknown_advancedrename_testimage.jpg");
 
404
}
 
405
 
 
406
void AdvancedRenameWidgetTest::testDefaultValueModifier()
 
407
{
 
408
    QFETCH(QString,   parseString);
 
409
    QFETCH(QString,   result);
 
410
 
 
411
    QList<ParseSettings> files;
 
412
    ParseSettings ps;
 
413
    KUrl url(filePath);
 
414
    ps.fileUrl = KUrl(filePath);
 
415
    files << ps;
 
416
    AdvancedRenameManager manager(files);
 
417
    manager.parseFiles(parseString);
 
418
 
 
419
    QString parsed = manager.newName(filePath);
 
420
    QCOMPARE(parsed, result);
 
421
}
 
422
 
 
423
void AdvancedRenameWidgetTest::testLowercaseModifier()
 
424
{
 
425
    ParseSettings settings;
 
426
    DefaultRenameParser parser;
 
427
 
 
428
    settings.fileUrl     = filePath;
 
429
    settings.parseString = "[file]{lower}";
 
430
 
 
431
    QString parsed = parser.parse(settings);
 
432
    QCOMPARE(parsed, fileName.toLower());
 
433
}
 
434
 
 
435
void AdvancedRenameWidgetTest::testEmptyParseString()
 
436
{
 
437
    ParseSettings settings;
 
438
    DefaultRenameParser parser;
 
439
 
 
440
    settings.fileUrl = filePath;
 
441
 
 
442
    // test for empty parser string
 
443
    settings.parseString.clear();
 
444
    QString parsed = parser.parse(settings);
 
445
    QCOMPARE(parsed, fileName);
 
446
 
 
447
    settings.parseString = QString("   ");
 
448
    parsed = parser.parse(settings);
 
449
    QCOMPARE(parsed, fileName);
 
450
}