21 #define MINIMAL_CONTAINER_TESTS
24 #include "cutelee_paths.h"
26 #include "test_macros.h"
28 #include "coverageobject.h"
29 #if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
30 #include <QtCore/QLinkedList>
32 #include <QtCore/QQueue>
33 #include <QtCore/QStack>
34 #include <QtCore/QVariant>
35 #include <QtTest/QTest>
44 void testContainer_Builtins();
47 TestGenericContainers::TestGenericContainers(QObject *parent)
52 template <
typename T> QVector<T> getItems()
61 template <> QVector<QString> getItems<QString>()
63 QVector<QString> items;
64 Q_FOREACH (
const int item, getItems<int>())
65 items.push_back(
QString::number(item));
71 QVector<QVariant> items;
72 Q_FOREACH (
const int item, getItems<int>())
73 items.push_back(item);
77 template <> QVector<QDateTime> getItems<QDateTime>()
79 QVector<QDateTime> items;
81 for (
auto i = 0; i < 3; ++i) {
83 d.setMSecsSinceEpoch(0);
90 template <> QVector<QObject *> getItems<QObject *>()
92 QVector<QObject *> items;
94 for (
auto i = 9; i > 4; i -= 2) {
95 auto obj =
new QObject;
97 obj->setObjectName(QString::number(i));
104 static void populateSequential(Container &container)
106 Q_FOREACH (
const typename Container::value_type item,
107 getItems<typename Container::value_type>())
108 container.push_back(item);
110 static void populateAssociative(Container &container)
113 Q_FOREACH (
const typename Container::mapped_type item,
114 getItems<typename Container::mapped_type>())
115 container[i++] = item;
120 static void populateSequential(QSet<T> &container)
122 Q_FOREACH (
const T item, getItems<T>())
123 container.insert(item);
128 static void populateAssociative(QMap<QString, T> &container)
131 Q_FOREACH (
const T item, getItems<T>())
132 container.insert(QString::number(i++), item);
137 static void populateAssociative(QHash<QString, T> &container)
140 Q_FOREACH (
const T item, getItems<T>())
141 container.insert(QString::number(i++), item);
146 static void populateAssociative(std::map<QString, T> &container)
149 Q_FOREACH (
const T item, getItems<T>())
150 container[QString::number(i++)] = item;
154 template <
typename T>
QString getTemplate()
156 return QStringLiteral(
"{{ container.size }};{{ container.count }};{% for "
157 "item in container %}{{ item }},{% endfor %}");
160 template <>
QString getTemplate<QDateTime>()
162 return QStringLiteral(
"{{ container.size }};{{ container.count }};{% for "
163 "item in container %}{{ item|date }},{% endfor %}");
166 template <>
QString getTemplate<QObject *>()
168 return QStringLiteral(
169 "{{ container.size }};{{ container.count }};{% for item in container "
170 "%}{{ item.objectName }},{% endfor %}");
173 template <
typename T>
QString getAssociativeTemplate()
175 return QStringLiteral(
"{{ container.size }};{{ container.count }};{% for "
176 "item in container.values %}{{ item }},{% endfor %}");
179 template <>
QString getAssociativeTemplate<QDateTime>()
181 return QStringLiteral(
182 "{{ container.size }};{{ container.count }};{% for item in "
183 "container.values %}{{ item|date }},{% endfor %}");
186 template <>
QString getAssociativeTemplate<QObject *>()
188 return QStringLiteral(
189 "{{ container.size }};{{ container.count }};{% for item in "
190 "container.values %}{{ item.objectName }},{% endfor %}");
193 template <
typename T> QStringList getResults()
195 return {QStringLiteral(
"3;3;"), QStringLiteral(
"9,"), QStringLiteral(
"7,"),
196 QStringLiteral(
"5,")};
199 template <> QStringList getResults<QDateTime>()
201 return {QStringLiteral(
"3;3;"), QStringLiteral(
"Jan. 1, 1970,"),
202 QStringLiteral(
"Jan. 2, 1970,"), QStringLiteral(
"Jan. 3, 1970,")};
205 template <
typename Container,
typename T =
typename Container::value_type>
207 static void clean(Container &) {}
210 template <
typename Container,
typename T =
typename Container::mapped_type>
212 static void clean(Container &) {}
215 template <
typename Container>
217 static void clean(Container &c) { qDeleteAll(c); }
220 template <
typename Container>
222 static void clean(Container &c) { qDeleteAll(c); }
225 template <
typename T>
227 static void clean(std::map<T, QObject *> &c)
229 typename std::map<T, QObject *>::iterator it = c.begin();
230 const typename std::map<T, QObject *>::iterator end = c.end();
231 for (; it != end; ++it) {
238 template <
typename Container>
void cleanupSequential(Container c)
243 template <
typename Container>
void cleanupAssociative(Container c)
248 void testContainer(
const QString &stringTemplate,
250 const QStringList &expectedResults,
bool unordered)
257 c.
insert(QStringLiteral(
"container"), containerVariant);
259 auto t1 = engine.
newTemplate(stringTemplate, QStringLiteral(
"template1"));
261 auto result = t1->
render(&c);
263 QCOMPARE(result, expectedResults.join(
QString()));
265 QVERIFY(result.size() == expectedResults.join(
QString()).size());
266 Q_FOREACH (
const QString &expectedResult, expectedResults)
267 QVERIFY(result.contains(expectedResult));
270 auto t2 = engine.
newTemplate(QStringLiteral(
"-{{ container.doesnotexist }}-"),
271 QStringLiteral(
"template2"));
273 auto result2 = t2->
render(&c);
275 QCOMPARE(result2, QStringLiteral(
"--"));
278 template <
typename Container>
279 void doTestSequentialContainer(
bool unordered = {})
284 testContainer(getTemplate<typename Container::value_type>(),
285 QVariant::fromValue(container),
286 getResults<typename Container::value_type>(), unordered);
287 cleanupSequential(container);
290 template <
typename Container>
291 void doTestAssociativeContainer(
bool unordered = {})
296 testContainer(getAssociativeTemplate<typename Container::mapped_type>(),
297 QVariant::fromValue(container),
298 getResults<typename Container::mapped_type>(), unordered);
299 cleanupAssociative(container);
302 template <
typename T>
void doTestNonHashableContainers()
304 doTestSequentialContainer<QVector<T>>();
305 doTestSequentialContainer<QList<T>>();
306 #if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
307 doTestSequentialContainer<QLinkedList<T>>();
309 doTestSequentialContainer<QQueue<T>>();
310 doTestSequentialContainer<QStack<T>>();
311 doTestSequentialContainer<std::list<T>>();
312 #if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
313 doTestAssociativeContainer<QMap<qint32, T>>();
314 doTestAssociativeContainer<std::map<qint32, T>>();
315 doTestAssociativeContainer<QHash<qint32, T>>(
true);
317 #ifndef MINIMAL_CONTAINER_TESTS
318 doTestAssociativeContainer<QMap<qint16, T>>();
319 doTestAssociativeContainer<QMap<qint64, T>>();
320 doTestAssociativeContainer<QMap<quint16, T>>();
321 doTestAssociativeContainer<QMap<quint32, T>>();
322 doTestAssociativeContainer<QMap<quint64, T>>();
323 doTestAssociativeContainer<QMap<QString, T>>();
324 doTestAssociativeContainer<std::map<qint16, T>>();
325 doTestAssociativeContainer<std::map<qint64, T>>();
326 doTestAssociativeContainer<std::map<quint16, T>>();
327 doTestAssociativeContainer<std::map<quint32, T>>();
328 doTestAssociativeContainer<std::map<quint64, T>>();
329 doTestAssociativeContainer<std::map<QString, T>>();
330 doTestAssociativeContainer<QHash<qint16, T>>(
true);
331 doTestAssociativeContainer<QHash<qint64, T>>(
true);
332 doTestAssociativeContainer<QHash<quint16, T>>(
true);
333 doTestAssociativeContainer<QHash<quint32, T>>(
true);
334 doTestAssociativeContainer<QHash<quint64, T>>(
true);
335 doTestAssociativeContainer<QHash<QString, T>>(
true);
339 template <
typename T>
void doTestContainers()
341 doTestNonHashableContainers<T>();
342 doTestSequentialContainer<QSet<T>>(
true);
345 void TestGenericContainers::testContainer_Builtins()
347 doTestContainers<qint32>();
348 #ifndef MINIMAL_CONTAINER_TESTS
349 doTestContainers<qint16>();
350 doTestContainers<qint64>();
351 doTestContainers<quint16>();
352 doTestContainers<quint32>();
353 doTestContainers<quint64>();
354 doTestNonHashableContainers<float>();
355 doTestNonHashableContainers<double>();
356 doTestContainers<QString>();
357 doTestNonHashableContainers<QVariant>();
358 doTestNonHashableContainers<QDateTime>();
359 doTestContainers<QObject *>();
364 #include "testgenericcontainers.moc"
The Context class holds the context to render a Template with.
void insert(const QString &name, QObject *object)
Cutelee::Engine is the main entry point for creating Cutelee Templates.
void setPluginPaths(const QStringList &dirs)
Template newTemplate(const QString &content, const QString &name) const
QString render(Context *c) const