MailJDTourDownloadDocsQualityTestsCoverage

Which source lines and branches the tests execute. Lines 91.5 %, branches 75.0 % (minimum 85 % and 72 %). main @ 399ffe3d · 21 October 2026 · pipeline 7238.

GCC Code Coverage Report

Directory: src/
Coverage: low: ≥ 0% medium: ≥ 75.0% high: ≥ 90.0%
Coverage Exec / Excl / Total
Lines: 86.8% 296 / 0 / 341
Functions: 96.8% 30 / 0 / 31
Branches: 71.2% 319 / 0 / 448
data/GeoData.cpp
Line Branch Exec Source
1 #include "GeoData.h"
2
3 #include <QCryptographicHash>
4 #include <QFile>
5 #include <QHash>
6 #include <QLoggingCategory>
7 #include <QMutex>
8 #include <QResource>
9 #include <QtEndian>
10 #include <algorithm>
11 #include <cstring>
12
13
4/7
✓ Branch 2 → 3 taken 6 times.
✓ Branch 2 → 8 taken 5 times.
✓ Branch 4 → 5 taken 6 times.
✗ Branch 4 → 8 not taken.
✓ Branch 5 → 6 taken 6 times.
✗ Branch 10 → 11 not taken.
✗ Branch 10 → 12 not taken.
 11 Q_LOGGING_CATEGORY(lcGeoData, "mailjd.contacts.places")
