libc/benchmarks/JSONTest.cpp

   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