← Back to branch summary

~timo-jyrinki/ubuntu/trusty/maliit-framework/fix_qt52

« back to all changes in this revision

Viewing changes to tests/ut_maliit_attributeextension/ut_maliit_attributeextension.cpp

  • Committer: Package Import Robot
  • Author(s): Ricardo Salveti de Araujo
  • Date: 2013-07-23 19:47:04 UTC
  • mto: This revision was merged to the branch mainline in revision 8.
  • Revision ID: package-import@ubuntu.com-20130723194704-0o18p2ao0x9sa1zx
Tags: upstream-0.99.0+git20130615+97e8335
Import upstream version 0.99.0+git20130615+97e8335

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/ut_maliit_attributeextension/ut_maliit_attributeextension.cpp
1
 
#include <QtCore/QString>
2
 
#include <QtTest/QtTest>
3
 
 
4
 
#include <maliit/attributeextension.h>
5
 
#include <tr1/memory>
6
 
#include <algorithm>
7
 
 
8
 
typedef std::tr1::shared_ptr<Maliit::AttributeExtension> SharedAttributeExtension;
9
 
 
10
 
typedef std::vector<std::pair<QString, QVariant> > KeyValueContainer;
11
 
 
12
 
Q_DECLARE_METATYPE(KeyValueContainer)
13
 
 
14
 
namespace {
15
 
    SharedAttributeExtension createDefault()
16
 
    {
17
 
        return SharedAttributeExtension(new Maliit::AttributeExtension(QString()));
18
 
    }
19
 
 
20
 
    int id(const SharedAttributeExtension &ptr)
21
 
    {
22
 
        return ptr->id();
23
 
    }
24
 
 
25
 
    template<typename Container>
26
 
    bool containsNoDuplicates(const Container &container)
27
 
    {
28
 
        std::vector<typename Container::value_type> copy(container.begin(), container.end());
29
 
        std::sort(copy.begin(), copy.end());
30
 
        return std::unique(copy.begin(), copy.end()) == copy.end();
31
 
    }
32
 
 
33
 
    struct SetAttribute {
34
 
        explicit SetAttribute(const SharedAttributeExtension &newExtension) :
35
 
            extension(newExtension)
36
 
        {}
37
 
 
38
 
        void operator() (const std::pair<QString, QVariant> &keyValue)
39
 
        {
40
 
            extension->setAttribute(keyValue.first, keyValue.second);
41
 
        }
42
 
 
43
 
    private:
44
 
        SharedAttributeExtension extension;
45
 
    };
46
 
 
47
 
    struct CompareAttribute {
48
 
        explicit CompareAttribute(const SharedAttributeExtension &newExtension) :
49
 
            extension(newExtension)
50
 
        {}
51
 
 
52
 
        void operator() (const std::pair<QString, QVariant> &keyValue)
53
 
        {
54
 
            QCOMPARE(extension->attributes().value(keyValue.first), keyValue.second);
55
 
        }
56
 
 
57
 
    private:
58
 
        SharedAttributeExtension extension;
59
 
    };
60
 
 
61
 
    void compareAttributes(const SharedAttributeExtension &extension, const KeyValueContainer &result)
62
 
    {
63
 
        QCOMPARE(extension->attributes().size(), static_cast<int>(result.size()));
64
 
        std::for_each(result.begin(), result.end(), CompareAttribute(extension));
65
 
    }
66
 
}
67
 
 
68
 
class Ut_Maliit_AttributeExtension : public QObject
69
 
{
70
 
    Q_OBJECT
71
 
 
72
 
private Q_SLOTS:
73
 
    void testDefaultFilename();
74
 
    void testDefaultAttributes();
75
 
    void testFilename();
76
 
    void testIdsUnique();
77
 
    void testAttributes();
78
 
    void testAttributes_data();
79
 
};
80
 
 
81
 
void Ut_Maliit_AttributeExtension::testDefaultFilename()
82
 
{
83
 
    const SharedAttributeExtension subject = createDefault();
84
 
 
85
 
    QCOMPARE(subject->fileName(), QString());
86
 
}
87
 
 
88
 
void Ut_Maliit_AttributeExtension::testDefaultAttributes()
89
 
{
90
 
    const SharedAttributeExtension subject = createDefault();
91
 
 
92
 
    QVERIFY(subject->attributes().empty());
93
 
}
94
 
 
95
 
void Ut_Maliit_AttributeExtension::testFilename()
96
 
{
97
 
    const QString testName = QString::fromLatin1("TestName");
98
 
    const SharedAttributeExtension subject(new Maliit::AttributeExtension(testName));
99
 
 
100
 
    QCOMPARE(subject->fileName(), testName);
101
 
}
102
 
 
103
 
void Ut_Maliit_AttributeExtension::testIdsUnique()
104
 
{
105
 
    std::vector<SharedAttributeExtension> subjects(10);
106
 
    std::generate(subjects.begin(), subjects.end(), &createDefault);
107
 
 
108
 
    std::vector<int> ids(subjects.size());
109
 
    std::transform(subjects.begin(), subjects.end(), ids.begin(), &id);
110
 
 
111
 
    QVERIFY(containsNoDuplicates(ids));
112
 
}
113
 
 
114
 
void Ut_Maliit_AttributeExtension::testAttributes()
115
 
{
116
 
    QFETCH(KeyValueContainer, attributes);
117
 
    QFETCH(KeyValueContainer, result);
118
 
 
119
 
    const SharedAttributeExtension subject = createDefault();
120
 
    std::for_each(attributes.begin(), attributes.end(), SetAttribute(subject));
121
 
 
122
 
    compareAttributes(subject, result);
123
 
}
124
 
 
125
 
void Ut_Maliit_AttributeExtension::testAttributes_data()
126
 
{
127
 
    QTest::addColumn<KeyValueContainer>("attributes");
128
 
    QTest::addColumn<KeyValueContainer>("result");
129
 
 
130
 
    KeyValueContainer attributes;
131
 
    attributes.push_back(std::make_pair(QString::fromLatin1("TestKey1"), QVariant(1000)));
132
 
    attributes.push_back(std::make_pair(QString::fromLatin1("TestKey2"), QVariant(2000)));
133
 
    attributes.push_back(std::make_pair(QString::fromLatin1("TestKey3"), QVariant(3000)));
134
 
    KeyValueContainer result(attributes.begin(), attributes.end());
135
 
 
136
 
    QTest::newRow("add") << attributes << result;
137
 
 
138
 
    attributes.push_back(std::make_pair(QString::fromLatin1("TestKey1"), QVariant(1100)));
139
 
    attributes.push_back(std::make_pair(QString::fromLatin1("TestKey2"), QVariant(2000)));
140
 
    attributes.push_back(std::make_pair(QString::fromLatin1("TestKey3"), QVariant(3000)));
141
 
 
142
 
    result.assign(attributes.begin() + 3, attributes.end());
143
 
 
144
 
    QTest::newRow("change") << attributes << result;
145
 
 
146
 
    // One cannot remove attributes just override them with an empty value
147
 
    attributes.push_back(std::make_pair(QString::fromLatin1("TestKey1"), QVariant()));
148
 
    attributes.push_back(std::make_pair(QString::fromLatin1("TestKey2"), QVariant()));
149
 
 
150
 
    result.assign(attributes.begin() + 5, attributes.end());
151
 
 
152
 
    QTest::newRow("remove") << attributes << result;
153
 
}
154
 
 
155
 
QTEST_APPLESS_MAIN(Ut_Maliit_AttributeExtension)
156
 
 
157
 
#include "ut_maliit_attributeextension.moc"