|
207
|
1 //===-- JSON Tests --------------------------------------------------------===//
|
|
|
2 //
|
|
|
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
|
4 // See https://llvm.org/LICENSE.txt for license information.
|
|
|
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
|
6 //
|
|
|
7 //===----------------------------------------------------------------------===//
|
|
|
8
|
|
|
9 #include "JSON.h"
|
|
|
10 #include "LibcBenchmark.h"
|
|
|
11 #include "LibcMemoryBenchmark.h"
|
|
|
12 #include "llvm/Support/JSON.h"
|
|
|
13 #include "llvm/Support/raw_ostream.h"
|
|
|
14 #include "gmock/gmock.h"
|
|
|
15 #include "gtest/gtest.h"
|
|
|
16
|
|
|
17 using testing::AllOf;
|
|
|
18 using testing::ExplainMatchResult;
|
|
|
19 using testing::Field;
|
|
|
20 using testing::Pointwise;
|
|
|
21
|
|
|
22 namespace llvm {
|
|
|
23 namespace libc_benchmarks {
|
|
|
24 namespace {
|
|
|
25
|
|
|
26 Study getStudy() {
|
|
|
27 return Study{
|
|
|
28 "StudyName",
|
|
|
29 Runtime{HostState{"CpuName",
|
|
|
30 123,
|
|
|
31 {CacheInfo{"A", 1, 2, 3}, CacheInfo{"B", 4, 5, 6}}},
|
|
|
32 456, 789,
|
|
|
33 BenchmarkOptions{std::chrono::seconds(1), std::chrono::seconds(2),
|
|
|
34 10, 100, 6, 100, 0.1, 2, BenchmarkLog::Full}},
|
|
|
35 StudyConfiguration{std::string("Function"), 30U, false, 32U,
|
|
|
36 std::string("Distribution"), Align(16), 3U},
|
|
|
37 {std::chrono::seconds(3), std::chrono::seconds(4)}};
|
|
|
38 }
|
|
|
39
|
|
|
40 static std::string serializeToString(const Study &S) {
|
|
|
41 std::string Buffer;
|
|
|
42 raw_string_ostream RSO(Buffer);
|
|
|
43 json::OStream JOS(RSO);
|
|
|
44 serializeToJson(S, JOS);
|
|
|
45 return Buffer;
|
|
|
46 }
|
|
|
47
|
|
|
48 MATCHER(EqualsCacheInfo, "") {
|
|
|
49 const CacheInfo &A = ::testing::get<0>(arg);
|
|
|
50 const CacheInfo &B = ::testing::get<1>(arg);
|
|
|
51 return ExplainMatchResult(AllOf(Field(&CacheInfo::Type, B.Type),
|
|
|
52 Field(&CacheInfo::Level, B.Level),
|
|
|
53 Field(&CacheInfo::Size, B.Size),
|
|
|
54 Field(&CacheInfo::NumSharing, B.NumSharing)),
|
|
|
55 A, result_listener);
|
|
|
56 }
|
|
|
57
|
|
|
58 auto equals(const HostState &H) -> auto {
|
|
|
59 return AllOf(
|
|
|
60 Field(&HostState::CpuName, H.CpuName),
|
|
|
61 Field(&HostState::CpuFrequency, H.CpuFrequency),
|
|
|
62 Field(&HostState::Caches, Pointwise(EqualsCacheInfo(), H.Caches)));
|
|
|
63 }
|
|
|
64
|
|
|
65 auto equals(const StudyConfiguration &SC) -> auto {
|
|
|
66 return AllOf(
|
|
|
67 Field(&StudyConfiguration::Function, SC.Function),
|
|
|
68 Field(&StudyConfiguration::NumTrials, SC.NumTrials),
|
|
|
69 Field(&StudyConfiguration::IsSweepMode, SC.IsSweepMode),
|
|
|
70 Field(&StudyConfiguration::SweepModeMaxSize, SC.SweepModeMaxSize),
|
|
|
71 Field(&StudyConfiguration::SizeDistributionName, SC.SizeDistributionName),
|
|
|
72 Field(&StudyConfiguration::AccessAlignment, SC.AccessAlignment),
|
|
|
73 Field(&StudyConfiguration::MemcmpMismatchAt, SC.MemcmpMismatchAt));
|
|
|
74 }
|
|
|
75
|
|
|
76 auto equals(const BenchmarkOptions &BO) -> auto {
|
|
|
77 return AllOf(
|
|
|
78 Field(&BenchmarkOptions::MinDuration, BO.MinDuration),
|
|
|
79 Field(&BenchmarkOptions::MaxDuration, BO.MaxDuration),
|
|
|
80 Field(&BenchmarkOptions::InitialIterations, BO.InitialIterations),
|
|
|
81 Field(&BenchmarkOptions::MaxIterations, BO.MaxIterations),
|
|
|
82 Field(&BenchmarkOptions::MinSamples, BO.MinSamples),
|
|
|
83 Field(&BenchmarkOptions::MaxSamples, BO.MaxSamples),
|
|
|
84 Field(&BenchmarkOptions::Epsilon, BO.Epsilon),
|
|
|
85 Field(&BenchmarkOptions::ScalingFactor, BO.ScalingFactor),
|
|
|
86 Field(&BenchmarkOptions::Log, BO.Log));
|
|
|
87 }
|
|
|
88
|
|
|
89 auto equals(const Runtime &RI) -> auto {
|
|
|
90 return AllOf(Field(&Runtime::Host, equals(RI.Host)),
|
|
|
91 Field(&Runtime::BufferSize, RI.BufferSize),
|
|
|
92 Field(&Runtime::BatchParameterCount, RI.BatchParameterCount),
|
|
|
93 Field(&Runtime::BenchmarkOptions, equals(RI.BenchmarkOptions)));
|
|
|
94 }
|
|
|
95
|
|
|
96 auto equals(const Study &S) -> auto {
|
|
|
97 return AllOf(Field(&Study::StudyName, S.StudyName),
|
|
|
98 Field(&Study::Runtime, equals(S.Runtime)),
|
|
|
99 Field(&Study::Configuration, equals(S.Configuration)),
|
|
|
100 Field(&Study::Measurements, S.Measurements));
|
|
|
101 }
|
|
|
102
|
|
|
103 TEST(JsonTest, RoundTrip) {
|
|
|
104 const Study S = getStudy();
|
|
|
105 const auto Serialized = serializeToString(S);
|
|
|
106 auto StudyOrError = parseJsonStudy(Serialized);
|
|
|
107 if (auto Err = StudyOrError.takeError())
|
|
|
108 EXPECT_FALSE(Err) << "Unexpected error : " << Err << "\n" << Serialized;
|
|
|
109 const Study &Parsed = *StudyOrError;
|
|
|
110 EXPECT_THAT(Parsed, equals(S)) << Serialized << "\n"
|
|
|
111 << serializeToString(Parsed);
|
|
|
112 }
|
|
|
113
|
|
|
114 TEST(JsonTest, SupplementaryField) {
|
|
|
115 auto Failure = parseJsonStudy(R"({
|
|
|
116 "UnknownField": 10
|
|
|
117 }
|
|
|
118 )");
|
|
|
119 EXPECT_EQ(toString(Failure.takeError()), "Unknown field: UnknownField");
|
|
|
120 }
|
|
|
121
|
|
|
122 TEST(JsonTest, InvalidType) {
|
|
|
123 auto Failure = parseJsonStudy(R"({
|
|
|
124 "Runtime": 1
|
|
|
125 }
|
|
|
126 )");
|
|
|
127 EXPECT_EQ(toString(Failure.takeError()), "Expected JSON Object");
|
|
|
128 }
|
|
|
129
|
|
|
130 TEST(JsonTest, InvalidDuration) {
|
|
|
131 auto Failure = parseJsonStudy(R"({
|
|
|
132 "Runtime": {
|
|
|
133 "BenchmarkOptions": {
|
|
|
134 "MinDuration": "Duration should be a Number"
|
|
|
135 }
|
|
|
136 }
|
|
|
137 }
|
|
|
138 )");
|
|
|
139 EXPECT_EQ(toString(Failure.takeError()), "Can't parse Duration");
|
|
|
140 }
|
|
|
141
|
|
|
142 TEST(JsonTest, InvalidAlignType) {
|
|
|
143 auto Failure = parseJsonStudy(R"({
|
|
|
144 "Configuration": {
|
|
|
145 "AccessAlignment": "Align should be an Integer"
|
|
|
146 }
|
|
|
147 }
|
|
|
148 )");
|
|
|
149 EXPECT_EQ(toString(Failure.takeError()), "Can't parse Align, not an Integer");
|
|
|
150 }
|
|
|
151
|
|
|
152 TEST(JsonTest, InvalidAlign) {
|
|
|
153 auto Failure = parseJsonStudy(R"({
|
|
|
154 "Configuration": {
|
|
|
155 "AccessAlignment": 3
|
|
|
156 }
|
|
|
157 }
|
|
|
158 )");
|
|
|
159 EXPECT_EQ(toString(Failure.takeError()),
|
|
|
160 "Can't parse Align, not a power of two");
|
|
|
161 }
|
|
|
162
|
|
|
163 TEST(JsonTest, InvalidBenchmarkLogType) {
|
|
|
164 auto Failure = parseJsonStudy(R"({
|
|
|
165 "Runtime": {
|
|
|
166 "BenchmarkOptions":{
|
|
|
167 "Log": 3
|
|
|
168 }
|
|
|
169 }
|
|
|
170 }
|
|
|
171 )");
|
|
|
172 EXPECT_EQ(toString(Failure.takeError()),
|
|
|
173 "Can't parse BenchmarkLog, not a String");
|
|
|
174 }
|
|
|
175
|
|
|
176 TEST(JsonTest, InvalidBenchmarkLog) {
|
|
|
177 auto Failure = parseJsonStudy(R"({
|
|
|
178 "Runtime": {
|
|
|
179 "BenchmarkOptions":{
|
|
|
180 "Log": "Unknown"
|
|
|
181 }
|
|
|
182 }
|
|
|
183 }
|
|
|
184 )");
|
|
|
185 EXPECT_EQ(toString(Failure.takeError()),
|
|
|
186 "Can't parse BenchmarkLog, invalid value 'Unknown'");
|
|
|
187 }
|
|
|
188
|
|
|
189 } // namespace
|
|
|
190 } // namespace libc_benchmarks
|
|
|
191 } // namespace llvm
|
