Json test (#5324)
* mroe quotes * dssf * sqa * Json test p1 * qw * re * pr build * cast part 2 * ew * jj
This commit is contained in:
George Arama
GitHub
parent
ce4f25da23
commit
50cc742865
@ -10,6 +10,7 @@ set(CMAKE_CXX_STANDARD_REQUIRED True)
|
||||
set(
|
||||
AZURE_CORE_PERF_TEST_HEADER
|
||||
inc/azure/core/test/http_transport_test.hpp
|
||||
inc/azure/core/test/json_test.hpp
|
||||
inc/azure/core/test/nullable_test.hpp
|
||||
inc/azure/core/test/pipeline_test.hpp
|
||||
inc/azure/core/test/uuid_test.hpp
|
||||
|
||||
321
sdk/core/azure-core/test/perf/inc/azure/core/test/json_test.hpp
Normal file
321
sdk/core/azure-core/test/perf/inc/azure/core/test/json_test.hpp
Normal file
@ -0,0 +1,321 @@
|
||||
// Copyright (c) Microsoft Corporation.
|
||||
// Licensed under the MIT License.
|
||||
|
||||
/**
|
||||
* @file
|
||||
* @brief Test the JSON performance.
|
||||
*
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "../../../core/perf/inc/azure/perf.hpp"
|
||||
|
||||
#include <azure/core.hpp>
|
||||
#include <azure/core/internal/json/json.hpp>
|
||||
#include <azure/core/internal/json/json_optional.hpp>
|
||||
|
||||
#include <string>
|
||||
|
||||
using namespace Azure::Core::Json::_internal;
|
||||
|
||||
#include <memory>
|
||||
|
||||
namespace Azure { namespace Core { namespace Test {
|
||||
|
||||
struct JsonTestObject
|
||||
{
|
||||
// stack
|
||||
bool Boolean;
|
||||
int8_t Int8;
|
||||
int16_t Int16;
|
||||
int32_t Int32;
|
||||
int64_t Int64;
|
||||
uint8_t Uint8;
|
||||
uint16_t Uint16;
|
||||
uint32_t Uint32;
|
||||
uint64_t Uint64;
|
||||
float Float;
|
||||
double Double;
|
||||
std::string String;
|
||||
|
||||
// nullables
|
||||
Azure::Nullable<bool> NullableBoolean;
|
||||
Azure::Nullable<int8_t> NullableInt8;
|
||||
Azure::Nullable<int16_t> NullableInt16;
|
||||
Azure::Nullable<int32_t> NullableInt32;
|
||||
Azure::Nullable<int64_t> NullableInt64;
|
||||
Azure::Nullable<uint8_t> NullableUint8;
|
||||
Azure::Nullable<uint16_t> NullableUint16;
|
||||
Azure::Nullable<uint32_t> NullableUint32;
|
||||
Azure::Nullable<uint64_t> NullableUint64;
|
||||
Azure::Nullable<float> NullableFloat;
|
||||
Azure::Nullable<double> NullableDouble;
|
||||
Azure::Nullable<std::string> NullableString;
|
||||
|
||||
// vectors
|
||||
std::vector<bool> Booleans;
|
||||
std::vector<int8_t> Int8s;
|
||||
std::vector<int16_t> Int16s;
|
||||
std::vector<int32_t> Int32s;
|
||||
std::vector<int64_t> Int64s;
|
||||
std::vector<uint8_t> Uint8s;
|
||||
std::vector<uint16_t> Uint16s;
|
||||
std::vector<uint32_t> Uint32s;
|
||||
std::vector<uint64_t> Uint64s;
|
||||
std::vector<float> Floats;
|
||||
std::vector<double> Doubles;
|
||||
std::vector<std::string> Strings;
|
||||
|
||||
// Map
|
||||
std::map<std::string, std::string> Map;
|
||||
|
||||
bool operator==(const JsonTestObject& other) const
|
||||
{
|
||||
return Boolean == other.Boolean && Int8 == other.Int8 && Int16 == other.Int16
|
||||
&& Int32 == other.Int32 && Int64 == other.Int64 && Uint8 == other.Uint8
|
||||
&& Uint16 == other.Uint16 && Uint32 == other.Uint32 && Uint64 == other.Uint64
|
||||
&& Float == other.Float && Double == other.Double && String == other.String
|
||||
&& Booleans == other.Booleans && Int8s == other.Int8s && Int16s == other.Int16s
|
||||
&& Int32s == other.Int32s && Int64s == other.Int64s && Uint8s == other.Uint8s
|
||||
&& Uint16s == other.Uint16s && Uint32s == other.Uint32s && Uint64s == other.Uint64s
|
||||
&& Floats == other.Floats && Doubles == other.Doubles && Strings == other.Strings
|
||||
&& Map == other.Map;
|
||||
}
|
||||
|
||||
std::string Serialize() const
|
||||
{
|
||||
Azure::Core::Json::_internal::json j;
|
||||
|
||||
j["Boolean"] = Boolean;
|
||||
j["Int8"] = Int8;
|
||||
j["Int16"] = Int16;
|
||||
j["Int32"] = Int32;
|
||||
j["Int64"] = Int64;
|
||||
j["Uint8"] = Uint8;
|
||||
j["Uint16"] = Uint16;
|
||||
j["Uint32"] = Uint32;
|
||||
j["Uint64"] = Uint64;
|
||||
j["Float"] = Float;
|
||||
j["Double"] = Double;
|
||||
j["String"] = String;
|
||||
|
||||
JsonOptional::SetFromNullable<bool>(NullableBoolean, j, "NullableBoolean");
|
||||
JsonOptional::SetFromNullable<int8_t>(NullableInt8, j, "NullableInt8");
|
||||
JsonOptional::SetFromNullable<int16_t>(NullableInt16, j, "NullableInt16");
|
||||
JsonOptional::SetFromNullable<int32_t>(NullableInt32, j, "NullableInt32");
|
||||
JsonOptional::SetFromNullable<int64_t>(NullableInt64, j, "NullableInt64");
|
||||
JsonOptional::SetFromNullable<uint8_t>(NullableUint8, j, "NullableUint8");
|
||||
JsonOptional::SetFromNullable<uint16_t>(NullableUint16, j, "NullableUint16");
|
||||
JsonOptional::SetFromNullable<uint32_t>(NullableUint32, j, "NullableUint32");
|
||||
JsonOptional::SetFromNullable<uint64_t>(NullableUint64, j, "NullableUint64");
|
||||
JsonOptional::SetFromNullable<float>(NullableFloat, j, "NullableFloat");
|
||||
JsonOptional::SetFromNullable<double>(NullableDouble, j, "NullableDouble");
|
||||
JsonOptional::SetFromNullable<std::string>(NullableString, j, "NullableString");
|
||||
|
||||
j["Booleans"] = Booleans;
|
||||
j["Int8s"] = Int8s;
|
||||
j["Int16s"] = Int16s;
|
||||
j["Int32s"] = Int32s;
|
||||
j["Int64s"] = Int64s;
|
||||
j["Uint8s"] = Uint8s;
|
||||
j["Uint16s"] = Uint16s;
|
||||
j["Uint32s"] = Uint32s;
|
||||
j["Uint64s"] = Uint64s;
|
||||
j["Floats"] = Floats;
|
||||
j["Doubles"] = Doubles;
|
||||
j["Strings"] = Strings;
|
||||
|
||||
for (auto const& pair : Map)
|
||||
{
|
||||
j["Map"][pair.first] = pair.second;
|
||||
};
|
||||
|
||||
return j.dump();
|
||||
}
|
||||
|
||||
void Deserialize(std::string const& json)
|
||||
{
|
||||
Azure::Core::Json::_internal::json j = Azure::Core::Json::_internal::json::parse(json);
|
||||
|
||||
Boolean = j["Boolean"].get<bool>();
|
||||
Int8 = j["Int8"].get<int8_t>();
|
||||
Int16 = j["Int16"].get<int16_t>();
|
||||
Int32 = j["Int32"].get<int32_t>();
|
||||
Int64 = j["Int64"].get<int64_t>();
|
||||
Uint8 = j["Uint8"].get<uint8_t>();
|
||||
Uint16 = j["Uint16"].get<uint16_t>();
|
||||
Uint32 = j["Uint32"].get<uint32_t>();
|
||||
Uint64 = j["Uint64"].get<uint64_t>();
|
||||
Float = j["Float"].get<float>();
|
||||
Double = j["Double"].get<double>();
|
||||
String = j["String"].get<std::string>();
|
||||
|
||||
JsonOptional::SetIfExists<bool>(NullableBoolean, j, "NullableBoolean");
|
||||
JsonOptional::SetIfExists<int8_t>(NullableInt8, j, "NullableInt8");
|
||||
JsonOptional::SetIfExists<int16_t>(NullableInt16, j, "NullableInt16");
|
||||
JsonOptional::SetIfExists<int32_t>(NullableInt32, j, "NullableInt32");
|
||||
JsonOptional::SetIfExists<int64_t>(NullableInt64, j, "NullableInt64");
|
||||
JsonOptional::SetIfExists<uint8_t>(NullableUint8, j, "NullableUint8");
|
||||
JsonOptional::SetIfExists<uint16_t>(NullableUint16, j, "NullableUint16");
|
||||
JsonOptional::SetIfExists<uint32_t>(NullableUint32, j, "NullableUint32");
|
||||
JsonOptional::SetIfExists<uint64_t>(NullableUint64, j, "NullableUint64");
|
||||
JsonOptional::SetIfExists<float>(NullableFloat, j, "NullableFloat");
|
||||
JsonOptional::SetIfExists<double>(NullableDouble, j, "NullableDouble");
|
||||
JsonOptional::SetIfExists<std::string>(NullableString, j, "NullableString");
|
||||
|
||||
Booleans = j["Booleans"].get<std::vector<bool>>();
|
||||
Int8s = j["Int8s"].get<std::vector<int8_t>>();
|
||||
Int16s = j["Int16s"].get<std::vector<int16_t>>();
|
||||
Int32s = j["Int32s"].get<std::vector<int32_t>>();
|
||||
Int64s = j["Int64s"].get<std::vector<int64_t>>();
|
||||
Uint8s = j["Uint8s"].get<std::vector<uint8_t>>();
|
||||
Uint16s = j["Uint16s"].get<std::vector<uint16_t>>();
|
||||
Uint32s = j["Uint32s"].get<std::vector<uint32_t>>();
|
||||
Uint64s = j["Uint64s"].get<std::vector<uint64_t>>();
|
||||
Floats = j["Floats"].get<std::vector<float>>();
|
||||
Doubles = j["Doubles"].get<std::vector<double>>();
|
||||
Strings = j["Strings"].get<std::vector<std::string>>();
|
||||
|
||||
for (auto const& pair : j["Map"].items())
|
||||
{
|
||||
Map[pair.key()] = pair.value().get<std::string>();
|
||||
}
|
||||
}
|
||||
|
||||
JsonTestObject() = default;
|
||||
JsonTestObject(size_t const& vectorSize)
|
||||
{
|
||||
Boolean = true;
|
||||
Int8 = static_cast<int8_t>(1);
|
||||
Int16 = static_cast<int16_t>(2);
|
||||
Int32 = static_cast<int32_t>(3);
|
||||
Int64 = static_cast<int64_t>(4);
|
||||
Uint8 = static_cast<uint8_t>(5);
|
||||
Uint16 = static_cast<uint16_t>(6);
|
||||
Uint32 = static_cast<uint32_t>(7);
|
||||
Uint64 = static_cast<uint64_t>(8);
|
||||
Float = static_cast<float>(9.0);
|
||||
Double = static_cast<double>(10.0);
|
||||
String = "string";
|
||||
|
||||
NullableBoolean = true;
|
||||
NullableInt8 = static_cast<int8_t>(1);
|
||||
NullableInt16 = static_cast<int16_t>(2);
|
||||
NullableInt32 = static_cast<int32_t>(3);
|
||||
NullableInt64 = static_cast<int64_t>(4);
|
||||
NullableUint8 = static_cast<uint8_t>(5);
|
||||
NullableUint16 = static_cast<uint16_t>(6);
|
||||
NullableUint32 = static_cast<uint32_t>(7);
|
||||
NullableUint64 = static_cast<uint64_t>(8);
|
||||
NullableFloat = static_cast<float>(9.0);
|
||||
NullableDouble = static_cast<double>(10.0);
|
||||
NullableString = "string";
|
||||
|
||||
Booleans = std::vector<bool>(vectorSize, true);
|
||||
Int8s = std::vector<int8_t>(vectorSize, static_cast<int8_t>(1));
|
||||
Int16s = std::vector<int16_t>(vectorSize, static_cast<int16_t>(2));
|
||||
Int32s = std::vector<int32_t>(vectorSize, static_cast<int32_t>(3));
|
||||
Int64s = std::vector<int64_t>(vectorSize, static_cast<int64_t>(4));
|
||||
Uint8s = std::vector<uint8_t>(vectorSize, static_cast<uint8_t>(5));
|
||||
Uint16s = std::vector<uint16_t>(vectorSize, static_cast<uint16_t>(6));
|
||||
Uint32s = std::vector<uint32_t>(vectorSize, static_cast<uint32_t>(7));
|
||||
Uint64s = std::vector<uint64_t>(vectorSize, static_cast<uint64_t>(8));
|
||||
Floats = std::vector<float>(vectorSize, static_cast<float>(9.0));
|
||||
Doubles = std::vector<double>(vectorSize, static_cast<double>(10.0));
|
||||
Strings = std::vector<std::string>(vectorSize, "string");
|
||||
|
||||
Map = std::map<std::string, std::string>();
|
||||
for (size_t i = 0; i < vectorSize; i++)
|
||||
{
|
||||
Map["key" + std::to_string(i)] = "value" + std::to_string(i);
|
||||
};
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* @brief Measure the HTTP transport performance.
|
||||
*/
|
||||
class JsonTest : public Azure::Perf::PerfTest {
|
||||
enum class Action
|
||||
{
|
||||
Serialize,
|
||||
Deserialize
|
||||
};
|
||||
|
||||
Action m_action;
|
||||
size_t m_vectorSize;
|
||||
JsonTestObject m_testObject;
|
||||
std::string m_jsonBody;
|
||||
|
||||
public:
|
||||
/**
|
||||
* @brief Construct a new JsonTest test.
|
||||
*
|
||||
* @param options The test options.
|
||||
*/
|
||||
JsonTest(Azure::Perf::TestOptions options) : PerfTest(options) {}
|
||||
|
||||
void Setup() override
|
||||
{
|
||||
m_action = m_options.GetOptionOrDefault<std::string>("Action", "serialize") == "serialize"
|
||||
? Action::Serialize
|
||||
: Action::Deserialize;
|
||||
|
||||
m_vectorSize = m_options.GetOptionOrDefault<size_t>("Size", 1000);
|
||||
m_testObject = JsonTestObject(m_vectorSize);
|
||||
|
||||
if (m_action == Action::Deserialize)
|
||||
{
|
||||
m_jsonBody = m_testObject.Serialize();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Perform Json test.
|
||||
*
|
||||
*/
|
||||
void Run(Azure::Core::Context const&) override
|
||||
{
|
||||
switch (m_action)
|
||||
{
|
||||
case Action::Serialize: {
|
||||
m_testObject.Serialize();
|
||||
break;
|
||||
}
|
||||
case Action::Deserialize: {
|
||||
m_testObject.Deserialize(m_jsonBody);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Define the test options for the test.
|
||||
*
|
||||
* @return The list of test options.
|
||||
*/
|
||||
std::vector<Azure::Perf::TestOption> GetTestOptions() override
|
||||
{
|
||||
return {
|
||||
{"Action", {"--action"}, "Serialize/deserialize, default serialize", 1, false},
|
||||
{"Size", {"--size"}, "The vector size, default 1000", 1, false}};
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Get the static Test Metadata for the test.
|
||||
*
|
||||
* @return Azure::Perf::TestMetadata describing the test.
|
||||
*/
|
||||
static Azure::Perf::TestMetadata GetTestMetadata()
|
||||
{
|
||||
return {
|
||||
"JsonTest",
|
||||
"Measures Json serialize/deserialize performance",
|
||||
[](Azure::Perf::TestOptions options) {
|
||||
return std::make_unique<Azure::Core::Test::JsonTest>(options);
|
||||
}};
|
||||
}
|
||||
};
|
||||
|
||||
}}} // namespace Azure::Core::Test
|
||||
@ -2,6 +2,7 @@
|
||||
// Licensed under the MIT License.
|
||||
|
||||
#include "azure/core/test/http_transport_test.hpp"
|
||||
#include "azure/core/test/json_test.hpp"
|
||||
#include "azure/core/test/nullable_test.hpp"
|
||||
#include "azure/core/test/pipeline_test.hpp"
|
||||
#include "azure/core/test/uuid_test.hpp"
|
||||
@ -16,6 +17,7 @@ int main(int argc, char** argv)
|
||||
// Create the test list
|
||||
std::vector<Azure::Perf::TestMetadata> tests{
|
||||
Azure::Core::Test::HTTPTransportTest::GetTestMetadata(),
|
||||
Azure::Core::Test::JsonTest::GetTestMetadata(),
|
||||
Azure::Core::Test::NullableTest::GetTestMetadata(),
|
||||
Azure::Core::Test::PipelineTest::GetTestMetadata(),
|
||||
Azure::Core::Test::UuidTest::GetTestMetadata()};
|
||||
|
||||
Loading…
Reference in New Issue
Block a user