14
15 namespace {
16
17 constexpr char kMagic[] = "MJGEO1\n";
18 constexpr int kHeaderSize = 8 + 4 + 32; // magic, version, SHA-256
19
20 // Little-endian reader over one section; out-of-range reads flag `ok`.
21 struct Reader {
22 const char *data = nullptr;
23 qsizetype size = 0;
24 qsizetype at = 0;
25 bool ok = true;
26
27 206227 template <typename T> T read() {
28
4/8
unsigned char (anonymous namespace)::Reader::read<unsigned char>():
✗ Branch 2 → 3 not taken.
✓ Branch 2 → 4 taken 1694 times.
int (anonymous namespace)::Reader::read<int>():
✗ Branch 2 → 3 not taken.
✓ Branch 2 → 4 taken 62552 times.
unsigned int (anonymous namespace)::Reader::read<unsigned int>():
✗ Branch 2 → 3 not taken.
✓ Branch 2 → 4 taken 87899 times.
unsigned short (anonymous namespace)::Reader::read<unsigned short>():
✗ Branch 2 → 3 not taken.
✓ Branch 2 → 4 taken 54082 times.
 206227 if (at + qsizetype(sizeof(T)) > size) {
29 ✗ ok = false;
30 ✗ return T{};
31 }
32 T value;
33 206227 std::memcpy(&value, data + at, sizeof(T));
34 206227 at += sizeof(T);
35 206227 return qFromLittleEndian(value);
36 }
37 3451 QByteArray bytes(int count) {
38
1/2
✗ Branch 2 → 3 not taken.
✓ Branch 2 → 4 taken 3451 times.
 3451 if (at + count > size) {
39 ✗ ok = false;
40 ✗ return {};
41 }
42
1/1
✓ Branch 4 → 5 taken 3451 times.
 3451 const QByteArray out(data + at, count);
43 3451 at += count;
44 3451 return out;
45 3451 }
46 };
47
48 struct Section {
49 qsizetype offset = 0;
50 qsizetype size = 0;
51 };
52
53 // Letters without a decomposition (same table as KEY_LETTERS of
54 // scripts/geodata/build_geodata.py).
55 1455795 QString spelled(QChar c) {
56
9/10
✓ Branch 3 → 4 taken 28 times.
✓ Branch 3 → 9 taken 36 times.
✓ Branch 3 → 14 taken 35 times.
✓ Branch 3 → 19 taken 21 times.
✓ Branch 3 → 24 taken 201 times.
✓ Branch 3 → 29 taken 49 times.
✓ Branch 3 → 34 taken 84 times.
✗ Branch 3 → 39 not taken.
✓ Branch 3 → 44 taken 287 times.
✓ Branch 3 → 49 taken 1455054 times.
 1455795 switch (c.unicode()) {
57 56 case 0x00DF: return QStringLiteral("ss"); // ß
58 72 case 0x00F8: return QStringLiteral("o"); // ø
59 70 case 0x00E6: return QStringLiteral("ae"); // æ
60 42 case 0x0153: return QStringLiteral("oe"); // œ
61 402 case 0x0142: return QStringLiteral("l"); // ł
62 98 case 0x0111: return QStringLiteral("d"); // đ
63 168 case 0x00F0: return QStringLiteral("d"); // ð
64 ✗ case 0x00FE: return QStringLiteral("th"); // þ
65 574 case 0x0131: return QStringLiteral("i"); // ı
66 1455054 default: return QString(c);
67 }
68 }
69
70 1455879 bool isKeySpace(QChar c) {
71
3/4
✓ Branch 2 → 3 taken 7 times.
✓ Branch 2 → 12 taken 1455872 times.
✓ Branch 4 → 5 taken 7 times.
✗ Branch 4 → 12 not taken.
 1455886 static const QString spaces = QStringLiteral("-‐‑–—'’.,/()");
72
4/4
✓ Branch 13 → 14 taken 1440874 times.
✓ Branch 13 → 16 taken 15005 times.
✓ Branch 15 → 16 taken 90051 times.
✓ Branch 15 → 17 taken 1350823 times.
 1455879 return spaces.contains(c) || c.isSpace();
73 }
74
75 } // namespace
76
77 118865 QString GeoData::key(const QString &text) {
78 118865 QString out;
79
1/1
✓ Branch 3 → 4 taken 118865 times.
 118865 out.reserve(text.size());
80
1/1
✓ Branch 4 → 5 taken 118865 times.
 118865 const QString decomposed = text.normalized(QString::NormalizationForm_KD);
81
2/2
✓ Branch 27 → 7 taken 1475247 times.
✓ Branch 27 → 28 taken 118865 times.
 1594112 for (const QChar c : decomposed) {
82 1475247 const QChar::Category category = c.category();
83
4/6
✓ Branch 8 → 9 taken 1455795 times.
✓ Branch 8 → 11 taken 19452 times.
✓ Branch 9 → 10 taken 1455795 times.
✗ Branch 9 → 11 not taken.
✗ Branch 10 → 11 not taken.
✓ Branch 10 → 12 taken 1455795 times.
 1475247 if (category == QChar::Mark_NonSpacing || category == QChar::Mark_SpacingCombining ||
84 category == QChar::Mark_Enclosing)
85 19452 continue;
86
1/1
✓ Branch 13 → 14 taken 1455795 times.
 1455795 const QString lower = spelled(c.toLower());
87
2/2
✓ Branch 23 → 16 taken 1455879 times.
✓ Branch 23 → 24 taken 1455795 times.
 2911674 for (const QChar l : lower)
88
4/4
✓ Branch 16 → 17 taken 1455879 times.
✓ Branch 17 → 18 taken 105056 times.
✓ Branch 17 → 20 taken 1350823 times.
✓ Branch 21 → 22 taken 1455879 times.
 1455879 out += isKeySpace(l) ? QChar(QLatin1Char(' ')) : l;
89 1455795 }
90
1/1
✓ Branch 28 → 29 taken 118865 times.
 237730 return out.simplified();
91 118865 }
92
93 11 std::shared_ptr<const GeoData> GeoData::fromBytes(const QByteArray &file, QString *error, bool verify) {
94 4 const auto fail = [error](const QString &message) {
95
1/2
✓ Branch 2 → 3 taken 4 times.
✗ Branch 2 → 4 not taken.
 4 if (error)
96 4 *error = message;
97
6/6
✓ Branch 4 → 5 taken 4 times.
✓ Branch 8 → 9 taken 4 times.
✓ Branch 9 → 10 taken 4 times.
✓ Branch 10 → 11 taken 4 times.
✓ Branch 14 → 6 taken 4 times.
✓ Branch 14 → 15 taken 4 times.
 8 qCWarning(lcGeoData) << "Geodata rejected:" << message;
98 4 return std::shared_ptr<const GeoData>();
99 11 };
100
6/6
✓ Branch 3 → 4 taken 10 times.
✓ Branch 3 → 6 taken 1 time.
✓ Branch 5 → 6 taken 1 time.
✓ Branch 5 → 7 taken 9 times.
✓ Branch 8 → 9 taken 2 times.
✓ Branch 8 → 17 taken 9 times.
 11 if (file.size() < kHeaderSize + 4 || std::memcmp(file.constData(), kMagic, 8) != 0)
101
1/1
✓ Branch 12 → 13 taken 2 times.
 2 return fail(QStringLiteral("not a MailJD geodata file"));
102
1/1
✓ Branch 18 → 19 taken 9 times.
 9 const quint32 version = qFromLittleEndian<quint32>(file.constData() + 8);
103
2/4
✓ Branch 19 → 20 taken 9 times.
✗ Branch 19 → 29 not taken.
✗ Branch 20 → 21 not taken.
✓ Branch 20 → 29 taken 9 times.
 9 if (version != 1 && version != 2)
104 ✗ return fail(QStringLiteral("unsupported geodata version"));
105 // A v1 payload names its size in front (qUncompress); a forged size would
106 // allocate gigabytes before the data proves anything (S106-176).
107 9 constexpr quint32 kMaximumPayload = 256u * 1024 * 1024;
108
2/6
✗ Branch 29 → 30 not taken.
✓ Branch 29 → 36 taken 9 times.
✗ Branch 31 → 32 not taken.
✗ Branch 31 → 35 not taken.
✗ Branch 37 → 38 not taken.
✓ Branch 37 → 46 taken 9 times.
 9 if (version == 1 && (file.size() < kHeaderSize + 4 ||
109 ✗ qFromBigEndian<quint32>(file.constData() + kHeaderSize) > kMaximumPayload))
110 ✗ return fail(QStringLiteral("payload too large"));
111
1/1
✓ Branch 46 → 47 taken 9 times.
 9 auto data = std::make_shared<GeoData>();
112 // v2 is the raw payload: a resource-backed `file` is used in place.
113
3/9
✗ Branch 47 → 48 not taken.
✓ Branch 47 → 50 taken 9 times.
✗ Branch 48 → 49 not taken.
✗ Branch 49 → 53 not taken.
✓ Branch 52 → 53 taken 9 times.
✗ Branch 56 → 57 not taken.
✓ Branch 56 → 58 taken 9 times.
✗ Branch 521 → 522 not taken.
✗ Branch 521 → 523 not taken.
 27 data->m_payload = version == 1 ? qUncompress(file.mid(kHeaderSize))
114 18 : QByteArray::fromRawData(file.constData() + kHeaderSize, file.size() - kHeaderSize);
115
1/2
✗ Branch 60 → 61 not taken.
✓ Branch 60 → 69 taken 9 times.
 9 if (data->m_payload.isEmpty())
116 ✗ return fail(QStringLiteral("payload cannot be decompressed"));
117
12/16
✓ Branch 69 → 70 taken 3 times.
✓ Branch 69 → 77 taken 6 times.
✓ Branch 70 → 71 taken 3 times.
✓ Branch 73 → 74 taken 3 times.
✓ Branch 75 → 76 taken 2 times.
✓ Branch 75 → 77 taken 1 time.
✓ Branch 78 → 79 taken 3 times.
✓ Branch 78 → 80 taken 6 times.
✓ Branch 80 → 81 taken 3 times.
✓ Branch 80 → 82 taken 6 times.
✓ Branch 82 → 83 taken 2 times.
✓ Branch 82 → 91 taken 7 times.
✗ Branch 532 → 533 not taken.
✗ Branch 532 → 534 not taken.
✗ Branch 537 → 538 not taken.
✗ Branch 537 → 539 not taken.
 9 if (verify && QCryptographicHash::hash(data->m_payload, QCryptographicHash::Sha256) != file.mid(12, 32))
118
1/1
✓ Branch 86 → 87 taken 2 times.
 2 return fail(QStringLiteral("checksum mismatch"));
119
5/6
✓ Branch 91 → 92 taken 7 times.
✗ Branch 91 → 95 not taken.
✓ Branch 93 → 94 taken 1 time.
✓ Branch 93 → 95 taken 6 times.
✓ Branch 96 → 97 taken 1 time.
✓ Branch 96 → 99 taken 6 times.
 7 if (version == 2 && file.isDetached())
120 1 data->m_owner = file; // keeps a heap copy alive (files read with load())
121 7 Reader table{data->m_payload.constData(), data->m_payload.size()};
122
1/1
✓ Branch 103 → 104 taken 7 times.
 7 const quint32 sectionCount = table.read<quint32>();
123 7 QHash<QByteArray, Section> sections;
124
3/4
✓ Branch 126 → 127 taken 63 times.
✓ Branch 126 → 128 taken 7 times.
✓ Branch 127 → 105 taken 63 times.
✗ Branch 127 → 128 not taken.
 70 for (quint32 i = 0; i < sectionCount && table.ok; ++i) {
125
1/1
✓ Branch 105 → 106 taken 63 times.
 63 const QByteArray tag = table.bytes(4);
126 63 Section section;
127
1/1
✓ Branch 106 → 107 taken 63 times.
 63 section.offset = table.read<quint32>();
128
1/1
✓ Branch 107 → 108 taken 63 times.
 63 section.size = table.read<quint32>();
129
1/2
✗ Branch 110 → 111 not taken.
✓ Branch 110 → 119 taken 63 times.
 63 if (qint64(section.offset) + qint64(section.size) > data->m_payload.size())
130 ✗ return fail(QStringLiteral("section out of range"));
131
1/1
✓ Branch 119 → 120 taken 63 times.
 63 sections.insert(tag, section);
132 63 }
133 56 const auto reader = [&](const char *tag) {
134
1/1
✓ Branch 2 → 3 taken 56 times.
 56 const Section section = sections.value(QByteArray(tag, 4));
135 112 return Reader{data->m_payload.constData() + section.offset, section.size};
136 7 };
137 7 const Section strings = sections.value(QByteArrayLiteral("STR "));
138
1/1
✓ Branch 135 → 136 taken 7 times.
 7 data->m_strings = QByteArray::fromRawData(data->m_payload.constData() + strings.offset, strings.size);
139
2/4
✓ Branch 139 → 140 taken 7 times.
✗ Branch 139 → 142 not taken.
✓ Branch 140 → 141 taken 7 times.
✗ Branch 140 → 142 not taken.
 7 bool ok = table.ok && strings.size > 0;
140 {
141
1/1
✓ Branch 143 → 144 taken 7 times.
 7 Reader r = reader("CTRY");
142
1/1
✓ Branch 144 → 145 taken 7 times.
 7 const quint32 n = r.read<quint32>();
143
3/4
✓ Branch 170 → 171 taken 1694 times.
✓ Branch 170 → 172 taken 7 times.
✓ Branch 171 → 146 taken 1694 times.
✗ Branch 171 → 172 not taken.
 1701 for (quint32 i = 0; i < n && r.ok; ++i) {
144 1694 Country c;
145
1/1
✓ Branch 146 → 147 taken 1694 times.
 1694 c.iso2 = r.bytes(2);
146
1/1
✓ Branch 149 → 150 taken 1694 times.
 1694 c.iso3 = r.bytes(3);
147
1/1
✓ Branch 152 → 153 taken 1694 times.
 1694 c.labelRank = r.read<quint8>();
148
1/1
✓ Branch 153 → 154 taken 1694 times.
 1694 r.read<quint16>();
149
1/1
✓ Branch 154 → 155 taken 1694 times.
 1694 c.nameEn = r.read<quint32>();
150
1/1
✓ Branch 155 → 156 taken 1694 times.
 1694 c.nameDe = r.read<quint32>();
151
1/1
✓ Branch 156 → 157 taken 1694 times.
 1694 c.names = r.read<quint32>();
152
1/1
✓ Branch 157 → 158 taken 1694 times.
 1694 c.labelLat = r.read<qint32>();
153
1/1
✓ Branch 158 → 159 taken 1694 times.
 1694 c.labelLon = r.read<qint32>();
154
1/1
✓ Branch 159 → 160 taken 1694 times.
 1694 c.minLat = r.read<qint32>();
155
1/1
✓ Branch 160 → 161 taken 1694 times.
 1694 c.minLon = r.read<qint32>();
156
1/1
✓ Branch 161 → 162 taken 1694 times.
 1694 c.maxLat = r.read<qint32>();
157
1/1
✓ Branch 162 → 163 taken 1694 times.
 1694 c.maxLon = r.read<qint32>();
158
1/1
✓ Branch 163 → 164 taken 1694 times.
 1694 c.firstRing = r.read<quint32>();
159
1/1
✓ Branch 164 → 165 taken 1694 times.
 1694 c.ringCount = r.read<quint32>();
160
1/1
✓ Branch 165 → 166 taken 1694 times.
 1694 c.timeZone = r.read<quint32>();
161
1/1
✓ Branch 167 → 168 taken 1694 times.
 1694 data->m_countries.append(c);
162 1694 }
163
2/4
✓ Branch 172 → 173 taken 7 times.
✗ Branch 172 → 175 not taken.
✓ Branch 173 → 174 taken 7 times.
✗ Branch 173 → 175 not taken.
 7 ok = ok && r.ok;
164 }
165 {
166
1/1
✓ Branch 176 → 177 taken 7 times.
 7 Reader r = reader("RING");
167
1/1
✓ Branch 177 → 178 taken 7 times.
 7 const quint32 n = r.read<quint32>();
168 // A count beyond the section's own bytes is no reason to allocate.
169
1/1
✓ Branch 180 → 181 taken 7 times.
 7 data->m_rings.reserve(qMin<qsizetype>(n, (r.size - r.at) / 8));
170
3/4
✓ Branch 187 → 188 taken 11207 times.
✓ Branch 187 → 189 taken 7 times.
✓ Branch 188 → 182 taken 11207 times.
✗ Branch 188 → 189 not taken.
 11214 for (quint32 i = 0; i < n && r.ok; ++i)
171
3/3
✓ Branch 183 → 184 taken 11207 times.
✓ Branch 184 → 185 taken 11207 times.
✓ Branch 185 → 186 taken 11207 times.
 11207 data->m_rings.append({r.read<quint32>(), r.read<quint32>()});
172
2/4
✓ Branch 189 → 190 taken 7 times.
✗ Branch 189 → 192 not taken.
✓ Branch 190 → 191 taken 7 times.
✗ Branch 190 → 192 not taken.
 7 ok = ok && r.ok;
173 }
174 // Fixed-size records of the large tables are read in place (zero copy).
175 28 const auto fixedTable = [&](const char *tag, int recordSize, const char **base, int *count) {
176
1/1
✓ Branch 2 → 3 taken 28 times.
 28 Reader r = reader(tag);
177
1/1
✓ Branch 3 → 4 taken 28 times.
 28 const quint32 n = r.read<quint32>();
178
2/4
✓ Branch 4 → 5 taken 28 times.
✗ Branch 4 → 6 not taken.
✗ Branch 5 → 6 not taken.
✓ Branch 5 → 7 taken 28 times.
 28 if (!r.ok || 4 + qsizetype(n) * recordSize > r.size)
179 ✗ return false;
180 28 *base = r.data + 4;
181 28 *count = int(n);
182 28 return true;
183 7 };
184
3/5
✓ Branch 193 → 194 taken 7 times.
✗ Branch 193 → 199 not taken.
✓ Branch 196 → 197 taken 7 times.
✓ Branch 197 → 198 taken 7 times.
✗ Branch 197 → 199 not taken.
 7 ok = ok && fixedTable("PNTS", 8, &data->m_pointData, &data->m_pointCount);
185 {
186
1/1
✓ Branch 200 → 201 taken 7 times.
 7 Reader r = reader("ADM1");
187
1/1
✓ Branch 201 → 202 taken 7 times.
 7 const quint32 n = r.read<quint32>();
188
3/4
✓ Branch 212 → 213 taken 26194 times.
✓ Branch 212 → 214 taken 7 times.
✓ Branch 213 → 203 taken 26194 times.
✗ Branch 213 → 214 not taken.
 26201 for (quint32 i = 0; i < n && r.ok; ++i) {
189 26194 Admin1 a;
190
1/1
✓ Branch 203 → 204 taken 26194 times.
 26194 a.country = r.read<quint16>();
191
1/1
✓ Branch 204 → 205 taken 26194 times.
 26194 r.read<quint16>();
192
1/1
✓ Branch 205 → 206 taken 26194 times.
 26194 a.names = r.read<quint32>();
193
1/1
✓ Branch 206 → 207 taken 26194 times.
 26194 a.code = r.read<quint32>();
194
1/1
✓ Branch 207 → 208 taken 26194 times.
 26194 a.lat = r.read<qint32>();
195
1/1
✓ Branch 208 → 209 taken 26194 times.
 26194 a.lon = r.read<qint32>();
196
1/1
✓ Branch 210 → 211 taken 26194 times.
 26194 data->m_admin1.append(a);
197 }
198
2/4
✓ Branch 214 → 215 taken 7 times.
✗ Branch 214 → 217 not taken.
✓ Branch 215 → 216 taken 7 times.
✗ Branch 215 → 217 not taken.
 7 ok = ok && r.ok;
199 }
200
3/5
✓ Branch 218 → 219 taken 7 times.
✗ Branch 218 → 224 not taken.
✓ Branch 221 → 222 taken 7 times.
✓ Branch 222 → 223 taken 7 times.
✗ Branch 222 → 224 not taken.
 7 ok = ok && fixedTable("CITY", 28, &data->m_cityData, &data->m_cityCount);
201 {
202
1/1
✓ Branch 225 → 226 taken 7 times.
 7 Reader r = reader("TZ ");
203
1/1
✓ Branch 226 → 227 taken 7 times.
 7 const quint32 n = r.read<quint32>();
204
3/4
✓ Branch 232 → 233 taken 2744 times.
✓ Branch 232 → 234 taken 7 times.
✓ Branch 233 → 228 taken 2744 times.
✗ Branch 233 → 234 not taken.
 2751 for (quint32 i = 0; i < n && r.ok; ++i)
205
2/2
✓ Branch 229 → 230 taken 2744 times.
✓ Branch 230 → 231 taken 2744 times.
 2744 data->m_timeZones.append(r.read<quint32>());
206
2/4
✓ Branch 234 → 235 taken 7 times.
✗ Branch 234 → 237 not taken.
✓ Branch 235 → 236 taken 7 times.
✗ Branch 235 → 237 not taken.
 7 ok = ok && r.ok;
207 }
208
3/5
✓ Branch 238 → 239 taken 7 times.
✗ Branch 238 → 244 not taken.
✓ Branch 241 → 242 taken 7 times.
✓ Branch 242 → 243 taken 7 times.
✗ Branch 242 → 244 not taken.
 7 ok = ok && fixedTable("POST", 20, &data->m_postalData, &data->m_postalCount);
209
3/5
✓ Branch 245 → 246 taken 7 times.
✗ Branch 245 → 251 not taken.
✓ Branch 248 → 249 taken 7 times.
✓ Branch 249 → 250 taken 7 times.
✗ Branch 249 → 251 not taken.
 7 ok = ok && fixedTable("NAME", 8, &data->m_nameData, &data->m_nameCount);
210
1/2
✗ Branch 252 → 253 not taken.
✓ Branch 252 → 261 taken 7 times.
 7 if (!ok)
211 ✗ return fail(QStringLiteral("truncated section"));
212 // S106-176: every index into another section is checked before use (the
213 // accessors index without bounds checks), and the string table ends with
214 // NUL — string() and keyBytes() read up to one.
215
4/7
✓ Branch 263 → 264 taken 7 times.
✗ Branch 263 → 267 not taken.
✓ Branch 265 → 266 taken 7 times.
✗ Branch 266 → 267 not taken.
✓ Branch 266 → 268 taken 7 times.
✗ Branch 269 → 270 not taken.
✓ Branch 269 → 278 taken 7 times.
 7 if (data->m_strings.isEmpty() || data->m_strings.back() != '\0')
216 ✗ return fail(QStringLiteral("string table not terminated"));
217 7 const qint64 rings = data->m_rings.size();
218
2/2
✓ Branch 296 → 284 taken 1694 times.
✓ Branch 296 → 297 taken 7 times.
 1701 for (const Country &c : std::as_const(data->m_countries))
219
1/2
✗ Branch 285 → 286 not taken.
✓ Branch 285 → 294 taken 1694 times.
 1694 if (qint64(c.firstRing) + qint64(c.ringCount) > rings)
220 ✗ return fail(QStringLiteral("country ring out of range"));
221
2/2
✓ Branch 314 → 301 taken 11207 times.
✓ Branch 314 → 315 taken 7 times.
 11214 for (const Ring &ring : std::as_const(data->m_rings))
222
1/2
✗ Branch 303 → 304 not taken.
✓ Branch 303 → 312 taken 11207 times.
 11207 if (qint64(ring.firstPoint) + qint64(ring.pointCount) > data->m_pointCount)
223 ✗ return fail(QStringLiteral("ring point out of range"));
224 7 const qint64 countries = data->m_countries.size();
225
2/2
✓ Branch 333 → 321 taken 26194 times.
✓ Branch 333 → 334 taken 7 times.
 26201 for (const Admin1 &a : std::as_const(data->m_admin1))
226
1/2
✗ Branch 322 → 323 not taken.
✓ Branch 322 → 331 taken 26194 times.
 26194 if (a.country >= countries)
227 ✗ return fail(QStringLiteral("region country out of range"));
228
2/2
✓ Branch 359 → 335 taken 1196139 times.
✓ Branch 359 → 360 taken 7 times.
 1196146 for (int i = 0; i < data->m_cityCount; ++i) {
229
1/1
✓ Branch 336 → 337 taken 1196139 times.
 1196139 const City c = data->city(i);
230
5/8
✓ Branch 337 → 338 taken 1196139 times.
✗ Branch 337 → 346 not taken.
✓ Branch 338 → 339 taken 1193521 times.
✓ Branch 338 → 342 taken 2618 times.
✓ Branch 341 → 342 taken 1193521 times.
✗ Branch 341 → 346 not taken.
✗ Branch 348 → 349 not taken.
✓ Branch 348 → 357 taken 1196139 times.
 2392278 if (c.country >= countries || (c.admin1 != 0xFFFF && c.admin1 >= data->m_admin1.size()) ||
231
2/4
✓ Branch 342 → 343 taken 1196139 times.
✗ Branch 342 → 347 not taken.
✗ Branch 345 → 346 not taken.
✓ Branch 345 → 347 taken 1196139 times.
 1196139 (c.timeZone != 0xFFFF && c.timeZone >= data->m_timeZones.size()))
232 ✗ return fail(QStringLiteral("city reference out of range"));
233 }
234
2/2
✓ Branch 374 → 361 taken 116732 times.
✓ Branch 374 → 375 taken 7 times.
 116739 for (int i = 0; i < data->m_postalCount; ++i)
235
2/3
✓ Branch 362 → 363 taken 116732 times.
✗ Branch 363 → 364 not taken.
✓ Branch 363 → 372 taken 116732 times.
 116732 if (data->postal(i).country >= countries)
236 ✗ return fail(QStringLiteral("postal country out of range"));
237
2/2
✓ Branch 390 → 376 taken 3162474 times.
✓ Branch 390 → 391 taken 7 times.
 3162481 for (int i = 0; i < data->m_nameCount; ++i)
238
2/3
✓ Branch 377 → 378 taken 3162474 times.
✗ Branch 379 → 380 not taken.
✓ Branch 379 → 388 taken 3162474 times.
 3162474 if (data->nameEntry(i).city >= quint32(data->m_cityCount))
239 ✗ return fail(QStringLiteral("name city out of range"));
240 // Small indexes built at load: countries (≈ 3,000 names) and regions.
241 // A name shared by several entries (a territory carries its sovereign's
242 // names) belongs to the entry with the most prominent label.
243
2/2
✓ Branch 431 → 392 taken 1694 times.
✓ Branch 431 → 432 taken 7 times.
 1701 for (int i = 0; i < data->m_countries.size(); ++i) {
244 1694 const Country &c = data->m_countries.at(i);
245
2/2
✓ Branch 395 → 396 taken 1694 times.
✓ Branch 399 → 400 taken 1694 times.
 1694 QStringList names = data->string(c.names).split(QLatin1Char('|'), Qt::SkipEmptyParts);
246
4/4
✓ Branch 401 → 402 taken 1694 times.
✓ Branch 402 → 403 taken 1694 times.
✓ Branch 403 → 404 taken 1694 times.
✓ Branch 404 → 405 taken 1694 times.
 1694 names << QString::fromLatin1(c.iso2) << QString::fromLatin1(c.iso3);
247
4/4
✓ Branch 407 → 408 taken 1694 times.
✓ Branch 408 → 409 taken 1694 times.
✓ Branch 426 → 410 taken 16884 times.
✓ Branch 426 → 427 taken 1694 times.
 18578 for (const QString &name : names) {
248
1/1
✓ Branch 411 → 412 taken 16884 times.
 16884 const QString k = key(name);
249 16884 const int existing = data->m_countryKeys.value(k, -1);
250
6/6
✓ Branch 414 → 415 taken 3500 times.
✓ Branch 414 → 418 taken 13384 times.
✓ Branch 417 → 418 taken 7 times.
✓ Branch 417 → 419 taken 3493 times.
✓ Branch 420 → 421 taken 13391 times.
✓ Branch 420 → 423 taken 3493 times.
 16884 if (existing < 0 || data->m_countries.at(existing).labelRank > c.labelRank)
251
1/1
✓ Branch 422 → 423 taken 13391 times.
 13391 data->m_countryKeys.insert(k, i);
252 16884 }
253 1694 }
254
2/2
✓ Branch 442 → 433 taken 116732 times.
✓ Branch 442 → 443 taken 7 times.
 116739 for (int i = 0; i < data->m_postalCount; ++i) {
255
1/1
✓ Branch 434 → 435 taken 116732 times.
 116732 const int country = data->postal(i).country;
256 116732 auto range = data->m_postalRanges.value(country, {i, i});
257 116732 range.second = i + 1;
258
1/1
✓ Branch 439 → 440 taken 116732 times.
 116732 data->m_postalRanges.insert(country, range);
259 }
260
2/2
✓ Branch 477 → 444 taken 26194 times.
✓ Branch 477 → 478 taken 7 times.
 26201 for (int i = 0; i < data->m_admin1.size(); ++i) {
261 26194 const Admin1 &a = data->m_admin1.at(i);
262
6/6
✓ Branch 447 → 448 taken 26194 times.
✓ Branch 451 → 452 taken 26194 times.
✓ Branch 453 → 454 taken 26194 times.
✓ Branch 454 → 455 taken 26194 times.
✓ Branch 472 → 456 taken 89873 times.
✓ Branch 472 → 473 taken 26194 times.
 116067 for (const QString &name : data->string(a.names).split(QLatin1Char('|'), Qt::SkipEmptyParts))
263
6/6
✓ Branch 458 → 459 taken 89873 times.
✓ Branch 461 → 462 taken 89873 times.
✓ Branch 462 → 463 taken 89873 times.
✓ Branch 463 → 464 taken 89873 times.
✓ Branch 464 → 465 taken 89873 times.
✓ Branch 465 → 466 taken 89873 times.
 116067 data->m_admin1Keys[QString::number(a.country) + QLatin1Char('|') + key(name)].append(i);
264 }
265
9/9
✓ Branch 478 → 479 taken 7 times.
✓ Branch 482 → 483 taken 7 times.
✓ Branch 483 → 484 taken 7 times.
✓ Branch 486 → 487 taken 7 times.
✓ Branch 487 → 488 taken 7 times.
✓ Branch 489 → 490 taken 7 times.
✓ Branch 490 → 491 taken 7 times.
✓ Branch 497 → 480 taken 7 times.
✓ Branch 497 → 498 taken 7 times.
 14 qCInfo(lcGeoData) << "Geodata loaded:" << data->m_countries.size() << "countries," << data->m_cityCount << "cities,"
266
2/2
✓ Branch 492 → 493 taken 7 times.
✓ Branch 493 → 494 taken 7 times.
 7 << data->m_postalCount << "postal codes";
267 7 return data;
268 9 }
269
270 4 std::shared_ptr<const GeoData> GeoData::load(const QString &path, QString *error) {
271
1/1
✓ Branch 2 → 3 taken 4 times.
 4 QFile file(path);
272
2/3
✓ Branch 4 → 5 taken 4 times.
✓ Branch 5 → 6 taken 4 times.
✗ Branch 5 → 12 not taken.
 4 if (!file.open(QIODevice::ReadOnly)) {
273
1/2
✗ Branch 6 → 7 not taken.
✓ Branch 6 → 11 taken 4 times.
 4 if (error)
274 ✗ *error = file.errorString();
275 4 return {};
276 }
277 ✗ return fromBytes(file.readAll(), error);
278 4 }
279
280 98 std::shared_ptr<const GeoData> GeoData::builtIn() {
281
3/4
✓ Branch 2 → 3 taken 10 times.
✓ Branch 2 → 7 taken 88 times.
✓ Branch 4 → 5 taken 10 times.
✗ Branch 4 → 7 not taken.
 98 static QMutex mutex;
282
3/4
✓ Branch 7 → 8 taken 10 times.
✓ Branch 7 → 12 taken 88 times.
✓ Branch 9 → 10 taken 10 times.
✗ Branch 9 → 12 not taken.
 98 static std::shared_ptr<const GeoData> data;
283 static bool tried = false;
284 98 QMutexLocker lock(&mutex);
285
2/2
✓ Branch 13 → 14 taken 10 times.
✓ Branch 13 → 48 taken 88 times.
 98 if (!tried) {
286 10 tried = true;
287 // The resource is stored uncompressed (rcc -no-compress) and lives for
288 // the whole process: it is used without a copy. Its checksum is verified
289 // by test_place_gazetteer, not on every start (S103.0.5 numbers).
290
2/2
✓ Branch 14 → 15 taken 10 times.
✓ Branch 18 → 19 taken 10 times.
 20 QResource resource(QStringLiteral(":/geo/world.mjgeo"));
291
7/8
✓ Branch 22 → 23 taken 10 times.
✓ Branch 23 → 24 taken 6 times.
✓ Branch 23 → 27 taken 4 times.
✓ Branch 24 → 25 taken 6 times.
✓ Branch 25 → 26 taken 6 times.
✗ Branch 25 → 27 not taken.
✓ Branch 28 → 29 taken 6 times.
✓ Branch 28 → 37 taken 4 times.
 10 if (resource.isValid() && resource.compressionAlgorithm() == QResource::NoCompression)
292
4/4
✓ Branch 29 → 30 taken 6 times.
✓ Branch 30 → 31 taken 6 times.
✓ Branch 31 → 32 taken 6 times.
✓ Branch 32 → 33 taken 6 times.
 12 data = fromBytes(QByteArray::fromRawData(reinterpret_cast<const char *>(resource.data()), resource.size()),
293 6 nullptr, false);
294 else
295
1/1
✓ Branch 40 → 41 taken 4 times.
 4 data = load(QStringLiteral(":/geo/world.mjgeo"));
296 10 }
297 196 return data;
298 98 }
299
300 36614 QString GeoData::string(quint32 offset) const {
301
1/2
✗ Branch 3 → 4 not taken.
✓ Branch 3 → 5 taken 36614 times.
 36614 if (offset >= quint32(m_strings.size()))
302 ✗ return {};
303
1/1
✓ Branch 7 → 8 taken 36614 times.
 36614 return QString::fromUtf8(m_strings.constData() + offset);
304 }
305
306 31235 const char *GeoData::keyBytes(quint32 offset) const {
307
1/2
✓ Branch 3 → 4 taken 31235 times.
✗ Branch 3 → 6 not taken.
 31235 return offset < quint32(m_strings.size()) ? m_strings.constData() + offset : "";
308 }
309
310 1122 QString GeoData::timeZoneName(quint16 index) const {
311
1/2
✓ Branch 3 → 4 taken 1122 times.
✗ Branch 3 → 6 not taken.
 1122 return index < m_timeZones.size() ? string(m_timeZones.at(index)) : QString();
312 }
313
314
1/1
✓ Branch 2 → 3 taken 644 times.
 644 int GeoData::countryIndex(const QString &name) const { return m_countryKeys.value(key(name), -1); }
