regression test output

SophistSolutions · Feb 28, 2025 · 4e48d8c · 4e48d8c
1 parent fb9d5d2
commit 4e48d8c
Show file tree

Hide file tree

Showing 9 changed files with 46,428 additions and 0 deletions.
diff --git a/...istoricalPerformanceRegressionTestResults/3.0/PerformanceDump-MacOS_XCode16_m1-3.0d16.txt b/...istoricalPerformanceRegressionTestResults/3.0/PerformanceDump-MacOS_XCode16_m1-3.0d16.txt
@@ -0,0 +1,194 @@
+Performance score 1.0 means both sides equal (ratio), and tests setup so lower is generally better
+
+[[[Started testing at: Thu Feb 27 11:54:26 2025]]]
+
+Using TIME MULTIPLIER: 15
+
+Test Test of simple locking strategies (mutex v shared_ptr copy) (mutex vs shared_ptr<> copy)
+	PERFORMANCE_SCORE	1.5
+	DETAILS:         	[baseline test 3.19686 secs, and comparison 4.82182 sec, and warnIfPerfScore > 0.9, and perfScore=1.5083]
+	                 	shared_ptr<> copy is ***SLOWER***
+
+Test Test of simple locking strategies (mutex v SpinLock) (mutex vs SpinLock)
+	PERFORMANCE_SCORE	0.71
+	DETAILS:         	[baseline test 3.19695 secs, and comparison 2.28038 sec, and warnIfPerfScore > 0.51, and perfScore=0.713297]
+	                 	SpinLock is FASTER
+
+Test Simple Struct With Strings Filling And Copying (wstring vs Characters::String)
+	PERFORMANCE_SCORE	0.3
+	DETAILS:         	[baseline test 2.53555 secs, and comparison 0.757428 sec, and warnIfPerfScore > 0.49, and perfScore=0.298723]
+	                 	Characters::String is FASTER
+
+Test Simple Struct With Strings Filling And Copying2 (wstring vs Characters::String)
+	PERFORMANCE_SCORE	0.43
+	DETAILS:         	[baseline test 2.36116 secs, and comparison 1.00534 sec, and warnIfPerfScore > 0.45, and perfScore=0.425781]
+	                 	Characters::String is FASTER
+
+Test Simple String append test (+='string object') 10x (wstring vs Characters::String)
+	PERFORMANCE_SCORE	1.2
+	DETAILS:         	[baseline test 8.02506 secs, and comparison 9.49706 sec, and warnIfPerfScore > 4.9, and perfScore=1.18343]
+	                 	Characters::String is ***SLOWER***
+
+Test Simple String append test (+=wchar_t[]) 10x (wstring vs Characters::String)
+	PERFORMANCE_SCORE	3.6
+	DETAILS:         	[baseline test 7.65238 secs, and comparison 27.4949 sec, and warnIfPerfScore > 4.1, and perfScore=3.59299]
+	                 	Characters::String is ***SLOWER***
+
+Test Simple String append test (+=wchar_t[]) 100x (wstring vs Characters::String)
+	PERFORMANCE_SCORE	6.6
+	DETAILS:         	[baseline test 32.0014 secs, and comparison 210.089 sec, and warnIfPerfScore > 78, and perfScore=6.565]
+	                 	Characters::String is ***SLOWER***
+
+Test String a + b (wstring vs String)
+	PERFORMANCE_SCORE	1.7
+	DETAILS:         	[baseline test 2.85717 secs, and comparison 4.74489 sec, and warnIfPerfScore > 2.1, and perfScore=1.6607]
+	                 	String is ***SLOWER***
+
+Test wstringstream << test (wstring vs Characters::String)
+	PERFORMANCE_SCORE	1.2
+	DETAILS:         	[baseline test 4.34705 secs, and comparison 5.27778 sec, and warnIfPerfScore > 1.4, and perfScore=1.21411]
+	                 	Characters::String is ***SLOWER***
+
+Test String::substr() (wstring vs Characters::String)
+	PERFORMANCE_SCORE	1.8
+	DETAILS:         	[baseline test 2.43445 secs, and comparison 4.45755 sec, and warnIfPerfScore > 1.7, and perfScore=1.83103]
+	                 	Characters::String is ***SLOWER***
+
+Test wstringstream versus BasicTextOutputStream (wstringstream vs MemoryStream<Characters::Character>)
+	PERFORMANCE_SCORE	0.86
+	DETAILS:         	[baseline test 4.18449 secs, and comparison 3.58897 sec, and warnIfPerfScore > 1.2, and perfScore=0.857684]
+	                 	MemoryStream<Characters::Character> is FASTER
+
+Test wstringstream versus StringBuilder (wstringstream vs StringBuilder)
+	PERFORMANCE_SCORE	0.67
+	DETAILS:         	[baseline test 4.38704 secs, and comparison 2.93114 sec, and warnIfPerfScore > 0.48, and perfScore=0.668135]
+	                 	StringBuilder is FASTER
+
+Test Sequence<int> basics (vector<int> vs Sequence<int>)
+	PERFORMANCE_SCORE	1.2
+	DETAILS:         	[baseline test 3.84862 secs, and comparison 4.76131 sec, and warnIfPerfScore > 0.75, and perfScore=1.23715]
+	                 	Sequence<int> is ***SLOWER***
+
+Test Sequence<string> basics (vector<string> vs Sequence<string>)
+	PERFORMANCE_SCORE	0.36
+	DETAILS:         	[baseline test 1.90777 secs, and comparison 0.681629 sec, and warnIfPerfScore > 0.33, and perfScore=0.357292]
+	                 	Sequence<string> is FASTER
+
+Test Sequence_DoublyLinkedList<int> basics (vector<int> vs Sequence_DoublyLinkedList<int>)
+	PERFORMANCE_SCORE	9
+	DETAILS:         	[baseline test 3.72989 secs, and comparison 33.6476 sec, and warnIfPerfScore > 5.1, and perfScore=9.02107]
+	                 	Sequence_DoublyLinkedList<int> is ***SLOWER***
+
+Test Sequence_Array<int> basics (vector<int> vs Sequence_Array<int>)
+	PERFORMANCE_SCORE	1.2
+	DETAILS:         	[baseline test 3.72935 secs, and comparison 4.56692 sec, and warnIfPerfScore > 0.7, and perfScore=1.22459]
+	                 	Sequence_Array<int> is ***SLOWER***
+
+Test Sequence_stdvector<int> basics (vector<int> vs Sequence_stdvector<int>)
+	PERFORMANCE_SCORE	2
+	DETAILS:         	[baseline test 3.75741 secs, and comparison 7.57215 sec, and warnIfPerfScore > 1.1, and perfScore=2.01526]
+	                 	Sequence_stdvector<int> is ***SLOWER***
+
+Test Sequence_DoublyLinkedList<string> basics (vector<string> vs Sequence_DoublyLinkedList<string>)
+	PERFORMANCE_SCORE	1.5
+	DETAILS:         	[baseline test 1.90757 secs, and comparison 2.94768 sec, and warnIfPerfScore > 0.55, and perfScore=1.54525]
+	                 	Sequence_DoublyLinkedList<string> is ***SLOWER***
+
+Test Collection<int> basics (vector<int> vs Collection<int>)
+	PERFORMANCE_SCORE	5.7
+	DETAILS:         	[baseline test 5.09357 secs, and comparison 28.9637 sec, and warnIfPerfScore > 4.9, and perfScore=5.68634]
+	                 	Collection<int> is ***SLOWER***
+
+Test Collection<string> basics (vector<string> vs Collection<string>)
+	PERFORMANCE_SCORE	2.9
+	DETAILS:         	[baseline test 1.94905 secs, and comparison 5.72736 sec, and warnIfPerfScore > 0.85, and perfScore=2.93853]
+	                 	Collection<string> is ***SLOWER***
+
+Test Collection_LinkedList<string> basics (vector<string> vs Collection_LinkedList<string>)
+	PERFORMANCE_SCORE	1.4
+	DETAILS:         	[baseline test 1.95009 secs, and comparison 2.73549 sec, and warnIfPerfScore > 0.6, and perfScore=1.40275]
+	                 	Collection_LinkedList<string> is ***SLOWER***
+
+Test Collection_stdforward_list<string> basics (vector<string> vs Collection_stdforward_list<string>)
+	PERFORMANCE_SCORE	1.4
+	DETAILS:         	[baseline test 1.95001 secs, and comparison 2.73756 sec, and warnIfPerfScore > 0.6, and perfScore=1.40387]
+	                 	Collection_stdforward_list<string> is ***SLOWER***
+
+Test SortedCollection_stdmultiset<string> basics (vector<string> vs SortedCollection_stdmultiset<string>)
+	PERFORMANCE_SCORE	2.9
+	DETAILS:         	[baseline test 1.94998 secs, and comparison 5.73745 sec, and warnIfPerfScore > 1, and perfScore=2.94232]
+	                 	SortedCollection_stdmultiset<string> is ***SLOWER***
+
+Test SortedCollection_stdmultiset<string> basics with rnd strings (vector<string> vs SortedCollection_stdmultiset<string>)
+	PERFORMANCE_SCORE	3.4
+	DETAILS:         	[baseline test 2.34681 secs, and comparison 7.8958 sec, and warnIfPerfScore > 1.3, and perfScore=3.36449]
+	                 	SortedCollection_stdmultiset<string> is ***SLOWER***
+
+Test std::set<int> vs Set<int> (set<int> vs Set<int>)
+	PERFORMANCE_SCORE	0.17
+	DETAILS:         	[baseline test 27.1125 secs, and comparison 4.5296 sec, and warnIfPerfScore > 0.21, and perfScore=0.167067]
+	                 	Set<int> is FASTER
+
+Test String Characters::Format () (sprintf vs String Characters::Format)
+	PERFORMANCE_SCORE	1
+	DETAILS:         	[baseline test 8.63857 secs, and comparison 8.68303 sec, and warnIfPerfScore > 1.8, and perfScore=1.00515]
+	                 	String Characters::Format is ***SLOWER***
+
+Test BLOB versus vector<byte> (vector<byte> vs BLOB)
+	PERFORMANCE_SCORE	2.2
+	DETAILS:         	[baseline test 2.60084 secs, and comparison 5.63145 sec, and warnIfPerfScore > 1, and perfScore=2.16524]
+	                 	BLOB is ***SLOWER***
+
+Test BLOB versus vector<byte> ver#2 (vector<byte> vs BLOB)
+	PERFORMANCE_SCORE	2.9
+	DETAILS:         	[baseline test 1.57738 secs, and comparison 4.54567 sec, and warnIfPerfScore > 0.85, and perfScore=2.88178]
+	                 	BLOB is ***SLOWER***
+
+Test Test_JSONReadWriteFile (15 seconds vs Test_JSONReadWriteFile)
+	PERFORMANCE_SCORE	0.24
+	DETAILS:         	[baseline test 15 secs, and comparison 3.58151 sec, and warnIfPerfScore > 0.5, and perfScore=0.238767]
+	                 	Test_JSONReadWriteFile is FASTER
+
+Test Test_Optional_ (15 seconds vs Test_Optional_)
+	PERFORMANCE_SCORE	0.11
+	DETAILS:         	[baseline test 15 secs, and comparison 1.64061 sec, and warnIfPerfScore > 0.5, and perfScore=0.109374]
+	                 	Test_Optional_ is FASTER
+
+stroika-json-native-parser: "./Tests/51/JSONTestData/small-dict.json"
+	DETAILS			0.104689 seconds
+
+stroika-json-native-parser: "./Tests/51/JSONTestData/medium-dict.json"
+	DETAILS			1.28784 seconds
+
+stroika-json-native-parser: "./Tests/51/JSONTestData/large-dict.json"
+	DETAILS			4.0729 seconds
+
+stroika-json-parser: "./Tests/51/JSONTestData/small-dict.json"
+	DETAILS			0.05327 seconds
+
+stroika-json-parser: "./Tests/51/JSONTestData/medium-dict.json"
+	DETAILS			0.690372 seconds
+
+stroika-json-parser: "./Tests/51/JSONTestData/large-dict.json"
+	DETAILS			2.4774 seconds
+
+boost_json-parser: "./Tests/51/JSONTestData/small-dict.json"
+	DETAILS			0.0242286 seconds
+
+boost_json-parser: "./Tests/51/JSONTestData/medium-dict.json"
+	DETAILS			0.298193 seconds
+
+boost_json-parser: "./Tests/51/JSONTestData/large-dict.json"
+	DETAILS			0.976242 seconds
+
+boost_json-vv-parser: "./Tests/51/JSONTestData/small-dict.json"
+	DETAILS			0.0648292 seconds
+
+boost_json-vv-parser: "./Tests/51/JSONTestData/medium-dict.json"
+	DETAILS			0.836903 seconds
+
+boost_json-vv-parser: "./Tests/51/JSONTestData/large-dict.json"
+	DETAILS			2.90492 seconds
+
+[[[Tests took: 9 minutes, 38 seconds]]]
+
diff --git a/...storicalPerformanceRegressionTestResults/3.0/PerformanceDump-Ubuntu2204_x86_64-3.0d16.txt b/...storicalPerformanceRegressionTestResults/3.0/PerformanceDump-Ubuntu2204_x86_64-3.0d16.txt
@@ -0,0 +1,194 @@
+Performance score 1.0 means both sides equal (ratio), and tests setup so lower is generally better
+
+[[[Started testing at: Thu Feb 27 18:30:16 2025]]]
+
+Using TIME MULTIPLIER: 15
+
+Test Test of simple locking strategies (mutex v shared_ptr copy) (mutex vs shared_ptr<> copy)
+	PERFORMANCE_SCORE	0.9
+	DETAILS:         	[baseline test 3.62402 secs, and comparison 3.26865 sec, and warnIfPerfScore > 0.9, and perfScore=0.901942]
+	                 	shared_ptr<> copy is FASTER
+
+Test Test of simple locking strategies (mutex v SpinLock) (mutex vs SpinLock)
+	PERFORMANCE_SCORE	0.9
+	DETAILS:         	[baseline test 3.42574 secs, and comparison 3.08032 sec, and warnIfPerfScore > 0.51, and perfScore=0.899168]
+	                 	SpinLock is FASTER
+
+Test Simple Struct With Strings Filling And Copying (wstring vs Characters::String)
+	PERFORMANCE_SCORE	0.26
+	DETAILS:         	[baseline test 3.76869 secs, and comparison 0.996004 sec, and warnIfPerfScore > 0.49, and perfScore=0.264284]
+	                 	Characters::String is FASTER
+
+Test Simple Struct With Strings Filling And Copying2 (wstring vs Characters::String)
+	PERFORMANCE_SCORE	0.27
+	DETAILS:         	[baseline test 4.48839 secs, and comparison 1.19312 sec, and warnIfPerfScore > 0.45, and perfScore=0.265825]
+	                 	Characters::String is FASTER
+
+Test Simple String append test (+='string object') 10x (wstring vs Characters::String)
+	PERFORMANCE_SCORE	0.85
+	DETAILS:         	[baseline test 9.75317 secs, and comparison 8.3083 sec, and warnIfPerfScore > 4.9, and perfScore=0.851857]
+	                 	Characters::String is FASTER
+
+Test Simple String append test (+=wchar_t[]) 10x (wstring vs Characters::String)
+	PERFORMANCE_SCORE	2.7
+	DETAILS:         	[baseline test 11.2569 secs, and comparison 30.4975 sec, and warnIfPerfScore > 4.1, and perfScore=2.70923]
+	                 	Characters::String is ***SLOWER***
+
+Test Simple String append test (+=wchar_t[]) 100x (wstring vs Characters::String)
+	PERFORMANCE_SCORE	4
+	DETAILS:         	[baseline test 71.8817 secs, and comparison 289.283 sec, and warnIfPerfScore > 78, and perfScore=4.02443]
+	                 	Characters::String is ***SLOWER***
+
+Test String a + b (wstring vs String)
+	PERFORMANCE_SCORE	0.84
+	DETAILS:         	[baseline test 5.07798 secs, and comparison 4.28868 sec, and warnIfPerfScore > 2.1, and perfScore=0.844564]
+	                 	String is FASTER
+
+Test wstringstream << test (wstring vs Characters::String)
+	PERFORMANCE_SCORE	1.2
+	DETAILS:         	[baseline test 7.24476 secs, and comparison 8.59843 sec, and warnIfPerfScore > 1.4, and perfScore=1.18685]
+	                 	Characters::String is ***SLOWER***
+
+Test String::substr() (wstring vs Characters::String)
+	PERFORMANCE_SCORE	1.8
+	DETAILS:         	[baseline test 2.86098 secs, and comparison 5.2816 sec, and warnIfPerfScore > 1.7, and perfScore=1.84608]
+	                 	Characters::String is ***SLOWER***
+
+Test wstringstream versus BasicTextOutputStream (wstringstream vs MemoryStream<Characters::Character>)
+	PERFORMANCE_SCORE	1.2
+	DETAILS:         	[baseline test 3.68529 secs, and comparison 4.57582 sec, and warnIfPerfScore > 1.2, and perfScore=1.24165]
+	                 	MemoryStream<Characters::Character> is ***SLOWER***
+
+Test wstringstream versus StringBuilder (wstringstream vs StringBuilder)
+	PERFORMANCE_SCORE	1
+	DETAILS:         	[baseline test 3.79566 secs, and comparison 3.80102 sec, and warnIfPerfScore > 0.48, and perfScore=1.00141]
+	                 	StringBuilder is ***SLOWER***
+
+Test Sequence<int> basics (vector<int> vs Sequence<int>)
+	PERFORMANCE_SCORE	2
+	DETAILS:         	[baseline test 3.31292 secs, and comparison 6.47463 sec, and warnIfPerfScore > 0.75, and perfScore=1.95436]
+	                 	Sequence<int> is ***SLOWER***
+
+Test Sequence<string> basics (vector<string> vs Sequence<string>)
+	PERFORMANCE_SCORE	0.063
+	DETAILS:         	[baseline test 19.6452 secs, and comparison 1.2423 sec, and warnIfPerfScore > 0.33, and perfScore=0.0632366]
+	                 	Sequence<string> is FASTER
+
+Test Sequence_DoublyLinkedList<int> basics (vector<int> vs Sequence_DoublyLinkedList<int>)
+	PERFORMANCE_SCORE	12
+	DETAILS:         	[baseline test 3.15617 secs, and comparison 37.5258 sec, and warnIfPerfScore > 5.1, and perfScore=11.8897]
+	                 	Sequence_DoublyLinkedList<int> is ***SLOWER***
+
+Test Sequence_Array<int> basics (vector<int> vs Sequence_Array<int>)
+	PERFORMANCE_SCORE	1.9
+	DETAILS:         	[baseline test 3.47365 secs, and comparison 6.55138 sec, and warnIfPerfScore > 0.7, and perfScore=1.88602]
+	                 	Sequence_Array<int> is ***SLOWER***
+
+Test Sequence_stdvector<int> basics (vector<int> vs Sequence_stdvector<int>)
+	PERFORMANCE_SCORE	2.2
+	DETAILS:         	[baseline test 3.46577 secs, and comparison 7.64078 sec, and warnIfPerfScore > 1.1, and perfScore=2.20464]
+	                 	Sequence_stdvector<int> is ***SLOWER***
+
+Test Sequence_DoublyLinkedList<string> basics (vector<string> vs Sequence_DoublyLinkedList<string>)
+	PERFORMANCE_SCORE	0.48
+	DETAILS:         	[baseline test 10.3925 secs, and comparison 4.95952 sec, and warnIfPerfScore > 0.55, and perfScore=0.477221]
+	                 	Sequence_DoublyLinkedList<string> is FASTER
+
+Test Collection<int> basics (vector<int> vs Collection<int>)
+	PERFORMANCE_SCORE	5.5
+	DETAILS:         	[baseline test 6.9842 secs, and comparison 38.3122 sec, and warnIfPerfScore > 4.9, and perfScore=5.48555]
+	                 	Collection<int> is ***SLOWER***
+
+Test Collection<string> basics (vector<string> vs Collection<string>)
+	PERFORMANCE_SCORE	0.37
+	DETAILS:         	[baseline test 11.324 secs, and comparison 4.13668 sec, and warnIfPerfScore > 0.85, and perfScore=0.365301]
+	                 	Collection<string> is FASTER
+
+Test Collection_LinkedList<string> basics (vector<string> vs Collection_LinkedList<string>)
+	PERFORMANCE_SCORE	0.27
+	DETAILS:         	[baseline test 12.1181 secs, and comparison 3.25934 sec, and warnIfPerfScore > 0.6, and perfScore=0.268964]
+	                 	Collection_LinkedList<string> is FASTER
+
+Test Collection_stdforward_list<string> basics (vector<string> vs Collection_stdforward_list<string>)
+	PERFORMANCE_SCORE	0.29
+	DETAILS:         	[baseline test 12.1053 secs, and comparison 3.54529 sec, and warnIfPerfScore > 0.6, and perfScore=0.292869]
+	                 	Collection_stdforward_list<string> is FASTER
+
+Test SortedCollection_stdmultiset<string> basics (vector<string> vs SortedCollection_stdmultiset<string>)
+	PERFORMANCE_SCORE	0.34
+	DETAILS:         	[baseline test 12.113 secs, and comparison 4.12098 sec, and warnIfPerfScore > 1, and perfScore=0.340211]
+	                 	SortedCollection_stdmultiset<string> is FASTER
+
+Test SortedCollection_stdmultiset<string> basics with rnd strings (vector<string> vs SortedCollection_stdmultiset<string>)
+	PERFORMANCE_SCORE	0.55
+	DETAILS:         	[baseline test 19.6068 secs, and comparison 10.8114 sec, and warnIfPerfScore > 1.3, and perfScore=0.551412]
+	                 	SortedCollection_stdmultiset<string> is FASTER
+
+Test std::set<int> vs Set<int> (set<int> vs Set<int>)
+	PERFORMANCE_SCORE	0.26
+	DETAILS:         	[baseline test 18.9057 secs, and comparison 4.90149 sec, and warnIfPerfScore > 0.21, and perfScore=0.25926]
+	                 	Set<int> is FASTER
+
+Test String Characters::Format () (sprintf vs String Characters::Format)
+	PERFORMANCE_SCORE	1.4
+	DETAILS:         	[baseline test 7.43932 secs, and comparison 10.4285 sec, and warnIfPerfScore > 1.8, and perfScore=1.4018]
+	                 	String Characters::Format is ***SLOWER***
+
+Test BLOB versus vector<byte> (vector<byte> vs BLOB)
+	PERFORMANCE_SCORE	0.74
+	DETAILS:         	[baseline test 6.70356 secs, and comparison 4.94501 sec, and warnIfPerfScore > 1, and perfScore=0.73767]
+	                 	BLOB is FASTER
+
+Test BLOB versus vector<byte> ver#2 (vector<byte> vs BLOB)
+	PERFORMANCE_SCORE	0.8
+	DETAILS:         	[baseline test 4.41171 secs, and comparison 3.53861 sec, and warnIfPerfScore > 0.85, and perfScore=0.802096]
+	                 	BLOB is FASTER
+
+Test Test_JSONReadWriteFile (15 seconds vs Test_JSONReadWriteFile)
+	PERFORMANCE_SCORE	0.39
+	DETAILS:         	[baseline test 15 secs, and comparison 5.90689 sec, and warnIfPerfScore > 0.5, and perfScore=0.393792]
+	                 	Test_JSONReadWriteFile is FASTER
+
+Test Test_Optional_ (15 seconds vs Test_Optional_)
+	PERFORMANCE_SCORE	0.075
+	DETAILS:         	[baseline test 15 secs, and comparison 1.11976 sec, and warnIfPerfScore > 0.5, and perfScore=0.074651]
+	                 	Test_Optional_ is FASTER
+
+stroika-json-native-parser: "./Tests/51/JSONTestData/small-dict.json"
+	DETAILS			0.194161 seconds
+
+stroika-json-native-parser: "./Tests/51/JSONTestData/medium-dict.json"
+	DETAILS			2.79247 seconds
+
+stroika-json-native-parser: "./Tests/51/JSONTestData/large-dict.json"
+	DETAILS			9.57677 seconds
+
+stroika-json-parser: "./Tests/51/JSONTestData/small-dict.json"
+	DETAILS			0.0899773 seconds
+
+stroika-json-parser: "./Tests/51/JSONTestData/medium-dict.json"
+	DETAILS			1.44562 seconds
+
+stroika-json-parser: "./Tests/51/JSONTestData/large-dict.json"
+	DETAILS			5.52805 seconds
+
+boost_json-parser: "./Tests/51/JSONTestData/small-dict.json"
+	DETAILS			0.0304144 seconds
+
+boost_json-parser: "./Tests/51/JSONTestData/medium-dict.json"
+	DETAILS			0.419872 seconds
+
+boost_json-parser: "./Tests/51/JSONTestData/large-dict.json"
+	DETAILS			1.65121 seconds
+
+boost_json-vv-parser: "./Tests/51/JSONTestData/small-dict.json"
+	DETAILS			0.113539 seconds
+
+boost_json-vv-parser: "./Tests/51/JSONTestData/medium-dict.json"
+	DETAILS			1.64217 seconds
+
+boost_json-vv-parser: "./Tests/51/JSONTestData/large-dict.json"
+	DETAILS			6.24966 seconds
+
+[[[Tests took: 14 minutes, 2 seconds]]]
+