libc/benchmarks/JSONTest.cpp

//===-- JSON Tests --------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#include "JSON.h"
#include "LibcBenchmark.h"
#include "LibcMemoryBenchmark.h"
#include "llvm/Support/JSON.h"
#include "llvm/Support/raw_ostream.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"

using testing::AllOf;
using testing::ExplainMatchResult;
using testing::Field;
using testing::Pointwise;

namespace llvm {
namespace libc_benchmarks {
namespace {

Study getStudy() {
  return Study{
      "StudyName",
      Runtime{HostState{"CpuName",
                        123,
                        {CacheInfo{"A", 1, 2, 3}, CacheInfo{"B", 4, 5, 6}}},
              456, 789,
              BenchmarkOptions{std::chrono::seconds(1), std::chrono::seconds(2),
                               10, 100, 6, 100, 0.1, 2, BenchmarkLog::Full}},
      StudyConfiguration{std::string("Function"), 30U, false, 32U,
                         std::string("Distribution"), Align(16), 3U},
      {std::chrono::seconds(3), std::chrono::seconds(4)}};
}

static std::string serializeToString(const Study &S) {
  std::string Buffer;
  raw_string_ostream RSO(Buffer);
  json::OStream JOS(RSO);
  serializeToJson(S, JOS);
  return Buffer;
}

MATCHER(EqualsCacheInfo, "") {
  const CacheInfo &A = ::testing::get<0>(arg);
  const CacheInfo &B = ::testing::get<1>(arg);
  return ExplainMatchResult(AllOf(Field(&CacheInfo::Type, B.Type),
                                  Field(&CacheInfo::Level, B.Level),
                                  Field(&CacheInfo::Size, B.Size),
                                  Field(&CacheInfo::NumSharing, B.NumSharing)),
                            A, result_listener);
}

auto equals(const HostState &H) -> auto {
  return AllOf(
      Field(&HostState::CpuName, H.CpuName),
      Field(&HostState::CpuFrequency, H.CpuFrequency),
      Field(&HostState::Caches, Pointwise(EqualsCacheInfo(), H.Caches)));
}

auto equals(const StudyConfiguration &SC) -> auto {
  return AllOf(
      Field(&StudyConfiguration::Function, SC.Function),
      Field(&StudyConfiguration::NumTrials, SC.NumTrials),
      Field(&StudyConfiguration::IsSweepMode, SC.IsSweepMode),
      Field(&StudyConfiguration::SweepModeMaxSize, SC.SweepModeMaxSize),
      Field(&StudyConfiguration::SizeDistributionName, SC.SizeDistributionName),
      Field(&StudyConfiguration::AccessAlignment, SC.AccessAlignment),
      Field(&StudyConfiguration::MemcmpMismatchAt, SC.MemcmpMismatchAt));
}

auto equals(const BenchmarkOptions &BO) -> auto {
  return AllOf(
      Field(&BenchmarkOptions::MinDuration, BO.MinDuration),
      Field(&BenchmarkOptions::MaxDuration, BO.MaxDuration),
      Field(&BenchmarkOptions::InitialIterations, BO.InitialIterations),
      Field(&BenchmarkOptions::MaxIterations, BO.MaxIterations),
      Field(&BenchmarkOptions::MinSamples, BO.MinSamples),
      Field(&BenchmarkOptions::MaxSamples, BO.MaxSamples),
      Field(&BenchmarkOptions::Epsilon, BO.Epsilon),
      Field(&BenchmarkOptions::ScalingFactor, BO.ScalingFactor),
      Field(&BenchmarkOptions::Log, BO.Log));
}

auto equals(const Runtime &RI) -> auto {
  return AllOf(Field(&Runtime::Host, equals(RI.Host)),
               Field(&Runtime::BufferSize, RI.BufferSize),
               Field(&Runtime::BatchParameterCount, RI.BatchParameterCount),
               Field(&Runtime::BenchmarkOptions, equals(RI.BenchmarkOptions)));
}

auto equals(const Study &S) -> auto {
  return AllOf(Field(&Study::StudyName, S.StudyName),
               Field(&Study::Runtime, equals(S.Runtime)),
               Field(&Study::Configuration, equals(S.Configuration)),
               Field(&Study::Measurements, S.Measurements));
}

TEST(JsonTest, RoundTrip) {
  const Study S = getStudy();
  const auto Serialized = serializeToString(S);
  auto StudyOrError = parseJsonStudy(Serialized);
  if (auto Err = StudyOrError.takeError())
    EXPECT_FALSE(Err) << "Unexpected error : " << Err << "\n" << Serialized;
  const Study &Parsed = *StudyOrError;
  EXPECT_THAT(Parsed, equals(S)) << Serialized << "\n"
                                 << serializeToString(Parsed);
}

TEST(JsonTest, SupplementaryField) {
  auto Failure = parseJsonStudy(R"({
      "UnknownField": 10
    }
  )");
  EXPECT_EQ(toString(Failure.takeError()), "Unknown field: UnknownField");
}

TEST(JsonTest, InvalidType) {
  auto Failure = parseJsonStudy(R"({
      "Runtime": 1
    }
  )");
  EXPECT_EQ(toString(Failure.takeError()), "Expected JSON Object");
}

TEST(JsonTest, InvalidDuration) {
  auto Failure = parseJsonStudy(R"({
      "Runtime": {
        "BenchmarkOptions": {
          "MinDuration": "Duration should be a Number"
        }
      }
    }
  )");
  EXPECT_EQ(toString(Failure.takeError()), "Can't parse Duration");
}

TEST(JsonTest, InvalidAlignType) {
  auto Failure = parseJsonStudy(R"({
      "Configuration": {
        "AccessAlignment": "Align should be an Integer"
      }
    }
  )");
  EXPECT_EQ(toString(Failure.takeError()), "Can't parse Align, not an Integer");
}

TEST(JsonTest, InvalidAlign) {
  auto Failure = parseJsonStudy(R"({
      "Configuration": {
        "AccessAlignment": 3
      }
    }
  )");
  EXPECT_EQ(toString(Failure.takeError()),
            "Can't parse Align, not a power of two");
}

TEST(JsonTest, InvalidBenchmarkLogType) {
  auto Failure = parseJsonStudy(R"({
      "Runtime": {
        "BenchmarkOptions":{
          "Log": 3
        }
      }
    }
  )");
  EXPECT_EQ(toString(Failure.takeError()),
            "Can't parse BenchmarkLog, not a String");
}

TEST(JsonTest, InvalidBenchmarkLog) {
  auto Failure = parseJsonStudy(R"({
      "Runtime": {
        "BenchmarkOptions":{
          "Log": "Unknown"
        }
      }
    }
  )");
  EXPECT_EQ(toString(Failure.takeError()),
            "Can't parse BenchmarkLog, invalid value 'Unknown'");
}

} // namespace
} // namespace libc_benchmarks
} // namespace llvm