315
316 namespace {
317 16224073 template <typename T> T at(const char *base, int offset) {
318 T value;
319 16224073 std::memcpy(&value, base + offset, sizeof(T));
320 16224073 return qFromLittleEndian(value);
321 }
322 } // namespace
323
324 104186 GeoData::Point GeoData::point(int index) const {
325 104186 const char *r = m_pointData + qsizetype(index) * 8;
326 104186 return {at<qint32>(r, 0), at<qint32>(r, 4)};
327 }
328
329 1207432 GeoData::City GeoData::city(int index) const {
330 1207432 const char *r = m_cityData + qsizetype(index) * 28;
331 1207432 City c;
332 1207432 c.lat = at<qint32>(r, 0);
333 1207432 c.lon = at<qint32>(r, 4);
334 1207432 c.country = at<quint16>(r, 8);
335 1207432 c.admin1 = at<quint16>(r, 10);
336 1207432 c.population = at<quint32>(r, 12);
337 1207432 c.name = at<quint32>(r, 16);
338 1207432 c.timeZone = at<quint16>(r, 24);
339 1207432 return c;
340 }
341
342 236373 GeoData::Postal GeoData::postal(int index) const {
343 236373 const char *r = m_postalData + qsizetype(index) * 20;
344 236373 Postal p;
345 236373 p.country = at<quint16>(r, 0);
346 236373 p.code = at<quint32>(r, 4);
347 236373 p.place = at<quint32>(r, 8);
348 236373 p.lat = at<qint32>(r, 12);
349 236373 p.lon = at<qint32>(r, 16);
350 236373 return p;
351 }
352
353 3190906 GeoData::NameEntry GeoData::nameEntry(int index) const {
354 3190906 const char *r = m_nameData + qsizetype(index) * 8;
355 3190906 return {at<quint32>(r, 0), at<quint32>(r, 4)};
356 }
357
358 // First NAME entry whose key is not less than `wanted` (binary search over
359 // the UTF-8 bytes, the builder's sort order).
360 1180 int GeoData::firstName(const QByteArray &wanted) const {
361 1180 int low = 0;
362 1180 int high = m_nameCount;
363
2/2
✓ Branch 9 → 3 taken 22156 times.
✓ Branch 9 → 10 taken 1180 times.
 23336 while (low < high) {
364 22156 const int mid = low + (high - low) / 2;
365
2/2
✓ Branch 6 → 7 taken 11193 times.
✓ Branch 6 → 8 taken 10963 times.
 22156 if (std::strcmp(keyBytes(nameEntry(mid).key), wanted.constData()) < 0)
366 11193 low = mid + 1;
367 else
368 10963 high = mid;
369 }
370 1180 return low;
371 }
372
373 1180 QList<int> GeoData::citiesNamed(const QString &cityKey, int limit) const {
374 1180 QList<int> out;
375
1/1
✓ Branch 2 → 3 taken 1180 times.
 1180 const QByteArray wanted = cityKey.toUtf8();
376
6/7
✓ Branch 3 → 4 taken 1180 times.
✓ Branch 14 → 15 taken 6278 times.
✗ Branch 14 → 18 not taken.
✓ Branch 16 → 17 taken 6276 times.
✓ Branch 16 → 18 taken 2 times.
✓ Branch 19 → 5 taken 6276 times.
✓ Branch 19 → 20 taken 2 times.
 6278 for (int i = firstName(wanted); i < m_nameCount && out.size() < limit; ++i) {
377
1/1
✓ Branch 5 → 6 taken 6276 times.
 6276 const NameEntry entry = nameEntry(i);
378
2/2
✓ Branch 8 → 9 taken 1178 times.
✓ Branch 8 → 10 taken 5098 times.
 6276 if (std::strcmp(keyBytes(entry.key), wanted.constData()) != 0)
379 1178 break;
380
1/2
✓ Branch 11 → 12 taken 5098 times.
✗ Branch 11 → 13 not taken.
 5098 if (!out.contains(int(entry.city)))
381
1/1
✓ Branch 12 → 13 taken 5098 times.
 5098 out.append(int(entry.city));
382 }
383 // Cities are stored by population: the smallest index is the largest city.
384
3/3
✓ Branch 20 → 21 taken 1180 times.
✓ Branch 21 → 22 taken 1180 times.
✓ Branch 22 → 23 taken 1180 times.
 1180 std::sort(out.begin(), out.end());
385 1180 return out;
386 1180 }
387
388 ✗ QList<int> GeoData::citiesWithPrefix(const QString &prefix, int limit) const {
389 ✗ QList<int> out;
390 ✗ const QByteArray wanted = key(prefix).toUtf8();
391 ✗ if (wanted.isEmpty())
392 ✗ return out;
393 ✗ QList<int> candidates;
394 ✗ for (int i = firstName(wanted); i < m_nameCount && candidates.size() < 400; ++i) {
395 ✗ const NameEntry entry = nameEntry(i);
396 ✗ if (std::strncmp(keyBytes(entry.key), wanted.constData(), size_t(wanted.size())) != 0)
397 ✗ break;
398 ✗ candidates.append(int(entry.city));
399 }
400 ✗ std::sort(candidates.begin(), candidates.end());
401 ✗ for (int city : candidates)
402 ✗ if (!out.contains(city) && out.size() < limit)
403 ✗ out.append(city);
404 ✗ return out;
405 ✗ }
406
407 5 int GeoData::admin1Index(int country, const QString &regionKey) const {
408
3/3
✓ Branch 4 → 5 taken 5 times.
✓ Branch 5 → 6 taken 5 times.
✓ Branch 6 → 7 taken 5 times.
 5 const QList<int> hits = m_admin1Keys.value(QString::number(country) + QLatin1Char('|') + regionKey);
409
1/2
✗ Branch 12 → 13 not taken.
✓ Branch 12 → 14 taken 5 times.
 10 return hits.isEmpty() ? -1 : hits.first();
410 5 }
411
412 223 int GeoData::postalIndex(int country, const QString &code) const {
413 // POST is sorted by country and code (builder order).
414 223 const auto range = m_postalRanges.value(country, {0, 0});
415
1/1
✓ Branch 4 → 5 taken 223 times.
 223 const QByteArray wanted = code.toUtf8();
416 223 int low = range.first;
417 223 int high = range.second;
418
2/2
✓ Branch 12 → 6 taken 2606 times.
✓ Branch 12 → 13 taken 223 times.
 2829 while (low < high) {
419 2606 const int mid = low + (high - low) / 2;
420
3/3
✓ Branch 7 → 8 taken 2606 times.
✓ Branch 9 → 10 taken 1147 times.
✓ Branch 9 → 11 taken 1459 times.
 2606 if (std::strcmp(keyBytes(postal(mid).code), wanted.constData()) < 0)
421 1147 low = mid + 1;
422 else
423 1459 high = mid;
424 }
425
7/7
✓ Branch 13 → 14 taken 197 times.
✓ Branch 13 → 19 taken 26 times.
✓ Branch 15 → 16 taken 197 times.
✓ Branch 17 → 18 taken 106 times.
✓ Branch 17 → 19 taken 91 times.
✓ Branch 20 → 21 taken 106 times.
✓ Branch 20 → 22 taken 117 times.
 223 if (low < range.second && std::strcmp(keyBytes(postal(low).code), wanted.constData()) == 0)
426 106 return low;
427 117 return -1;
428 223 }
429