1 /**
2 * Orthanc - A Lightweight, RESTful DICOM Store
3 * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics
4 * Department, University Hospital of Liege, Belgium
5 * Copyright (C) 2017-2020 Osimis S.A., Belgium
6 *
7 * This program is free software: you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public License
9 * as published by the Free Software Foundation, either version 3 of
10 * the License, or (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this program. If not, see
19 * <http://www.gnu.org/licenses/>.
20 **/
21
22
23 #if ORTHANC_UNIT_TESTS_LINK_FRAMEWORK == 1
24 // Must be the first to be sure to use the Orthanc framework shared library
25 # include <OrthancFramework.h>
26 #endif
27
28 #if !defined(ORTHANC_ENABLE_PUGIXML)
29 # error ORTHANC_ENABLE_PUGIXML is not defined
30 #endif
31
32 #include "../Sources/EnumerationDictionary.h"
33
34 #include <gtest/gtest.h>
35
36 #include "../Sources/DicomFormat/DicomTag.h"
37 #include "../Sources/HttpServer/HttpToolbox.h"
38 #include "../Sources/Logging.h"
39 #include "../Sources/OrthancException.h"
40 #include "../Sources/Toolbox.h"
41
42 #if ORTHANC_SANDBOXED != 1
43 # include "../Sources/FileBuffer.h"
44 # include "../Sources/MetricsRegistry.h"
45 # include "../Sources/SystemToolbox.h"
46 # include "../Sources/TemporaryFile.h"
47 #endif
48
49 #include <ctype.h>
50
51
52 using namespace Orthanc;
53
54
TEST(Uuid,Generation)55 TEST(Uuid, Generation)
56 {
57 for (int i = 0; i < 10; i++)
58 {
59 std::string s = Toolbox::GenerateUuid();
60 ASSERT_TRUE(Toolbox::IsUuid(s));
61 }
62 }
63
TEST(Uuid,Test)64 TEST(Uuid, Test)
65 {
66 ASSERT_FALSE(Toolbox::IsUuid(""));
67 ASSERT_FALSE(Toolbox::IsUuid("012345678901234567890123456789012345"));
68 ASSERT_TRUE(Toolbox::IsUuid("550e8400-e29b-41d4-a716-446655440000"));
69 ASSERT_FALSE(Toolbox::IsUuid("550e8400-e29b-41d4-a716-44665544000_"));
70 ASSERT_FALSE(Toolbox::IsUuid("01234567890123456789012345678901234_"));
71 ASSERT_FALSE(Toolbox::StartsWithUuid("550e8400-e29b-41d4-a716-44665544000"));
72 ASSERT_TRUE(Toolbox::StartsWithUuid("550e8400-e29b-41d4-a716-446655440000"));
73 ASSERT_TRUE(Toolbox::StartsWithUuid("550e8400-e29b-41d4-a716-446655440000 ok"));
74 ASSERT_FALSE(Toolbox::StartsWithUuid("550e8400-e29b-41d4-a716-446655440000ok"));
75 }
76
TEST(Toolbox,IsSHA1)77 TEST(Toolbox, IsSHA1)
78 {
79 ASSERT_FALSE(Toolbox::IsSHA1(""));
80 ASSERT_FALSE(Toolbox::IsSHA1("01234567890123456789012345678901234567890123"));
81 ASSERT_FALSE(Toolbox::IsSHA1("012345678901234567890123456789012345678901234"));
82 ASSERT_TRUE(Toolbox::IsSHA1("b5ed549f-956400ce-69a8c063-bf5b78be-2732a4b9"));
83
84 std::string sha = " b5ed549f-956400ce-69a8c063-bf5b78be-2732a4b9 ";
85 ASSERT_TRUE(Toolbox::IsSHA1(sha));
86 sha[3] = '\0';
87 sha[53] = '\0';
88 ASSERT_TRUE(Toolbox::IsSHA1(sha));
89 sha[40] = '\0';
90 ASSERT_FALSE(Toolbox::IsSHA1(sha));
91 ASSERT_FALSE(Toolbox::IsSHA1(" "));
92
93 ASSERT_TRUE(Toolbox::IsSHA1("16738bc3-e47ed42a-43ce044c-a3414a45-cb069bd0"));
94
95 std::string s;
96 Toolbox::ComputeSHA1(s, "The quick brown fox jumps over the lazy dog");
97 ASSERT_TRUE(Toolbox::IsSHA1(s));
98 ASSERT_EQ("2fd4e1c6-7a2d28fc-ed849ee1-bb76e739-1b93eb12", s);
99
100 ASSERT_FALSE(Toolbox::IsSHA1("b5ed549f-956400ce-69a8c063-bf5b78be-2732a4b_"));
101 }
102
103
TEST(ParseGetArguments,Basic)104 TEST(ParseGetArguments, Basic)
105 {
106 HttpToolbox::GetArguments b;
107 HttpToolbox::ParseGetArguments(b, "aaa=baaa&bb=a&aa=c");
108
109 HttpToolbox::Arguments a;
110 HttpToolbox::CompileGetArguments(a, b);
111
112 ASSERT_EQ(3u, a.size());
113 ASSERT_EQ(a["aaa"], "baaa");
114 ASSERT_EQ(a["bb"], "a");
115 ASSERT_EQ(a["aa"], "c");
116 }
117
118
TEST(ParseGetArguments,BasicEmpty)119 TEST(ParseGetArguments, BasicEmpty)
120 {
121 HttpToolbox::GetArguments b;
122 HttpToolbox::ParseGetArguments(b, "aaa&bb=aa&aa");
123
124 HttpToolbox::Arguments a;
125 HttpToolbox::CompileGetArguments(a, b);
126
127 ASSERT_EQ(3u, a.size());
128 ASSERT_EQ(a["aaa"], "");
129 ASSERT_EQ(a["bb"], "aa");
130 ASSERT_EQ(a["aa"], "");
131 }
132
133
TEST(ParseGetArguments,Single)134 TEST(ParseGetArguments, Single)
135 {
136 HttpToolbox::GetArguments b;
137 HttpToolbox::ParseGetArguments(b, "aaa=baaa");
138
139 HttpToolbox::Arguments a;
140 HttpToolbox::CompileGetArguments(a, b);
141
142 ASSERT_EQ(1u, a.size());
143 ASSERT_EQ(a["aaa"], "baaa");
144 }
145
146
TEST(ParseGetArguments,SingleEmpty)147 TEST(ParseGetArguments, SingleEmpty)
148 {
149 HttpToolbox::GetArguments b;
150 HttpToolbox::ParseGetArguments(b, "aaa");
151
152 HttpToolbox::Arguments a;
153 HttpToolbox::CompileGetArguments(a, b);
154
155 ASSERT_EQ(1u, a.size());
156 ASSERT_EQ(a["aaa"], "");
157 }
158
159
TEST(ParseGetQuery,Test1)160 TEST(ParseGetQuery, Test1)
161 {
162 UriComponents uri;
163 HttpToolbox::GetArguments b;
164 HttpToolbox::ParseGetQuery(uri, b, "/instances/test/world?aaa=baaa&bb=a&aa=c");
165
166 HttpToolbox::Arguments a;
167 HttpToolbox::CompileGetArguments(a, b);
168
169 ASSERT_EQ(3u, uri.size());
170 ASSERT_EQ("instances", uri[0]);
171 ASSERT_EQ("test", uri[1]);
172 ASSERT_EQ("world", uri[2]);
173 ASSERT_EQ(3u, a.size());
174 ASSERT_EQ(a["aaa"], "baaa");
175 ASSERT_EQ(a["bb"], "a");
176 ASSERT_EQ(a["aa"], "c");
177 }
178
179
TEST(ParseGetQuery,Test2)180 TEST(ParseGetQuery, Test2)
181 {
182 UriComponents uri;
183 HttpToolbox::GetArguments b;
184 HttpToolbox::ParseGetQuery(uri, b, "/instances/test/world");
185
186 HttpToolbox::Arguments a;
187 HttpToolbox::CompileGetArguments(a, b);
188
189 ASSERT_EQ(3u, uri.size());
190 ASSERT_EQ("instances", uri[0]);
191 ASSERT_EQ("test", uri[1]);
192 ASSERT_EQ("world", uri[2]);
193 ASSERT_EQ(0u, a.size());
194 }
195
196
TEST(Uri,SplitUriComponents)197 TEST(Uri, SplitUriComponents)
198 {
199 UriComponents c, d;
200 Toolbox::SplitUriComponents(c, "/cou/hello/world");
201 ASSERT_EQ(3u, c.size());
202 ASSERT_EQ("cou", c[0]);
203 ASSERT_EQ("hello", c[1]);
204 ASSERT_EQ("world", c[2]);
205
206 Toolbox::SplitUriComponents(c, "/cou/hello/world/");
207 ASSERT_EQ(3u, c.size());
208 ASSERT_EQ("cou", c[0]);
209 ASSERT_EQ("hello", c[1]);
210 ASSERT_EQ("world", c[2]);
211
212 Toolbox::SplitUriComponents(c, "/cou/hello/world/a");
213 ASSERT_EQ(4u, c.size());
214 ASSERT_EQ("cou", c[0]);
215 ASSERT_EQ("hello", c[1]);
216 ASSERT_EQ("world", c[2]);
217 ASSERT_EQ("a", c[3]);
218
219 Toolbox::SplitUriComponents(c, "/");
220 ASSERT_EQ(0u, c.size());
221
222 Toolbox::SplitUriComponents(c, "/hello");
223 ASSERT_EQ(1u, c.size());
224 ASSERT_EQ("hello", c[0]);
225
226 Toolbox::SplitUriComponents(c, "/hello/");
227 ASSERT_EQ(1u, c.size());
228 ASSERT_EQ("hello", c[0]);
229
230 ASSERT_THROW(Toolbox::SplitUriComponents(c, ""), OrthancException);
231 ASSERT_THROW(Toolbox::SplitUriComponents(c, "a"), OrthancException);
232 ASSERT_THROW(Toolbox::SplitUriComponents(c, "/coucou//coucou"), OrthancException);
233
234 c.clear();
235 c.push_back("test");
236 ASSERT_EQ("/", Toolbox::FlattenUri(c, 10));
237 }
238
239
TEST(Uri,Truncate)240 TEST(Uri, Truncate)
241 {
242 UriComponents c, d;
243 Toolbox::SplitUriComponents(c, "/cou/hello/world");
244
245 Toolbox::TruncateUri(d, c, 0);
246 ASSERT_EQ(3u, d.size());
247 ASSERT_EQ("cou", d[0]);
248 ASSERT_EQ("hello", d[1]);
249 ASSERT_EQ("world", d[2]);
250
251 Toolbox::TruncateUri(d, c, 1);
252 ASSERT_EQ(2u, d.size());
253 ASSERT_EQ("hello", d[0]);
254 ASSERT_EQ("world", d[1]);
255
256 Toolbox::TruncateUri(d, c, 2);
257 ASSERT_EQ(1u, d.size());
258 ASSERT_EQ("world", d[0]);
259
260 Toolbox::TruncateUri(d, c, 3);
261 ASSERT_EQ(0u, d.size());
262
263 Toolbox::TruncateUri(d, c, 4);
264 ASSERT_EQ(0u, d.size());
265
266 Toolbox::TruncateUri(d, c, 5);
267 ASSERT_EQ(0u, d.size());
268 }
269
270
TEST(Uri,Child)271 TEST(Uri, Child)
272 {
273 UriComponents c1; Toolbox::SplitUriComponents(c1, "/hello/world");
274 UriComponents c2; Toolbox::SplitUriComponents(c2, "/hello/hello");
275 UriComponents c3; Toolbox::SplitUriComponents(c3, "/hello");
276 UriComponents c4; Toolbox::SplitUriComponents(c4, "/world");
277 UriComponents c5; Toolbox::SplitUriComponents(c5, "/");
278
279 ASSERT_TRUE(Toolbox::IsChildUri(c1, c1));
280 ASSERT_FALSE(Toolbox::IsChildUri(c1, c2));
281 ASSERT_FALSE(Toolbox::IsChildUri(c1, c3));
282 ASSERT_FALSE(Toolbox::IsChildUri(c1, c4));
283 ASSERT_FALSE(Toolbox::IsChildUri(c1, c5));
284
285 ASSERT_FALSE(Toolbox::IsChildUri(c2, c1));
286 ASSERT_TRUE(Toolbox::IsChildUri(c2, c2));
287 ASSERT_FALSE(Toolbox::IsChildUri(c2, c3));
288 ASSERT_FALSE(Toolbox::IsChildUri(c2, c4));
289 ASSERT_FALSE(Toolbox::IsChildUri(c2, c5));
290
291 ASSERT_TRUE(Toolbox::IsChildUri(c3, c1));
292 ASSERT_TRUE(Toolbox::IsChildUri(c3, c2));
293 ASSERT_TRUE(Toolbox::IsChildUri(c3, c3));
294 ASSERT_FALSE(Toolbox::IsChildUri(c3, c4));
295 ASSERT_FALSE(Toolbox::IsChildUri(c3, c5));
296
297 ASSERT_FALSE(Toolbox::IsChildUri(c4, c1));
298 ASSERT_FALSE(Toolbox::IsChildUri(c4, c2));
299 ASSERT_FALSE(Toolbox::IsChildUri(c4, c3));
300 ASSERT_TRUE(Toolbox::IsChildUri(c4, c4));
301 ASSERT_FALSE(Toolbox::IsChildUri(c4, c5));
302
303 ASSERT_TRUE(Toolbox::IsChildUri(c5, c1));
304 ASSERT_TRUE(Toolbox::IsChildUri(c5, c2));
305 ASSERT_TRUE(Toolbox::IsChildUri(c5, c3));
306 ASSERT_TRUE(Toolbox::IsChildUri(c5, c4));
307 ASSERT_TRUE(Toolbox::IsChildUri(c5, c5));
308 }
309
310
311 #if ORTHANC_SANDBOXED != 1
TEST(Uri,AutodetectMimeType)312 TEST(Uri, AutodetectMimeType)
313 {
314 ASSERT_EQ(MimeType_Binary, SystemToolbox::AutodetectMimeType("../NOTES"));
315 ASSERT_EQ(MimeType_Binary, SystemToolbox::AutodetectMimeType(""));
316 ASSERT_EQ(MimeType_Binary, SystemToolbox::AutodetectMimeType("/"));
317 ASSERT_EQ(MimeType_Binary, SystemToolbox::AutodetectMimeType("a/a"));
318 ASSERT_EQ(MimeType_Binary, SystemToolbox::AutodetectMimeType("..\\a\\"));
319 ASSERT_EQ(MimeType_Binary, SystemToolbox::AutodetectMimeType("..\\a\\a"));
320
321 ASSERT_EQ(MimeType_PlainText, SystemToolbox::AutodetectMimeType("../NOTES.txt"));
322 ASSERT_EQ(MimeType_PlainText, SystemToolbox::AutodetectMimeType("../coucou.xml/NOTES.txt"));
323 ASSERT_EQ(MimeType_Xml, SystemToolbox::AutodetectMimeType("..\\coucou.\\NOTES.xml"));
324 ASSERT_EQ(MimeType_Xml, SystemToolbox::AutodetectMimeType("../.xml"));
325 ASSERT_EQ(MimeType_Xml, SystemToolbox::AutodetectMimeType("../.XmL"));
326
327 ASSERT_EQ(MimeType_JavaScript, SystemToolbox::AutodetectMimeType("NOTES.js"));
328 ASSERT_EQ(MimeType_Json, SystemToolbox::AutodetectMimeType("NOTES.json"));
329 ASSERT_EQ(MimeType_Pdf, SystemToolbox::AutodetectMimeType("NOTES.pdf"));
330 ASSERT_EQ(MimeType_Css, SystemToolbox::AutodetectMimeType("NOTES.css"));
331 ASSERT_EQ(MimeType_Html, SystemToolbox::AutodetectMimeType("NOTES.html"));
332 ASSERT_EQ(MimeType_PlainText, SystemToolbox::AutodetectMimeType("NOTES.txt"));
333 ASSERT_EQ(MimeType_Xml, SystemToolbox::AutodetectMimeType("NOTES.xml"));
334 ASSERT_EQ(MimeType_Gif, SystemToolbox::AutodetectMimeType("NOTES.gif"));
335 ASSERT_EQ(MimeType_Jpeg, SystemToolbox::AutodetectMimeType("NOTES.jpg"));
336 ASSERT_EQ(MimeType_Jpeg, SystemToolbox::AutodetectMimeType("NOTES.jpeg"));
337 ASSERT_EQ(MimeType_Png, SystemToolbox::AutodetectMimeType("NOTES.png"));
338 ASSERT_EQ(MimeType_NaCl, SystemToolbox::AutodetectMimeType("NOTES.nexe"));
339 ASSERT_EQ(MimeType_Json, SystemToolbox::AutodetectMimeType("NOTES.nmf"));
340 ASSERT_EQ(MimeType_PNaCl, SystemToolbox::AutodetectMimeType("NOTES.pexe"));
341 ASSERT_EQ(MimeType_Svg, SystemToolbox::AutodetectMimeType("NOTES.svg"));
342 ASSERT_EQ(MimeType_Woff, SystemToolbox::AutodetectMimeType("NOTES.woff"));
343 ASSERT_EQ(MimeType_Woff2, SystemToolbox::AutodetectMimeType("NOTES.woff2"));
344
345 // Test primitives from the "RegisterDefaultExtensions()" that was
346 // present in the sample "Serve Folders plugin" of Orthanc 1.4.2
347 ASSERT_STREQ("application/javascript", EnumerationToString(SystemToolbox::AutodetectMimeType(".js")));
348 ASSERT_STREQ("application/json", EnumerationToString(SystemToolbox::AutodetectMimeType(".json")));
349 ASSERT_STREQ("application/json", EnumerationToString(SystemToolbox::AutodetectMimeType(".nmf")));
350 ASSERT_STREQ("application/octet-stream", EnumerationToString(SystemToolbox::AutodetectMimeType("")));
351 ASSERT_STREQ("application/wasm", EnumerationToString(SystemToolbox::AutodetectMimeType(".wasm")));
352 ASSERT_STREQ("application/x-font-woff", EnumerationToString(SystemToolbox::AutodetectMimeType(".woff")));
353 ASSERT_STREQ("application/x-nacl", EnumerationToString(SystemToolbox::AutodetectMimeType(".nexe")));
354 ASSERT_STREQ("application/x-pnacl", EnumerationToString(SystemToolbox::AutodetectMimeType(".pexe")));
355 ASSERT_STREQ("application/xml", EnumerationToString(SystemToolbox::AutodetectMimeType(".xml")));
356 ASSERT_STREQ("font/woff2", EnumerationToString(SystemToolbox::AutodetectMimeType(".woff2")));
357 ASSERT_STREQ("image/gif", EnumerationToString(SystemToolbox::AutodetectMimeType(".gif")));
358 ASSERT_STREQ("image/jpeg", EnumerationToString(SystemToolbox::AutodetectMimeType(".jpeg")));
359 ASSERT_STREQ("image/jpeg", EnumerationToString(SystemToolbox::AutodetectMimeType(".jpg")));
360 ASSERT_STREQ("image/png", EnumerationToString(SystemToolbox::AutodetectMimeType(".png")));
361 ASSERT_STREQ("image/svg+xml", EnumerationToString(SystemToolbox::AutodetectMimeType(".svg")));
362 ASSERT_STREQ("text/css", EnumerationToString(SystemToolbox::AutodetectMimeType(".css")));
363 ASSERT_STREQ("text/html", EnumerationToString(SystemToolbox::AutodetectMimeType(".html")));
364 }
365 #endif
366
367
TEST(Toolbox,ComputeMD5)368 TEST(Toolbox, ComputeMD5)
369 {
370 std::string s;
371
372 // # echo -n "Hello" | md5sum
373
374 Toolbox::ComputeMD5(s, "Hello");
375 ASSERT_EQ("8b1a9953c4611296a827abf8c47804d7", s);
376 Toolbox::ComputeMD5(s, "");
377 ASSERT_EQ("d41d8cd98f00b204e9800998ecf8427e", s);
378 }
379
TEST(Toolbox,ComputeSHA1)380 TEST(Toolbox, ComputeSHA1)
381 {
382 std::string s;
383
384 Toolbox::ComputeSHA1(s, "The quick brown fox jumps over the lazy dog");
385 ASSERT_EQ("2fd4e1c6-7a2d28fc-ed849ee1-bb76e739-1b93eb12", s);
386 Toolbox::ComputeSHA1(s, "");
387 ASSERT_EQ("da39a3ee-5e6b4b0d-3255bfef-95601890-afd80709", s);
388 }
389
390 #if ORTHANC_SANDBOXED != 1
TEST(Toolbox,PathToExecutable)391 TEST(Toolbox, PathToExecutable)
392 {
393 printf("[%s]\n", SystemToolbox::GetPathToExecutable().c_str());
394 printf("[%s]\n", SystemToolbox::GetDirectoryOfExecutable().c_str());
395 }
396 #endif
397
TEST(Toolbox,StripSpaces)398 TEST(Toolbox, StripSpaces)
399 {
400 ASSERT_EQ("", Toolbox::StripSpaces(" \t \r \n "));
401 ASSERT_EQ("coucou", Toolbox::StripSpaces(" coucou \t \r \n "));
402 ASSERT_EQ("cou cou", Toolbox::StripSpaces(" cou cou \n "));
403 ASSERT_EQ("c", Toolbox::StripSpaces(" \n\t c\r \n "));
404 }
405
TEST(Toolbox,Case)406 TEST(Toolbox, Case)
407 {
408 std::string s = "CoU";
409 std::string ss;
410
411 Toolbox::ToUpperCase(ss, s);
412 ASSERT_EQ("COU", ss);
413 Toolbox::ToLowerCase(ss, s);
414 ASSERT_EQ("cou", ss);
415
416 s = "CoU";
417 Toolbox::ToUpperCase(s);
418 ASSERT_EQ("COU", s);
419
420 s = "CoU";
421 Toolbox::ToLowerCase(s);
422 ASSERT_EQ("cou", s);
423 }
424
425
TEST(Logger,Basic)426 TEST(Logger, Basic)
427 {
428 LOG(INFO) << "I say hello";
429 }
430
TEST(Toolbox,ConvertFromLatin1)431 TEST(Toolbox, ConvertFromLatin1)
432 {
433 // This is a Latin-1 test string
434 const unsigned char data[10] = { 0xe0, 0xe9, 0xea, 0xe7, 0x26, 0xc6, 0x61, 0x62, 0x63, 0x00 };
435
436 std::string s((char*) &data[0], 10);
437 ASSERT_EQ("&abc", Toolbox::ConvertToAscii(s));
438
439 // Open in Emacs, then save with UTF-8 encoding, then "hexdump -C"
440 std::string utf8 = Toolbox::ConvertToUtf8(s, Encoding_Latin1, false);
441 ASSERT_EQ(15u, utf8.size());
442 ASSERT_EQ(0xc3, static_cast<unsigned char>(utf8[0]));
443 ASSERT_EQ(0xa0, static_cast<unsigned char>(utf8[1]));
444 ASSERT_EQ(0xc3, static_cast<unsigned char>(utf8[2]));
445 ASSERT_EQ(0xa9, static_cast<unsigned char>(utf8[3]));
446 ASSERT_EQ(0xc3, static_cast<unsigned char>(utf8[4]));
447 ASSERT_EQ(0xaa, static_cast<unsigned char>(utf8[5]));
448 ASSERT_EQ(0xc3, static_cast<unsigned char>(utf8[6]));
449 ASSERT_EQ(0xa7, static_cast<unsigned char>(utf8[7]));
450 ASSERT_EQ(0x26, static_cast<unsigned char>(utf8[8]));
451 ASSERT_EQ(0xc3, static_cast<unsigned char>(utf8[9]));
452 ASSERT_EQ(0x86, static_cast<unsigned char>(utf8[10]));
453 ASSERT_EQ(0x61, static_cast<unsigned char>(utf8[11]));
454 ASSERT_EQ(0x62, static_cast<unsigned char>(utf8[12]));
455 ASSERT_EQ(0x63, static_cast<unsigned char>(utf8[13]));
456 ASSERT_EQ(0x00, static_cast<unsigned char>(utf8[14])); // Null-terminated string
457 }
458
459
TEST(Toolbox,FixUtf8)460 TEST(Toolbox, FixUtf8)
461 {
462 // This is a Latin-1 test string: "crane" with a circumflex accent
463 const unsigned char latin1[] = { 0x63, 0x72, 0xe2, 0x6e, 0x65 };
464
465 std::string s((char*) &latin1[0], sizeof(latin1) / sizeof(char));
466
467 ASSERT_EQ(s, Toolbox::ConvertFromUtf8(Toolbox::ConvertToUtf8(s, Encoding_Latin1, false), Encoding_Latin1));
468 ASSERT_EQ("cre", Toolbox::ConvertToUtf8(s, Encoding_Utf8, false));
469 }
470
471
GetUnicode(const uint8_t * data,size_t size,size_t expectedLength)472 static int32_t GetUnicode(const uint8_t* data,
473 size_t size,
474 size_t expectedLength)
475 {
476 std::string s((char*) &data[0], size);
477 uint32_t unicode;
478 size_t length;
479 Toolbox::Utf8ToUnicodeCharacter(unicode, length, s, 0);
480 if (length != expectedLength)
481 {
482 return -1; // Error case
483 }
484 else
485 {
486 return unicode;
487 }
488 }
489
490
TEST(Toolbox,Utf8ToUnicode)491 TEST(Toolbox, Utf8ToUnicode)
492 {
493 // https://en.wikipedia.org/wiki/UTF-8
494
495 ASSERT_EQ(1u, sizeof(char));
496 ASSERT_EQ(1u, sizeof(uint8_t));
497
498 {
499 const uint8_t data[] = { 0x24 };
500 ASSERT_EQ(0x24, GetUnicode(data, 1, 1));
501 ASSERT_THROW(GetUnicode(data, 0, 1), OrthancException);
502 }
503
504 {
505 const uint8_t data[] = { 0xc2, 0xa2 };
506 ASSERT_EQ(0xa2, GetUnicode(data, 2, 2));
507 ASSERT_THROW(GetUnicode(data, 1, 2), OrthancException);
508 }
509
510 {
511 const uint8_t data[] = { 0xe0, 0xa4, 0xb9 };
512 ASSERT_EQ(0x0939, GetUnicode(data, 3, 3));
513 ASSERT_THROW(GetUnicode(data, 2, 3), OrthancException);
514 }
515
516 {
517 const uint8_t data[] = { 0xe2, 0x82, 0xac };
518 ASSERT_EQ(0x20ac, GetUnicode(data, 3, 3));
519 ASSERT_THROW(GetUnicode(data, 2, 3), OrthancException);
520 }
521
522 {
523 const uint8_t data[] = { 0xf0, 0x90, 0x8d, 0x88 };
524 ASSERT_EQ(0x010348, GetUnicode(data, 4, 4));
525 ASSERT_THROW(GetUnicode(data, 3, 4), OrthancException);
526 }
527
528 {
529 const uint8_t data[] = { 0xe0 };
530 ASSERT_THROW(GetUnicode(data, 1, 1), OrthancException);
531 }
532 }
533
534
TEST(Toolbox,UrlDecode)535 TEST(Toolbox, UrlDecode)
536 {
537 std::string s;
538
539 s = "Hello%20World";
540 Toolbox::UrlDecode(s);
541 ASSERT_EQ("Hello World", s);
542
543 s = "%21%23%24%26%27%28%29%2A%2B%2c%2f%3A%3b%3d%3f%40%5B%5D%90%ff";
544 Toolbox::UrlDecode(s);
545 std::string ss = "!#$&'()*+,/:;=?@[]";
546 ss.push_back((char) 144);
547 ss.push_back((char) 255);
548 ASSERT_EQ(ss, s);
549
550 s = "(2000%2C00A4)+Other";
551 Toolbox::UrlDecode(s);
552 ASSERT_EQ("(2000,00A4) Other", s);
553 }
554
555
TEST(Toolbox,IsAsciiString)556 TEST(Toolbox, IsAsciiString)
557 {
558 std::string s = "Hello 12 /";
559 ASSERT_EQ(10u, s.size());
560 ASSERT_TRUE(Toolbox::IsAsciiString(s));
561 ASSERT_TRUE(Toolbox::IsAsciiString(s.c_str(), 10));
562 ASSERT_FALSE(Toolbox::IsAsciiString(s.c_str(), 11)); // Taking the trailing hidden '\0'
563
564 s[2] = '\0';
565 ASSERT_EQ(10u, s.size());
566 ASSERT_FALSE(Toolbox::IsAsciiString(s));
567
568 ASSERT_TRUE(Toolbox::IsAsciiString("Hello\nworld"));
569 ASSERT_FALSE(Toolbox::IsAsciiString("Hello\rworld"));
570
571 ASSERT_EQ("Hello\nworld", Toolbox::ConvertToAscii("Hello\nworld"));
572 ASSERT_EQ("Helloworld", Toolbox::ConvertToAscii("Hello\r\tworld"));
573 }
574
575
576 #if defined(__linux__)
TEST(Toolbox,AbsoluteDirectory)577 TEST(Toolbox, AbsoluteDirectory)
578 {
579 ASSERT_EQ("/tmp/hello", SystemToolbox::InterpretRelativePath("/tmp", "hello"));
580 ASSERT_EQ("/tmp", SystemToolbox::InterpretRelativePath("/tmp", "/tmp"));
581 }
582 #endif
583
584
585 #if ORTHANC_SANDBOXED != 1
TEST(Toolbox,WriteFile)586 TEST(Toolbox, WriteFile)
587 {
588 std::string path;
589
590 {
591 TemporaryFile tmp;
592 path = tmp.GetPath();
593
594 std::string s;
595 s.append("Hello");
596 s.push_back('\0');
597 s.append("World");
598 ASSERT_EQ(11u, s.size());
599
600 SystemToolbox::WriteFile(s, path.c_str());
601
602 std::string t;
603 SystemToolbox::ReadFile(t, path.c_str());
604
605 ASSERT_EQ(11u, t.size());
606 ASSERT_EQ(0, t[5]);
607 ASSERT_EQ(0, memcmp(s.c_str(), t.c_str(), s.size()));
608
609 std::string h;
610 ASSERT_EQ(true, SystemToolbox::ReadHeader(h, path.c_str(), 1));
611 ASSERT_EQ(1u, h.size());
612 ASSERT_EQ('H', h[0]);
613 ASSERT_TRUE(SystemToolbox::ReadHeader(h, path.c_str(), 0));
614 ASSERT_EQ(0u, h.size());
615 ASSERT_FALSE(SystemToolbox::ReadHeader(h, path.c_str(), 32));
616 ASSERT_EQ(11u, h.size());
617 ASSERT_EQ(0, memcmp(s.c_str(), h.c_str(), s.size()));
618 }
619
620 std::string u;
621 ASSERT_THROW(SystemToolbox::ReadFile(u, path.c_str()), OrthancException);
622
623 {
624 TemporaryFile tmp;
625 std::string s = "Hello";
626 SystemToolbox::WriteFile(s, tmp.GetPath(), true /* call fsync() */);
627 std::string t;
628 SystemToolbox::ReadFile(t, tmp.GetPath());
629 ASSERT_EQ(s, t);
630 }
631 }
632 #endif
633
634
635 #if ORTHANC_SANDBOXED != 1
TEST(Toolbox,FileBuffer)636 TEST(Toolbox, FileBuffer)
637 {
638 FileBuffer f;
639 f.Append("a", 1);
640 f.Append("", 0);
641 f.Append("bc", 2);
642
643 std::string s;
644 f.Read(s);
645 ASSERT_EQ("abc", s);
646
647 ASSERT_THROW(f.Append("d", 1), OrthancException); // File is closed
648 }
649 #endif
650
651
TEST(Toolbox,Wildcard)652 TEST(Toolbox, Wildcard)
653 {
654 ASSERT_EQ("abcd", Toolbox::WildcardToRegularExpression("abcd"));
655 ASSERT_EQ("ab.*cd", Toolbox::WildcardToRegularExpression("ab*cd"));
656 ASSERT_EQ("ab..cd", Toolbox::WildcardToRegularExpression("ab??cd"));
657 ASSERT_EQ("a.*b.c.*d", Toolbox::WildcardToRegularExpression("a*b?c*d"));
658 ASSERT_EQ("a\\{b\\]", Toolbox::WildcardToRegularExpression("a{b]"));
659 }
660
661
TEST(Toolbox,Tokenize)662 TEST(Toolbox, Tokenize)
663 {
664 std::vector<std::string> t;
665
666 Toolbox::TokenizeString(t, "", ',');
667 ASSERT_EQ(1u, t.size());
668 ASSERT_EQ("", t[0]);
669
670 Toolbox::TokenizeString(t, "abc", ',');
671 ASSERT_EQ(1u, t.size());
672 ASSERT_EQ("abc", t[0]);
673
674 Toolbox::TokenizeString(t, "ab,cd,ef,", ',');
675 ASSERT_EQ(4u, t.size());
676 ASSERT_EQ("ab", t[0]);
677 ASSERT_EQ("cd", t[1]);
678 ASSERT_EQ("ef", t[2]);
679 ASSERT_EQ("", t[3]);
680 }
681
TEST(Toolbox,Enumerations)682 TEST(Toolbox, Enumerations)
683 {
684 ASSERT_EQ(Encoding_Utf8, StringToEncoding(EnumerationToString(Encoding_Utf8)));
685 ASSERT_EQ(Encoding_Ascii, StringToEncoding(EnumerationToString(Encoding_Ascii)));
686 ASSERT_EQ(Encoding_Latin1, StringToEncoding(EnumerationToString(Encoding_Latin1)));
687 ASSERT_EQ(Encoding_Latin2, StringToEncoding(EnumerationToString(Encoding_Latin2)));
688 ASSERT_EQ(Encoding_Latin3, StringToEncoding(EnumerationToString(Encoding_Latin3)));
689 ASSERT_EQ(Encoding_Latin4, StringToEncoding(EnumerationToString(Encoding_Latin4)));
690 ASSERT_EQ(Encoding_Latin5, StringToEncoding(EnumerationToString(Encoding_Latin5)));
691 ASSERT_EQ(Encoding_Cyrillic, StringToEncoding(EnumerationToString(Encoding_Cyrillic)));
692 ASSERT_EQ(Encoding_Arabic, StringToEncoding(EnumerationToString(Encoding_Arabic)));
693 ASSERT_EQ(Encoding_Greek, StringToEncoding(EnumerationToString(Encoding_Greek)));
694 ASSERT_EQ(Encoding_Hebrew, StringToEncoding(EnumerationToString(Encoding_Hebrew)));
695 ASSERT_EQ(Encoding_Japanese, StringToEncoding(EnumerationToString(Encoding_Japanese)));
696 ASSERT_EQ(Encoding_Chinese, StringToEncoding(EnumerationToString(Encoding_Chinese)));
697 ASSERT_EQ(Encoding_Thai, StringToEncoding(EnumerationToString(Encoding_Thai)));
698 ASSERT_EQ(Encoding_Korean, StringToEncoding(EnumerationToString(Encoding_Korean)));
699 ASSERT_EQ(Encoding_JapaneseKanji, StringToEncoding(EnumerationToString(Encoding_JapaneseKanji)));
700 ASSERT_EQ(Encoding_SimplifiedChinese, StringToEncoding(EnumerationToString(Encoding_SimplifiedChinese)));
701
702 ASSERT_EQ(ResourceType_Patient, StringToResourceType(EnumerationToString(ResourceType_Patient)));
703 ASSERT_EQ(ResourceType_Study, StringToResourceType(EnumerationToString(ResourceType_Study)));
704 ASSERT_EQ(ResourceType_Series, StringToResourceType(EnumerationToString(ResourceType_Series)));
705 ASSERT_EQ(ResourceType_Instance, StringToResourceType(EnumerationToString(ResourceType_Instance)));
706
707 ASSERT_EQ(ImageFormat_Png, StringToImageFormat(EnumerationToString(ImageFormat_Png)));
708
709 ASSERT_EQ(PhotometricInterpretation_ARGB, StringToPhotometricInterpretation(EnumerationToString(PhotometricInterpretation_ARGB)));
710 ASSERT_EQ(PhotometricInterpretation_CMYK, StringToPhotometricInterpretation(EnumerationToString(PhotometricInterpretation_CMYK)));
711 ASSERT_EQ(PhotometricInterpretation_HSV, StringToPhotometricInterpretation(EnumerationToString(PhotometricInterpretation_HSV)));
712 ASSERT_EQ(PhotometricInterpretation_Monochrome1, StringToPhotometricInterpretation(EnumerationToString(PhotometricInterpretation_Monochrome1)));
713 ASSERT_EQ(PhotometricInterpretation_Monochrome2, StringToPhotometricInterpretation(EnumerationToString(PhotometricInterpretation_Monochrome2)));
714 ASSERT_EQ(PhotometricInterpretation_Palette, StringToPhotometricInterpretation(EnumerationToString(PhotometricInterpretation_Palette)));
715 ASSERT_EQ(PhotometricInterpretation_RGB, StringToPhotometricInterpretation(EnumerationToString(PhotometricInterpretation_RGB)));
716 ASSERT_EQ(PhotometricInterpretation_YBRFull, StringToPhotometricInterpretation(EnumerationToString(PhotometricInterpretation_YBRFull)));
717 ASSERT_EQ(PhotometricInterpretation_YBRFull422, StringToPhotometricInterpretation(EnumerationToString(PhotometricInterpretation_YBRFull422)));
718 ASSERT_EQ(PhotometricInterpretation_YBRPartial420, StringToPhotometricInterpretation(EnumerationToString(PhotometricInterpretation_YBRPartial420)));
719 ASSERT_EQ(PhotometricInterpretation_YBRPartial422, StringToPhotometricInterpretation(EnumerationToString(PhotometricInterpretation_YBRPartial422)));
720 ASSERT_EQ(PhotometricInterpretation_YBR_ICT, StringToPhotometricInterpretation(EnumerationToString(PhotometricInterpretation_YBR_ICT)));
721 ASSERT_EQ(PhotometricInterpretation_YBR_RCT, StringToPhotometricInterpretation(EnumerationToString(PhotometricInterpretation_YBR_RCT)));
722
723 ASSERT_STREQ("Unknown", EnumerationToString(PhotometricInterpretation_Unknown));
724 ASSERT_THROW(StringToPhotometricInterpretation("Unknown"), OrthancException);
725
726 ASSERT_EQ(DicomVersion_2008, StringToDicomVersion(EnumerationToString(DicomVersion_2008)));
727 ASSERT_EQ(DicomVersion_2017c, StringToDicomVersion(EnumerationToString(DicomVersion_2017c)));
728
729 for (int i = static_cast<int>(ValueRepresentation_ApplicationEntity);
730 i < static_cast<int>(ValueRepresentation_NotSupported); i += 1)
731 {
732 ValueRepresentation vr = static_cast<ValueRepresentation>(i);
733 ASSERT_EQ(vr, StringToValueRepresentation(EnumerationToString(vr), true));
734 }
735
736 ASSERT_THROW(StringToValueRepresentation("nope", true), OrthancException);
737
738 ASSERT_EQ(JobState_Pending, StringToJobState(EnumerationToString(JobState_Pending)));
739 ASSERT_EQ(JobState_Running, StringToJobState(EnumerationToString(JobState_Running)));
740 ASSERT_EQ(JobState_Success, StringToJobState(EnumerationToString(JobState_Success)));
741 ASSERT_EQ(JobState_Failure, StringToJobState(EnumerationToString(JobState_Failure)));
742 ASSERT_EQ(JobState_Paused, StringToJobState(EnumerationToString(JobState_Paused)));
743 ASSERT_EQ(JobState_Retry, StringToJobState(EnumerationToString(JobState_Retry)));
744 ASSERT_THROW(StringToJobState("nope"), OrthancException);
745
746 ASSERT_EQ(MimeType_Binary, StringToMimeType(EnumerationToString(MimeType_Binary)));
747 ASSERT_EQ(MimeType_Css, StringToMimeType(EnumerationToString(MimeType_Css)));
748 ASSERT_EQ(MimeType_Dicom, StringToMimeType(EnumerationToString(MimeType_Dicom)));
749 ASSERT_EQ(MimeType_Gif, StringToMimeType(EnumerationToString(MimeType_Gif)));
750 ASSERT_EQ(MimeType_Gzip, StringToMimeType(EnumerationToString(MimeType_Gzip)));
751 ASSERT_EQ(MimeType_Html, StringToMimeType(EnumerationToString(MimeType_Html)));
752 ASSERT_EQ(MimeType_JavaScript, StringToMimeType(EnumerationToString(MimeType_JavaScript)));
753 ASSERT_EQ(MimeType_Jpeg, StringToMimeType(EnumerationToString(MimeType_Jpeg)));
754 ASSERT_EQ(MimeType_Jpeg2000, StringToMimeType(EnumerationToString(MimeType_Jpeg2000)));
755 ASSERT_EQ(MimeType_Json, StringToMimeType(EnumerationToString(MimeType_Json)));
756 ASSERT_EQ(MimeType_NaCl, StringToMimeType(EnumerationToString(MimeType_NaCl)));
757 ASSERT_EQ(MimeType_PNaCl, StringToMimeType(EnumerationToString(MimeType_PNaCl)));
758 ASSERT_EQ(MimeType_Pam, StringToMimeType(EnumerationToString(MimeType_Pam)));
759 ASSERT_EQ(MimeType_Pdf, StringToMimeType(EnumerationToString(MimeType_Pdf)));
760 ASSERT_EQ(MimeType_PlainText, StringToMimeType(EnumerationToString(MimeType_PlainText)));
761 ASSERT_EQ(MimeType_Png, StringToMimeType(EnumerationToString(MimeType_Png)));
762 ASSERT_EQ(MimeType_Svg, StringToMimeType(EnumerationToString(MimeType_Svg)));
763 ASSERT_EQ(MimeType_WebAssembly, StringToMimeType(EnumerationToString(MimeType_WebAssembly)));
764 ASSERT_EQ(MimeType_Xml, StringToMimeType("application/xml"));
765 ASSERT_EQ(MimeType_Xml, StringToMimeType("text/xml"));
766 ASSERT_EQ(MimeType_Xml, StringToMimeType(EnumerationToString(MimeType_Xml)));
767 ASSERT_EQ(MimeType_DicomWebJson, StringToMimeType(EnumerationToString(MimeType_DicomWebJson)));
768 ASSERT_EQ(MimeType_DicomWebXml, StringToMimeType(EnumerationToString(MimeType_DicomWebXml)));
769 ASSERT_THROW(StringToMimeType("nope"), OrthancException);
770
771 ASSERT_TRUE(IsResourceLevelAboveOrEqual(ResourceType_Patient, ResourceType_Patient));
772 ASSERT_TRUE(IsResourceLevelAboveOrEqual(ResourceType_Patient, ResourceType_Study));
773 ASSERT_TRUE(IsResourceLevelAboveOrEqual(ResourceType_Patient, ResourceType_Series));
774 ASSERT_TRUE(IsResourceLevelAboveOrEqual(ResourceType_Patient, ResourceType_Instance));
775
776 ASSERT_FALSE(IsResourceLevelAboveOrEqual(ResourceType_Study, ResourceType_Patient));
777 ASSERT_TRUE(IsResourceLevelAboveOrEqual(ResourceType_Study, ResourceType_Study));
778 ASSERT_TRUE(IsResourceLevelAboveOrEqual(ResourceType_Study, ResourceType_Series));
779 ASSERT_TRUE(IsResourceLevelAboveOrEqual(ResourceType_Study, ResourceType_Instance));
780
781 ASSERT_FALSE(IsResourceLevelAboveOrEqual(ResourceType_Series, ResourceType_Patient));
782 ASSERT_FALSE(IsResourceLevelAboveOrEqual(ResourceType_Series, ResourceType_Study));
783 ASSERT_TRUE(IsResourceLevelAboveOrEqual(ResourceType_Series, ResourceType_Series));
784 ASSERT_TRUE(IsResourceLevelAboveOrEqual(ResourceType_Series, ResourceType_Instance));
785
786 ASSERT_FALSE(IsResourceLevelAboveOrEqual(ResourceType_Instance, ResourceType_Patient));
787 ASSERT_FALSE(IsResourceLevelAboveOrEqual(ResourceType_Instance, ResourceType_Study));
788 ASSERT_FALSE(IsResourceLevelAboveOrEqual(ResourceType_Instance, ResourceType_Series));
789 ASSERT_TRUE(IsResourceLevelAboveOrEqual(ResourceType_Instance, ResourceType_Instance));
790 }
791
792
793 #if defined(__linux__) || defined(__OpenBSD__)
794 #include <endian.h>
795 #elif defined(__FreeBSD__)
796 #include <machine/endian.h>
797 #endif
798
799
TEST(Toolbox,Endianness)800 TEST(Toolbox, Endianness)
801 {
802 // Parts of this test come from Adam Conrad
803 // http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=728822#5
804
805
806 /**
807 * Windows and OS X are assumed to always little-endian.
808 **/
809
810 #if defined(_WIN32) || defined(__APPLE__)
811 ASSERT_EQ(Endianness_Little, Toolbox::DetectEndianness());
812
813
814 /**
815 * FreeBSD.
816 **/
817
818 #elif defined(__FreeBSD__) || defined(__OpenBSD__)
819 # if _BYTE_ORDER == _BIG_ENDIAN
820 ASSERT_EQ(Endianness_Big, Toolbox::DetectEndianness());
821 # else // _LITTLE_ENDIAN
822 ASSERT_EQ(Endianness_Little, Toolbox::DetectEndianness());
823 # endif
824
825
826 /**
827 * Linux.
828 **/
829
830 #elif defined(__linux__) || defined(__FreeBSD_kernel__)
831
832 #if !defined(__BYTE_ORDER)
833 # error Support your platform here
834 #endif
835
836 # if __BYTE_ORDER == __BIG_ENDIAN
837 ASSERT_EQ(Endianness_Big, Toolbox::DetectEndianness());
838 # else // __LITTLE_ENDIAN
839 ASSERT_EQ(Endianness_Little, Toolbox::DetectEndianness());
840 # endif
841
842
843 /**
844 * WebAssembly is always little-endian.
845 **/
846
847 #elif defined(__EMSCRIPTEN__)
848 ASSERT_EQ(Endianness_Little, Toolbox::DetectEndianness());
849 #else
850 # error Support your platform here
851 #endif
852 }
853
854
855 #include "../Sources/Endianness.h"
856
ASSERT_EQ16(uint16_t a,uint16_t b)857 static void ASSERT_EQ16(uint16_t a, uint16_t b)
858 {
859 #ifdef __MINGW32__
860 // This cast solves a linking problem with MinGW
861 ASSERT_EQ(static_cast<unsigned int>(a), static_cast<unsigned int>(b));
862 #else
863 ASSERT_EQ(a, b);
864 #endif
865 }
866
ASSERT_NE16(uint16_t a,uint16_t b)867 static void ASSERT_NE16(uint16_t a, uint16_t b)
868 {
869 #ifdef __MINGW32__
870 // This cast solves a linking problem with MinGW
871 ASSERT_NE(static_cast<unsigned int>(a), static_cast<unsigned int>(b));
872 #else
873 ASSERT_NE(a, b);
874 #endif
875 }
876
ASSERT_EQ32(uint32_t a,uint32_t b)877 static void ASSERT_EQ32(uint32_t a, uint32_t b)
878 {
879 #ifdef __MINGW32__
880 // This cast solves a linking problem with MinGW
881 ASSERT_EQ(static_cast<unsigned int>(a), static_cast<unsigned int>(b));
882 #else
883 ASSERT_EQ(a, b);
884 #endif
885 }
886
ASSERT_NE32(uint32_t a,uint32_t b)887 static void ASSERT_NE32(uint32_t a, uint32_t b)
888 {
889 #ifdef __MINGW32__
890 // This cast solves a linking problem with MinGW
891 ASSERT_NE(static_cast<unsigned int>(a), static_cast<unsigned int>(b));
892 #else
893 ASSERT_NE(a, b);
894 #endif
895 }
896
ASSERT_EQ64(uint64_t a,uint64_t b)897 static void ASSERT_EQ64(uint64_t a, uint64_t b)
898 {
899 #ifdef __MINGW32__
900 // This cast solves a linking problem with MinGW
901 ASSERT_EQ(static_cast<unsigned int>(a), static_cast<unsigned int>(b));
902 #else
903 ASSERT_EQ(a, b);
904 #endif
905 }
906
ASSERT_NE64(uint64_t a,uint64_t b)907 static void ASSERT_NE64(uint64_t a, uint64_t b)
908 {
909 #ifdef __MINGW32__
910 // This cast solves a linking problem with MinGW
911 ASSERT_NE(static_cast<unsigned long long>(a), static_cast<unsigned long long>(b));
912 #else
913 ASSERT_NE(a, b);
914 #endif
915 }
916
917
918
TEST(Toolbox,EndiannessConversions16)919 TEST(Toolbox, EndiannessConversions16)
920 {
921 Endianness e = Toolbox::DetectEndianness();
922
923 for (unsigned int i = 0; i < 65536; i += 17)
924 {
925 uint16_t v = static_cast<uint16_t>(i);
926 ASSERT_EQ16(v, be16toh(htobe16(v)));
927 ASSERT_EQ16(v, le16toh(htole16(v)));
928
929 const uint8_t* bytes = reinterpret_cast<const uint8_t*>(&v);
930 if (bytes[0] != bytes[1])
931 {
932 ASSERT_NE16(v, le16toh(htobe16(v)));
933 ASSERT_NE16(v, be16toh(htole16(v)));
934 }
935 else
936 {
937 ASSERT_EQ16(v, le16toh(htobe16(v)));
938 ASSERT_EQ16(v, be16toh(htole16(v)));
939 }
940
941 switch (e)
942 {
943 case Endianness_Little:
944 ASSERT_EQ16(v, htole16(v));
945 if (bytes[0] != bytes[1])
946 {
947 ASSERT_NE16(v, htobe16(v));
948 }
949 else
950 {
951 ASSERT_EQ16(v, htobe16(v));
952 }
953 break;
954
955 case Endianness_Big:
956 ASSERT_EQ16(v, htobe16(v));
957 if (bytes[0] != bytes[1])
958 {
959 ASSERT_NE16(v, htole16(v));
960 }
961 else
962 {
963 ASSERT_EQ16(v, htole16(v));
964 }
965 break;
966
967 default:
968 throw OrthancException(ErrorCode_ParameterOutOfRange);
969 }
970 }
971 }
972
973
TEST(Toolbox,EndiannessConversions32)974 TEST(Toolbox, EndiannessConversions32)
975 {
976 const uint32_t v = 0xff010203u;
977 const uint32_t r = 0x030201ffu;
978 ASSERT_EQ32(v, be32toh(htobe32(v)));
979 ASSERT_EQ32(v, le32toh(htole32(v)));
980 ASSERT_NE32(v, be32toh(htole32(v)));
981 ASSERT_NE32(v, le32toh(htobe32(v)));
982
983 switch (Toolbox::DetectEndianness())
984 {
985 case Endianness_Little:
986 ASSERT_EQ32(r, htobe32(v));
987 ASSERT_EQ32(v, htole32(v));
988 ASSERT_EQ32(r, be32toh(v));
989 ASSERT_EQ32(v, le32toh(v));
990 break;
991
992 case Endianness_Big:
993 ASSERT_EQ32(v, htobe32(v));
994 ASSERT_EQ32(r, htole32(v));
995 ASSERT_EQ32(v, be32toh(v));
996 ASSERT_EQ32(r, le32toh(v));
997 break;
998
999 default:
1000 throw OrthancException(ErrorCode_ParameterOutOfRange);
1001 }
1002 }
1003
1004
TEST(Toolbox,EndiannessConversions64)1005 TEST(Toolbox, EndiannessConversions64)
1006 {
1007 const uint64_t v = 0xff01020304050607LL;
1008 const uint64_t r = 0x07060504030201ffLL;
1009 ASSERT_EQ64(v, be64toh(htobe64(v)));
1010 ASSERT_EQ64(v, le64toh(htole64(v)));
1011 ASSERT_NE64(v, be64toh(htole64(v)));
1012 ASSERT_NE64(v, le64toh(htobe64(v)));
1013
1014 switch (Toolbox::DetectEndianness())
1015 {
1016 case Endianness_Little:
1017 ASSERT_EQ64(r, htobe64(v));
1018 ASSERT_EQ64(v, htole64(v));
1019 ASSERT_EQ64(r, be64toh(v));
1020 ASSERT_EQ64(v, le64toh(v));
1021 break;
1022
1023 case Endianness_Big:
1024 ASSERT_EQ64(v, htobe64(v));
1025 ASSERT_EQ64(r, htole64(v));
1026 ASSERT_EQ64(v, be64toh(v));
1027 ASSERT_EQ64(r, le64toh(v));
1028 break;
1029
1030 default:
1031 throw OrthancException(ErrorCode_ParameterOutOfRange);
1032 }
1033 }
1034
1035
1036 #if ORTHANC_SANDBOXED != 1
TEST(Toolbox,Now)1037 TEST(Toolbox, Now)
1038 {
1039 LOG(WARNING) << "Local time: " << SystemToolbox::GetNowIsoString(false);
1040 LOG(WARNING) << "Universal time: " << SystemToolbox::GetNowIsoString(true);
1041
1042 std::string date, time;
1043 SystemToolbox::GetNowDicom(date, time, false);
1044 LOG(WARNING) << "Local DICOM time: [" << date << "] [" << time << "]";
1045
1046 SystemToolbox::GetNowDicom(date, time, true);
1047 LOG(WARNING) << "Universal DICOM time: [" << date << "] [" << time << "]";
1048 }
1049 #endif
1050
1051
1052 #if ORTHANC_ENABLE_PUGIXML == 1
TEST(Toolbox,Xml)1053 TEST(Toolbox, Xml)
1054 {
1055 Json::Value a;
1056 a["hello"] = "world";
1057 a["42"] = 43;
1058 a["b"] = Json::arrayValue;
1059 a["b"].append("test");
1060 a["b"].append("test2");
1061
1062 std::string s;
1063 Toolbox::JsonToXml(s, a);
1064
1065 std::cout << s;
1066 }
1067 #endif
1068
1069
1070 #if !defined(_WIN32) && (ORTHANC_SANDBOXED != 1)
TEST(Toolbox,ExecuteSystemCommand)1071 TEST(Toolbox, ExecuteSystemCommand)
1072 {
1073 std::vector<std::string> args(2);
1074 args[0] = "Hello";
1075 args[1] = "World";
1076
1077 SystemToolbox::ExecuteSystemCommand("echo", args);
1078 }
1079 #endif
1080
1081
TEST(Toolbox,IsInteger)1082 TEST(Toolbox, IsInteger)
1083 {
1084 ASSERT_TRUE(Toolbox::IsInteger("00236"));
1085 ASSERT_TRUE(Toolbox::IsInteger("-0042"));
1086 ASSERT_TRUE(Toolbox::IsInteger("0"));
1087 ASSERT_TRUE(Toolbox::IsInteger("-0"));
1088
1089 ASSERT_FALSE(Toolbox::IsInteger(""));
1090 ASSERT_FALSE(Toolbox::IsInteger("42a"));
1091 ASSERT_FALSE(Toolbox::IsInteger("42-"));
1092 }
1093
1094
TEST(Toolbox,StartsWith)1095 TEST(Toolbox, StartsWith)
1096 {
1097 ASSERT_TRUE(Toolbox::StartsWith("hello world", ""));
1098 ASSERT_TRUE(Toolbox::StartsWith("hello world", "hello"));
1099 ASSERT_TRUE(Toolbox::StartsWith("hello world", "h"));
1100 ASSERT_FALSE(Toolbox::StartsWith("hello world", "H"));
1101 ASSERT_FALSE(Toolbox::StartsWith("h", "hello"));
1102 ASSERT_TRUE(Toolbox::StartsWith("h", "h"));
1103 ASSERT_FALSE(Toolbox::StartsWith("", "h"));
1104 }
1105
1106
TEST(Toolbox,UriEncode)1107 TEST(Toolbox, UriEncode)
1108 {
1109 std::string s;
1110
1111 // Unreserved characters must not be modified
1112 std::string t = "aAzZ09.-~_";
1113 Toolbox::UriEncode(s, t);
1114 ASSERT_EQ(t, s);
1115
1116 Toolbox::UriEncode(s, "!#$&'()*+,/:;=?@[]"); ASSERT_EQ("%21%23%24%26%27%28%29%2A%2B%2C/%3A%3B%3D%3F%40%5B%5D", s);
1117 Toolbox::UriEncode(s, "%"); ASSERT_EQ("%25", s);
1118
1119 // Encode characters from UTF-8. This is the test string from the
1120 // file "../Resources/EncodingTests.py"
1121 Toolbox::UriEncode(s, "\x54\x65\x73\x74\xc3\xa9\xc3\xa4\xc3\xb6\xc3\xb2\xd0\x94\xce\x98\xc4\x9d\xd7\x93\xd8\xb5\xc4\xb7\xd1\x9b\xe0\xb9\x9b\xef\xbe\x88\xc4\xb0");
1122 ASSERT_EQ("Test%C3%A9%C3%A4%C3%B6%C3%B2%D0%94%CE%98%C4%9D%D7%93%D8%B5%C4%B7%D1%9B%E0%B9%9B%EF%BE%88%C4%B0", s);
1123 }
1124
1125
TEST(Toolbox,AccessJson)1126 TEST(Toolbox, AccessJson)
1127 {
1128 Json::Value v = Json::arrayValue;
1129 ASSERT_EQ("nope", Toolbox::GetJsonStringField(v, "hello", "nope"));
1130
1131 v = Json::objectValue;
1132 ASSERT_EQ("nope", Toolbox::GetJsonStringField(v, "hello", "nope"));
1133 ASSERT_EQ(-10, Toolbox::GetJsonIntegerField(v, "hello", -10));
1134 ASSERT_EQ(10u, Toolbox::GetJsonUnsignedIntegerField(v, "hello", 10));
1135 ASSERT_TRUE(Toolbox::GetJsonBooleanField(v, "hello", true));
1136
1137 v["hello"] = "world";
1138 ASSERT_EQ("world", Toolbox::GetJsonStringField(v, "hello", "nope"));
1139 ASSERT_THROW(Toolbox::GetJsonIntegerField(v, "hello", -10), OrthancException);
1140 ASSERT_THROW(Toolbox::GetJsonUnsignedIntegerField(v, "hello", 10), OrthancException);
1141 ASSERT_THROW(Toolbox::GetJsonBooleanField(v, "hello", true), OrthancException);
1142
1143 v["hello"] = -42;
1144 ASSERT_THROW(Toolbox::GetJsonStringField(v, "hello", "nope"), OrthancException);
1145 ASSERT_EQ(-42, Toolbox::GetJsonIntegerField(v, "hello", -10));
1146 ASSERT_THROW(Toolbox::GetJsonUnsignedIntegerField(v, "hello", 10), OrthancException);
1147 ASSERT_THROW(Toolbox::GetJsonBooleanField(v, "hello", true), OrthancException);
1148
1149 v["hello"] = 42;
1150 ASSERT_THROW(Toolbox::GetJsonStringField(v, "hello", "nope"), OrthancException);
1151 ASSERT_EQ(42, Toolbox::GetJsonIntegerField(v, "hello", -10));
1152 ASSERT_EQ(42u, Toolbox::GetJsonUnsignedIntegerField(v, "hello", 10));
1153 ASSERT_THROW(Toolbox::GetJsonBooleanField(v, "hello", true), OrthancException);
1154
1155 v["hello"] = false;
1156 ASSERT_THROW(Toolbox::GetJsonStringField(v, "hello", "nope"), OrthancException);
1157 ASSERT_THROW(Toolbox::GetJsonIntegerField(v, "hello", -10), OrthancException);
1158 ASSERT_THROW(Toolbox::GetJsonUnsignedIntegerField(v, "hello", 10), OrthancException);
1159 ASSERT_FALSE(Toolbox::GetJsonBooleanField(v, "hello", true));
1160 }
1161
1162
TEST(Toolbox,LinesIterator)1163 TEST(Toolbox, LinesIterator)
1164 {
1165 std::string s;
1166
1167 {
1168 std::string content;
1169 Toolbox::LinesIterator it(content);
1170 ASSERT_FALSE(it.GetLine(s));
1171 }
1172
1173 {
1174 std::string content = "\n\r";
1175 Toolbox::LinesIterator it(content);
1176 ASSERT_TRUE(it.GetLine(s)); it.Next(); ASSERT_EQ("", s);
1177 ASSERT_FALSE(it.GetLine(s));
1178 }
1179
1180 {
1181 std::string content = "\n Hello \n\nWorld\n\n";
1182 Toolbox::LinesIterator it(content);
1183 ASSERT_TRUE(it.GetLine(s)); it.Next(); ASSERT_EQ("", s);
1184 ASSERT_TRUE(it.GetLine(s)); it.Next(); ASSERT_EQ(" Hello ", s);
1185 ASSERT_TRUE(it.GetLine(s)); it.Next(); ASSERT_EQ("", s);
1186 ASSERT_TRUE(it.GetLine(s)); it.Next(); ASSERT_EQ("World", s);
1187 ASSERT_TRUE(it.GetLine(s)); it.Next(); ASSERT_EQ("", s);
1188 ASSERT_FALSE(it.GetLine(s)); it.Next();
1189 ASSERT_FALSE(it.GetLine(s));
1190 }
1191
1192 {
1193 std::string content = "\r Hello \r\rWorld\r\r";
1194 Toolbox::LinesIterator it(content);
1195 ASSERT_TRUE(it.GetLine(s)); it.Next(); ASSERT_EQ("", s);
1196 ASSERT_TRUE(it.GetLine(s)); it.Next(); ASSERT_EQ(" Hello ", s);
1197 ASSERT_TRUE(it.GetLine(s)); it.Next(); ASSERT_EQ("", s);
1198 ASSERT_TRUE(it.GetLine(s)); it.Next(); ASSERT_EQ("World", s);
1199 ASSERT_TRUE(it.GetLine(s)); it.Next(); ASSERT_EQ("", s);
1200 ASSERT_FALSE(it.GetLine(s)); it.Next();
1201 ASSERT_FALSE(it.GetLine(s));
1202 }
1203
1204 {
1205 std::string content = "\n\r Hello \n\r\n\rWorld\n\r\n\r";
1206 Toolbox::LinesIterator it(content);
1207 ASSERT_TRUE(it.GetLine(s)); it.Next(); ASSERT_EQ("", s);
1208 ASSERT_TRUE(it.GetLine(s)); it.Next(); ASSERT_EQ(" Hello ", s);
1209 ASSERT_TRUE(it.GetLine(s)); it.Next(); ASSERT_EQ("", s);
1210 ASSERT_TRUE(it.GetLine(s)); it.Next(); ASSERT_EQ("World", s);
1211 ASSERT_TRUE(it.GetLine(s)); it.Next(); ASSERT_EQ("", s);
1212 ASSERT_FALSE(it.GetLine(s)); it.Next();
1213 ASSERT_FALSE(it.GetLine(s));
1214 }
1215
1216 {
1217 std::string content = "\r\n Hello \r\n\r\nWorld\r\n\r\n";
1218 Toolbox::LinesIterator it(content);
1219 ASSERT_TRUE(it.GetLine(s)); it.Next(); ASSERT_EQ("", s);
1220 ASSERT_TRUE(it.GetLine(s)); it.Next(); ASSERT_EQ(" Hello ", s);
1221 ASSERT_TRUE(it.GetLine(s)); it.Next(); ASSERT_EQ("", s);
1222 ASSERT_TRUE(it.GetLine(s)); it.Next(); ASSERT_EQ("World", s);
1223 ASSERT_TRUE(it.GetLine(s)); it.Next(); ASSERT_EQ("", s);
1224 ASSERT_FALSE(it.GetLine(s)); it.Next();
1225 ASSERT_FALSE(it.GetLine(s));
1226 }
1227 }
1228
1229
1230 #if ORTHANC_SANDBOXED != 1
TEST(Toolbox,SubstituteVariables)1231 TEST(Toolbox, SubstituteVariables)
1232 {
1233 std::map<std::string, std::string> env;
1234 env["NOPE"] = "nope";
1235 env["WORLD"] = "world";
1236
1237 ASSERT_EQ("Hello world\r\nWorld \r\nDone world\r\n",
1238 Toolbox::SubstituteVariables(
1239 "Hello ${WORLD}\r\nWorld ${HELLO}\r\nDone ${WORLD}\r\n",
1240 env));
1241
1242 ASSERT_EQ("world A a B world C 'c' D {\"a\":\"b\"} E ",
1243 Toolbox::SubstituteVariables(
1244 "${WORLD} A ${WORLD2:-a} B ${WORLD:-b} C ${WORLD2:-\"'c'\"} D ${WORLD2:-'{\"a\":\"b\"}'} E ${WORLD2:-}",
1245 env));
1246
1247 SystemToolbox::GetEnvironmentVariables(env);
1248 ASSERT_TRUE(env.find("NOPE") == env.end());
1249
1250 // The "PATH" environment variable should always be available on
1251 // machines running the unit tests
1252 ASSERT_TRUE(env.find("PATH") != env.end() /* Case used by UNIX */ ||
1253 env.find("Path") != env.end() /* Case used by Windows */);
1254
1255 env["PATH"] = "hello";
1256 ASSERT_EQ("AhelloB",
1257 Toolbox::SubstituteVariables("A${PATH}B", env));
1258 }
1259 #endif
1260
1261
1262 #if ORTHANC_SANDBOXED != 1
TEST(MetricsRegistry,Basic)1263 TEST(MetricsRegistry, Basic)
1264 {
1265 {
1266 MetricsRegistry m;
1267 m.SetEnabled(false);
1268 m.SetValue("hello.world", 42.5f);
1269
1270 std::string s;
1271 m.ExportPrometheusText(s);
1272 ASSERT_TRUE(s.empty());
1273 }
1274
1275 {
1276 MetricsRegistry m;
1277 m.Register("hello.world", MetricsType_Default);
1278
1279 std::string s;
1280 m.ExportPrometheusText(s);
1281 ASSERT_TRUE(s.empty());
1282 }
1283
1284 {
1285 MetricsRegistry m;
1286 m.SetValue("hello.world", 42.5f);
1287 ASSERT_EQ(MetricsType_Default, m.GetMetricsType("hello.world"));
1288 ASSERT_THROW(m.GetMetricsType("nope"), OrthancException);
1289
1290 std::string s;
1291 m.ExportPrometheusText(s);
1292
1293 std::vector<std::string> t;
1294 Toolbox::TokenizeString(t, s, '\n');
1295 ASSERT_EQ(2u, t.size());
1296 ASSERT_EQ("hello.world 42.5 ", t[0].substr(0, 17));
1297 ASSERT_TRUE(t[1].empty());
1298 }
1299
1300 {
1301 MetricsRegistry m;
1302 m.Register("hello.max", MetricsType_MaxOver10Seconds);
1303 m.SetValue("hello.max", 10);
1304 m.SetValue("hello.max", 20);
1305 m.SetValue("hello.max", -10);
1306 m.SetValue("hello.max", 5);
1307
1308 m.Register("hello.min", MetricsType_MinOver10Seconds);
1309 m.SetValue("hello.min", 10);
1310 m.SetValue("hello.min", 20);
1311 m.SetValue("hello.min", -10);
1312 m.SetValue("hello.min", 5);
1313
1314 m.Register("hello.default", MetricsType_Default);
1315 m.SetValue("hello.default", 10);
1316 m.SetValue("hello.default", 20);
1317 m.SetValue("hello.default", -10);
1318 m.SetValue("hello.default", 5);
1319
1320 ASSERT_EQ(MetricsType_MaxOver10Seconds, m.GetMetricsType("hello.max"));
1321 ASSERT_EQ(MetricsType_MinOver10Seconds, m.GetMetricsType("hello.min"));
1322 ASSERT_EQ(MetricsType_Default, m.GetMetricsType("hello.default"));
1323
1324 std::string s;
1325 m.ExportPrometheusText(s);
1326
1327 std::vector<std::string> t;
1328 Toolbox::TokenizeString(t, s, '\n');
1329 ASSERT_EQ(4u, t.size());
1330 ASSERT_TRUE(t[3].empty());
1331
1332 std::map<std::string, std::string> u;
1333 for (size_t i = 0; i < t.size() - 1; i++)
1334 {
1335 std::vector<std::string> v;
1336 Toolbox::TokenizeString(v, t[i], ' ');
1337 u[v[0]] = v[1];
1338 }
1339
1340 ASSERT_EQ("20", u["hello.max"]);
1341 ASSERT_EQ("-10", u["hello.min"]);
1342 ASSERT_EQ("5", u["hello.default"]);
1343 }
1344
1345 {
1346 MetricsRegistry m;
1347
1348 m.SetValue("a", 10);
1349 m.SetValue("b", 10, MetricsType_MinOver10Seconds);
1350
1351 m.Register("c", MetricsType_MaxOver10Seconds);
1352 m.SetValue("c", 10, MetricsType_MinOver10Seconds);
1353
1354 m.Register("d", MetricsType_MaxOver10Seconds);
1355 m.Register("d", MetricsType_Default);
1356
1357 ASSERT_EQ(MetricsType_Default, m.GetMetricsType("a"));
1358 ASSERT_EQ(MetricsType_MinOver10Seconds, m.GetMetricsType("b"));
1359 ASSERT_EQ(MetricsType_MaxOver10Seconds, m.GetMetricsType("c"));
1360 ASSERT_EQ(MetricsType_Default, m.GetMetricsType("d"));
1361 }
1362
1363 {
1364 MetricsRegistry m;
1365
1366 {
1367 MetricsRegistry::Timer t1(m, "a");
1368 MetricsRegistry::Timer t2(m, "b", MetricsType_MinOver10Seconds);
1369 }
1370
1371 ASSERT_EQ(MetricsType_MaxOver10Seconds, m.GetMetricsType("a"));
1372 ASSERT_EQ(MetricsType_MinOver10Seconds, m.GetMetricsType("b"));
1373 }
1374 }
1375 #endif
1376
1377
1378 #if ORTHANC_SANDBOXED != 1
TEST(Toolbox,ReadFileRange)1379 TEST(Toolbox, ReadFileRange)
1380 {
1381 TemporaryFile tmp;
1382 std::string s;
1383
1384 tmp.Write("");
1385 tmp.Read(s); ASSERT_TRUE(s.empty());
1386 tmp.ReadRange(s, 0, 0, true); ASSERT_TRUE(s.empty());
1387 tmp.ReadRange(s, 0, 10, false); ASSERT_TRUE(s.empty());
1388
1389 ASSERT_THROW(tmp.ReadRange(s, 0, 1, true), OrthancException);
1390
1391 tmp.Write("Hello");
1392 tmp.Read(s); ASSERT_EQ("Hello", s);
1393 tmp.ReadRange(s, 0, 5, true); ASSERT_EQ("Hello", s);
1394 tmp.ReadRange(s, 0, 1, true); ASSERT_EQ("H", s);
1395 tmp.ReadRange(s, 1, 2, true); ASSERT_EQ("e", s);
1396 tmp.ReadRange(s, 2, 3, true); ASSERT_EQ("l", s);
1397 tmp.ReadRange(s, 3, 4, true); ASSERT_EQ("l", s);
1398 tmp.ReadRange(s, 4, 5, true); ASSERT_EQ("o", s);
1399 tmp.ReadRange(s, 2, 5, true); ASSERT_EQ("llo", s);
1400 tmp.ReadRange(s, 2, 50, false); ASSERT_EQ("llo", s);
1401 tmp.ReadRange(s, 2, 2, false); ASSERT_TRUE(s.empty());
1402 tmp.ReadRange(s, 10, 50, false); ASSERT_TRUE(s.empty());
1403
1404 ASSERT_THROW(tmp.ReadRange(s, 5, 10, true), OrthancException);
1405 ASSERT_THROW(tmp.ReadRange(s, 10, 50, true), OrthancException);
1406 ASSERT_THROW(tmp.ReadRange(s, 50, 10, true), OrthancException);
1407 ASSERT_THROW(tmp.ReadRange(s, 2, 1, true), OrthancException);
1408 }
1409 #endif
1410