birkeh/o3de
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'development' into memory/overrideshim_removal

Browse Source 
Signed-off-by: Esteban Papp <81431996+amznestebanpapp@users.noreply.github.com>
This commit is contained in:
Esteban Papp
2022-01-20 13:43:12 -08:00
parent af6af93dff dd9c4e3f66
commit c978e12efc
1545 changed files with 24982 additions and 22444 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Code/Framework/AzCore/Tests/AZStd/String.cpp
+639 -327
View File
File diff suppressed because it is too large Load Diff
Code/Framework/AzCore/Tests/DOM/DomFixtures.cpp
+189
View File
@@ -0,0 +1,189 @@
/*
* Copyright (c) Contributors to the Open 3D Engine Project.
* For complete copyright and license terms please see the LICENSE at the root of this distribution.
*
* SPDX-License-Identifier: Apache-2.0 OR MIT
*
*/
#include <AzCore/DOM/DomValue.h>
#include <AzCore/Name/NameDictionary.h>
#include <AzCore/Serialization/Json/JsonUtils.h>
#include <Tests/DOM/DomFixtures.h>
namespace AZ::Dom::Tests
{
void DomTestHarness::SetUpHarness()
{
NameDictionary::Create();
AZ::AllocatorInstance<ValueAllocator>::Create();
}
void DomTestHarness::TearDownHarness()
{
AZ::AllocatorInstance<ValueAllocator>::Destroy();
NameDictionary::Destroy();
}
void DomBenchmarkFixture::SetUp(const ::benchmark::State& st)
{
UnitTest::AllocatorsBenchmarkFixture::SetUp(st);
SetUpHarness();
}
void DomBenchmarkFixture::SetUp(::benchmark::State& st)
{
UnitTest::AllocatorsBenchmarkFixture::SetUp(st);
SetUpHarness();
}
void DomBenchmarkFixture::TearDown(::benchmark::State& st)
{
TearDownHarness();
UnitTest::AllocatorsBenchmarkFixture::TearDown(st);
}
void DomBenchmarkFixture::TearDown(const ::benchmark::State& st)
{
TearDownHarness();
UnitTest::AllocatorsBenchmarkFixture::TearDown(st);
}
rapidjson::Document DomBenchmarkFixture::GenerateDomJsonBenchmarkDocument(int64_t entryCount, int64_t stringTemplateLength)
{
rapidjson::Document document;
document.SetObject();
AZStd::string entryTemplate;
while (entryTemplate.size() < aznumeric_cast<size_t>(stringTemplateLength))
{
entryTemplate += "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor ";
}
entryTemplate.resize(stringTemplateLength);
AZStd::string buffer;
auto createString = [&](int n) -> rapidjson::Value
{
buffer = AZStd::string::format("#%i %s", n, entryTemplate.c_str());
return rapidjson::Value(buffer.data(), aznumeric_cast<rapidjson::SizeType>(buffer.size()), document.GetAllocator());
};
auto createEntry = [&](int n) -> rapidjson::Value
{
rapidjson::Value entry(rapidjson::kObjectType);
entry.AddMember("string", createString(n), document.GetAllocator());
entry.AddMember("int", rapidjson::Value(n), document.GetAllocator());
entry.AddMember("double", rapidjson::Value(aznumeric_cast<double>(n) * 0.5), document.GetAllocator());
entry.AddMember("bool", rapidjson::Value(n % 2 == 0), document.GetAllocator());
entry.AddMember("null", rapidjson::Value(rapidjson::kNullType), document.GetAllocator());
return entry;
};
auto createArray = [&]() -> rapidjson::Value
{
rapidjson::Value array;
array.SetArray();
for (int i = 0; i < entryCount; ++i)
{
array.PushBack(createEntry(i), document.GetAllocator());
}
return array;
};
auto createObject = [&]() -> rapidjson::Value
{
rapidjson::Value object;
object.SetObject();
for (int i = 0; i < entryCount; ++i)
{
buffer = AZStd::string::format("Key%i", i);
rapidjson::Value key;
key.SetString(buffer.data(), aznumeric_cast<rapidjson::SizeType>(buffer.length()), document.GetAllocator());
object.AddMember(key.Move(), createArray(), document.GetAllocator());
}
return object;
};
document.SetObject();
document.AddMember("entries", createObject(), document.GetAllocator());
return document;
}
AZStd::string DomBenchmarkFixture::GenerateDomJsonBenchmarkPayload(int64_t entryCount, int64_t stringTemplateLength)
{
rapidjson::Document document = GenerateDomJsonBenchmarkDocument(entryCount, stringTemplateLength);
AZStd::string serializedJson;
auto result = AZ::JsonSerializationUtils::WriteJsonString(document, serializedJson);
AZ_Assert(result.IsSuccess(), "Failed to serialize generated JSON");
return serializedJson;
}
Value DomBenchmarkFixture::GenerateDomBenchmarkPayload(int64_t entryCount, int64_t stringTemplateLength)
{
Value root(Type::Object);
AZStd::string entryTemplate;
while (entryTemplate.size() < aznumeric_cast<size_t>(stringTemplateLength))
{
entryTemplate += "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor ";
}
entryTemplate.resize(stringTemplateLength);
AZStd::string buffer;
auto createString = [&](int n) -> Value
{
return Value(AZStd::string::format("#%i %s", n, entryTemplate.c_str()), true);
};
auto createEntry = [&](int n) -> Value
{
Value entry(Type::Object);
entry.AddMember("string", createString(n));
entry.AddMember("int", Value(n));
entry.AddMember("double", Value(aznumeric_cast<double>(n) * 0.5));
entry.AddMember("bool", Value(n % 2 == 0));
entry.AddMember("null", Value(Type::Null));
return entry;
};
auto createArray = [&]() -> Value
{
Value array(Type::Array);
for (int i = 0; i < entryCount; ++i)
{
array.ArrayPushBack(createEntry(i));
}
return array;
};
auto createObject = [&]() -> Value
{
Value object;
object.SetObject();
for (int i = 0; i < entryCount; ++i)
{
buffer = AZStd::string::format("Key%i", i);
object.AddMember(AZ::Name(buffer), createArray());
}
return object;
};
root["entries"] = createObject();
return root;
}
void DomTestFixture::SetUp()
{
UnitTest::AllocatorsFixture::SetUp();
SetUpHarness();
}
void DomTestFixture::TearDown()
{
TearDownHarness();
UnitTest::AllocatorsFixture::TearDown();
}
} // namespace AZ::Dom::Tests
Code/Framework/AzCore/Tests/DOM/DomFixtures.h
+66
View File
@@ -0,0 +1,66 @@
/*
* Copyright (c) Contributors to the Open 3D Engine Project.
* For complete copyright and license terms please see the LICENSE at the root of this distribution.
*
* SPDX-License-Identifier: Apache-2.0 OR MIT
*
*/
#pragma once
#include <AzCore/DOM/DomUtils.h>
#include <AzCore/JSON/document.h>
#include <AzCore/UnitTest/TestTypes.h>
#define DOM_REGISTER_SERIALIZATION_BENCHMARK(BaseClass, Method) \
BENCHMARK_REGISTER_F(BaseClass, Method)->Args({ 10, 5 })->Args({ 10, 500 })->Args({ 100, 5 })->Args({ 100, 500 })
#define DOM_REGISTER_SERIALIZATION_BENCHMARK_MS(BaseClass, Method) \
DOM_REGISTER_SERIALIZATION_BENCHMARK(BaseClass, Method)->Unit(benchmark::kMillisecond);
#define DOM_REGISTER_SERIALIZATION_BENCHMARK_NS(BaseClass, Method) \
DOM_REGISTER_SERIALIZATION_BENCHMARK(BaseClass, Method)->Unit(benchmark::kNanosecond);
namespace AZ::Dom::Tests
{
class DomTestHarness
{
public:
virtual ~DomTestHarness() = default;
virtual void SetUpHarness();
virtual void TearDownHarness();
};
class DomBenchmarkFixture
: public DomTestHarness
, public UnitTest::AllocatorsBenchmarkFixture
{
public:
void SetUp(const ::benchmark::State& st) override;
void SetUp(::benchmark::State& st) override;
void TearDown(::benchmark::State& st) override;
void TearDown(const ::benchmark::State& st) override;
rapidjson::Document GenerateDomJsonBenchmarkDocument(int64_t entryCount, int64_t stringTemplateLength);
AZStd::string GenerateDomJsonBenchmarkPayload(int64_t entryCount, int64_t stringTemplateLength);
Value GenerateDomBenchmarkPayload(int64_t entryCount, int64_t stringTemplateLength);
template<class T>
static void TakeAndDiscardWithoutTimingDtor(T&& value, benchmark::State& state)
{
{
T instance = AZStd::move(value);
state.PauseTiming();
}
state.ResumeTiming();
}
};
class DomTestFixture
: public DomTestHarness
, public UnitTest::AllocatorsFixture
{
public:
void SetUp() override;
void TearDown() override;
};
} // namespace AZ::Dom::Tests
Code/Framework/AzCore/Tests/DOM/DomJsonBenchmarks.cpp
+127 -111
View File
@@ -8,118 +8,23 @@
#if defined(HAVE_BENCHMARK)
#include <AzCore/DOM/DomUtils.h>
#include <AzCore/DOM/Backends/JSON/JsonBackend.h>
#include <AzCore/DOM/Backends/JSON/JsonSerializationUtils.h>
#include <AzCore/DOM/DomUtils.h>
#include <AzCore/DOM/DomValue.h>
#include <AzCore/JSON/document.h>
#include <AzCore/Name/NameDictionary.h>
#include <AzCore/Serialization/Json/JsonUtils.h>
#include <AzCore/UnitTest/TestTypes.h>
#include <Tests/DOM/DomFixtures.h>
namespace Benchmark
namespace AZ::Dom::Benchmark
{
class DomJsonBenchmark : public UnitTest::AllocatorsBenchmarkFixture
class DomJsonBenchmark : public Tests::DomBenchmarkFixture
{
public:
void SetUp(const ::benchmark::State& st) override
{
UnitTest::AllocatorsBenchmarkFixture::SetUp(st);
AZ::NameDictionary::Create();
}
void SetUp(::benchmark::State& st) override
{
UnitTest::AllocatorsBenchmarkFixture::SetUp(st);
AZ::NameDictionary::Create();
}
void TearDown(::benchmark::State& st) override
{
AZ::NameDictionary::Destroy();
UnitTest::AllocatorsBenchmarkFixture::TearDown(st);
}
void TearDown(const ::benchmark::State& st) override
{
AZ::NameDictionary::Destroy();
UnitTest::AllocatorsBenchmarkFixture::TearDown(st);
}
AZStd::string GenerateDomJsonBenchmarkPayload(int64_t entryCount, int64_t stringTemplateLength)
{
rapidjson::Document document;
document.SetObject();
AZStd::string entryTemplate;
while (entryTemplate.size() < static_cast<size_t>(stringTemplateLength))
{
entryTemplate += "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor ";
}
entryTemplate.resize(stringTemplateLength);
AZStd::string buffer;
auto createString = [&](int n) -> rapidjson::Value
{
buffer = AZStd::string::format("#%i %s", n, entryTemplate.c_str());
return rapidjson::Value(buffer.data(), static_cast<rapidjson::SizeType>(buffer.size()), document.GetAllocator());
};
auto createEntry = [&](int n) -> rapidjson::Value
{
rapidjson::Value entry(rapidjson::kObjectType);
entry.AddMember("string", createString(n), document.GetAllocator());
entry.AddMember("int", rapidjson::Value(n), document.GetAllocator());
entry.AddMember("double", rapidjson::Value(static_cast<double>(n) * 0.5), document.GetAllocator());
entry.AddMember("bool", rapidjson::Value(n % 2 == 0), document.GetAllocator());
entry.AddMember("null", rapidjson::Value(rapidjson::kNullType), document.GetAllocator());
return entry;
};
auto createArray = [&]() -> rapidjson::Value
{
rapidjson::Value array;
array.SetArray();
for (int i = 0; i < entryCount; ++i)
{
array.PushBack(createEntry(i), document.GetAllocator());
}
return array;
};
auto createObject = [&]() -> rapidjson::Value
{
rapidjson::Value object;
object.SetObject();
for (int i = 0; i < entryCount; ++i)
{
buffer = AZStd::string::format("Key%i", i);
rapidjson::Value key;
key.SetString(buffer.data(), static_cast<rapidjson::SizeType>(buffer.length()), document.GetAllocator());
object.AddMember(key.Move(), createArray(), document.GetAllocator());
}
return object;
};
document.SetObject();
document.AddMember("entries", createObject(), document.GetAllocator());
AZStd::string serializedJson;
auto result = AZ::JsonSerializationUtils::WriteJsonString(document, serializedJson);
AZ_Assert(result.IsSuccess(), "Failed to serialize generated JSON");
return serializedJson;
}
};
// Helper macro for registering JSON benchmarks
#define BENCHMARK_REGISTER_JSON(BaseClass, Method) \
BENCHMARK_REGISTER_F(BaseClass, Method) \
->Args({ 10, 5 }) \
->Args({ 10, 500 }) \
->Args({ 100, 5 }) \
->Args({ 100, 500 }) \
->Unit(benchmark::kMillisecond);
BENCHMARK_DEFINE_F(DomJsonBenchmark, DomDeserializeToDocumentInPlace)(benchmark::State& state)
BENCHMARK_DEFINE_F(DomJsonBenchmark, AzDomDeserializeToRapidjsonInPlace)(benchmark::State& state)
{
AZ::Dom::JsonBackend backend;
AZStd::string serializedPayload = GenerateDomJsonBenchmarkPayload(state.range(0), state.range(1));
@@ -136,14 +41,38 @@ namespace Benchmark
return AZ::Dom::Utils::ReadFromStringInPlace(backend, payloadCopy, visitor);
});
benchmark::DoNotOptimize(result.GetValue());
TakeAndDiscardWithoutTimingDtor(result.TakeValue(), state);
}
state.SetBytesProcessed(serializedPayload.size() * state.iterations());
}
BENCHMARK_REGISTER_JSON(DomJsonBenchmark, DomDeserializeToDocumentInPlace)
DOM_REGISTER_SERIALIZATION_BENCHMARK_MS(DomJsonBenchmark, AzDomDeserializeToRapidjsonInPlace)
BENCHMARK_DEFINE_F(DomJsonBenchmark, DomDeserializeToDocument)(benchmark::State& state)
BENCHMARK_DEFINE_F(DomJsonBenchmark, AzDomDeserializeToAzDomValueInPlace)(benchmark::State& state)
{
AZ::Dom::JsonBackend backend;
AZStd::string serializedPayload = GenerateDomJsonBenchmarkPayload(state.range(0), state.range(1));
for (auto _ : state)
{
state.PauseTiming();
AZStd::string payloadCopy = serializedPayload;
state.ResumeTiming();
auto result = AZ::Dom::Utils::WriteToValue(
[&](AZ::Dom::Visitor& visitor)
{
return AZ::Dom::Utils::ReadFromStringInPlace(backend, payloadCopy, visitor);
});
TakeAndDiscardWithoutTimingDtor(result.TakeValue(), state);
}
state.SetBytesProcessed(serializedPayload.size() * state.iterations());
}
DOM_REGISTER_SERIALIZATION_BENCHMARK_MS(DomJsonBenchmark, AzDomDeserializeToAzDomValueInPlace)
BENCHMARK_DEFINE_F(DomJsonBenchmark, AzDomDeserializeToRapidjson)(benchmark::State& state)
{
AZ::Dom::JsonBackend backend;
AZStd::string serializedPayload = GenerateDomJsonBenchmarkPayload(state.range(0), state.range(1));
@@ -156,14 +85,34 @@ namespace Benchmark
return AZ::Dom::Utils::ReadFromString(backend, serializedPayload, AZ::Dom::Lifetime::Temporary, visitor);
});
benchmark::DoNotOptimize(result.GetValue());
TakeAndDiscardWithoutTimingDtor(result.TakeValue(), state);
}
state.SetBytesProcessed(serializedPayload.size() * state.iterations());
}
BENCHMARK_REGISTER_JSON(DomJsonBenchmark, DomDeserializeToDocument)
DOM_REGISTER_SERIALIZATION_BENCHMARK_MS(DomJsonBenchmark, AzDomDeserializeToRapidjson)
BENCHMARK_DEFINE_F(DomJsonBenchmark, JsonUtilsDeserializeToDocument)(benchmark::State& state)
BENCHMARK_DEFINE_F(DomJsonBenchmark, AzDomDeserializeToAzDomValue)(benchmark::State& state)
{
AZ::Dom::JsonBackend backend;
AZStd::string serializedPayload = GenerateDomJsonBenchmarkPayload(state.range(0), state.range(1));
for (auto _ : state)
{
auto result = AZ::Dom::Utils::WriteToValue(
[&](AZ::Dom::Visitor& visitor)
{
return AZ::Dom::Utils::ReadFromString(backend, serializedPayload, AZ::Dom::Lifetime::Temporary, visitor);
});
TakeAndDiscardWithoutTimingDtor(result.TakeValue(), state);
}
state.SetBytesProcessed(serializedPayload.size() * state.iterations());
}
DOM_REGISTER_SERIALIZATION_BENCHMARK_MS(DomJsonBenchmark, AzDomDeserializeToAzDomValue)
BENCHMARK_DEFINE_F(DomJsonBenchmark, RapidjsonDeserializeToRapidjson)(benchmark::State& state)
{
AZ::Dom::JsonBackend backend;
AZStd::string serializedPayload = GenerateDomJsonBenchmarkPayload(state.range(0), state.range(1));
@@ -172,14 +121,81 @@ namespace Benchmark
{
auto result = AZ::JsonSerializationUtils::ReadJsonString(serializedPayload);
benchmark::DoNotOptimize(result.GetValue());
TakeAndDiscardWithoutTimingDtor(result.TakeValue(), state);
}
state.SetBytesProcessed(serializedPayload.size() * state.iterations());
}
BENCHMARK_REGISTER_JSON(DomJsonBenchmark, JsonUtilsDeserializeToDocument)
DOM_REGISTER_SERIALIZATION_BENCHMARK_MS(DomJsonBenchmark, RapidjsonDeserializeToRapidjson)
#undef BENCHMARK_REGISTER_JSON
} // namespace Benchmark
BENCHMARK_DEFINE_F(DomJsonBenchmark, RapidjsonMakeComplexObject)(benchmark::State& state)
{
for (auto _ : state)
{
TakeAndDiscardWithoutTimingDtor(GenerateDomJsonBenchmarkPayload(state.range(0), state.range(1)), state);
}
state.SetItemsProcessed(state.range(0) * state.range(0) * state.iterations());
}
DOM_REGISTER_SERIALIZATION_BENCHMARK_MS(DomJsonBenchmark, RapidjsonMakeComplexObject)
BENCHMARK_DEFINE_F(DomJsonBenchmark, RapidjsonLookupMemberByString)(benchmark::State& state)
{
rapidjson::Document document(rapidjson::kObjectType);
AZStd::vector<AZStd::string> keys;
for (int64_t i = 0; i < state.range(0); ++i)
{
AZStd::string key(AZStd::string::format("key%" PRId64, i));
keys.push_back(key);
document.AddMember(
rapidjson::Value(key.data(), static_cast<rapidjson::SizeType>(key.size()), document.GetAllocator()), rapidjson::Value(i),
document.GetAllocator());
}
for (auto _ : state)
{
for (const AZStd::string& key : keys)
{
benchmark::DoNotOptimize(document.FindMember(key.data()));
}
}
state.SetItemsProcessed(state.iterations() * state.range(0));
}
BENCHMARK_REGISTER_F(DomJsonBenchmark, RapidjsonLookupMemberByString)->Arg(100)->Arg(1000)->Arg(10000)->Unit(benchmark::kMillisecond);
BENCHMARK_DEFINE_F(DomJsonBenchmark, RapidjsonDeepCopy)(benchmark::State& state)
{
rapidjson::Document original = GenerateDomJsonBenchmarkDocument(state.range(0), state.range(1));
for (auto _ : state)
{
rapidjson::Document copy;
copy.CopyFrom(original, copy.GetAllocator(), true);
TakeAndDiscardWithoutTimingDtor(AZStd::move(copy), state);
}
state.SetItemsProcessed(state.iterations());
}
DOM_REGISTER_SERIALIZATION_BENCHMARK_MS(DomJsonBenchmark, RapidjsonDeepCopy)
BENCHMARK_DEFINE_F(DomJsonBenchmark, RapidjsonCopyAndMutate)(benchmark::State& state)
{
rapidjson::Document original = GenerateDomJsonBenchmarkDocument(state.range(0), state.range(1));
for (auto _ : state)
{
rapidjson::Document copy;
copy.CopyFrom(original, copy.GetAllocator(), true);
copy["entries"]["Key0"].PushBack(42, copy.GetAllocator());
TakeAndDiscardWithoutTimingDtor(AZStd::move(copy), state);
}
state.SetItemsProcessed(state.iterations());
}
DOM_REGISTER_SERIALIZATION_BENCHMARK_MS(DomJsonBenchmark, RapidjsonCopyAndMutate)
} // namespace AZ::Dom::Benchmark
#endif // defined(HAVE_BENCHMARK)
Code/Framework/AzCore/Tests/DOM/DomJsonTests.cpp
+4 -5
View File
@@ -13,24 +13,23 @@
#include <AzCore/Serialization/Json/JsonSerialization.h>
#include <AzCore/Serialization/Json/JsonUtils.h>
#include <AzCore/UnitTest/TestTypes.h>
#include <Tests/DOM/DomFixtures.h>
namespace AZ::Dom::Tests
{
class DomJsonTests : public UnitTest::AllocatorsFixture
class DomJsonTests : public DomTestFixture
{
public:
void SetUp() override
{
UnitTest::AllocatorsFixture::SetUp();
NameDictionary::Create();
DomTestFixture::SetUp();
m_document = AZStd::make_unique<rapidjson::Document>();
}
void TearDown() override
{
m_document.reset();
NameDictionary::Destroy();
UnitTest::AllocatorsFixture::TearDown();
DomTestFixture::TearDown();
}
rapidjson::Value CreateString(const AZStd::string& text)
Code/Framework/AzCore/Tests/DOM/DomValueBenchmarks.cpp
+266
View File
@@ -0,0 +1,266 @@
/*
* Copyright (c) Contributors to the Open 3D Engine Project.
* For complete copyright and license terms please see the LICENSE at the root of this distribution.
*
* SPDX-License-Identifier: Apache-2.0 OR MIT
*
*/
#include <AzCore/DOM/DomUtils.h>
#include <AzCore/DOM/DomValue.h>
#include <AzCore/Name/NameDictionary.h>
#include <AzCore/UnitTest/TestTypes.h>
#include <Tests/DOM/DomFixtures.h>
namespace AZ::Dom::Benchmark
{
class DomValueBenchmark : public Tests::DomBenchmarkFixture
{
};
BENCHMARK_DEFINE_F(DomValueBenchmark, AzDomValueGetType_UsingVariantIndex)(benchmark::State& state)
{
Value intValue(5);
Value boolValue(true);
Value objValue(Type::Object);
Value nodeValue(Type::Node);
Value arrValue(Type::Array);
Value uintValue(5u);
Value doubleValue(4.0);
Value stringValue("foo", true);
for (auto _ : state)
{
(intValue.GetType());
(boolValue.GetType());
(objValue.GetType());
(nodeValue.GetType());
(arrValue.GetType());
(uintValue.GetType());
(doubleValue.GetType());
(stringValue.GetType());
}
state.SetItemsProcessed(8 * state.iterations());
}
BENCHMARK_REGISTER_F(DomValueBenchmark, AzDomValueGetType_UsingVariantIndex);
BENCHMARK_DEFINE_F(DomValueBenchmark, AzDomValueGetType_UsingVariantVisit)(benchmark::State& state)
{
Value intValue(5);
Value boolValue(true);
Value objValue(Type::Object);
Value nodeValue(Type::Node);
Value arrValue(Type::Array);
Value uintValue(5u);
Value doubleValue(4.0);
Value stringValue("foo", true);
auto getTypeViaVisit = [](const Value& value)
{
return AZStd::visit(
[](auto&& value) constexpr -> Type
{
using CurrentType = AZStd::decay_t<decltype(value)>;
if constexpr (AZStd::is_same_v<CurrentType, AZStd::monostate>)
{
return Type::Null;
}
else if constexpr (AZStd::is_same_v<CurrentType, int64_t>)
{
return Type::Int64;
}
else if constexpr (AZStd::is_same_v<CurrentType, uint64_t>)
{
return Type::Uint64;
}
else if constexpr (AZStd::is_same_v<CurrentType, double>)
{
return Type::Double;
}
else if constexpr (AZStd::is_same_v<CurrentType, bool>)
{
return Type::Bool;
}
else if constexpr (AZStd::is_same_v<CurrentType, AZStd::string_view>)
{
return Type::String;
}
else if constexpr (AZStd::is_same_v<CurrentType, Value::SharedStringType>)
{
return Type::String;
}
else if constexpr (AZStd::is_same_v<CurrentType, Value::ShortStringType>)
{
return Type::String;
}
else if constexpr (AZStd::is_same_v<CurrentType, ObjectPtr>)
{
return Type::Object;
}
else if constexpr (AZStd::is_same_v<CurrentType, ArrayPtr>)
{
return Type::Array;
}
else if constexpr (AZStd::is_same_v<CurrentType, NodePtr>)
{
return Type::Node;
}
else if constexpr (AZStd::is_same_v<CurrentType, Value::OpaqueStorageType>)
{
return Type::Opaque;
}
else
{
AZ_Assert(false, "AZ::Dom::Value::GetType: m_value has an unexpected type");
}
},
value.GetInternalValue());
};
for (auto _ : state)
{
(getTypeViaVisit(intValue));
(getTypeViaVisit(boolValue));
(getTypeViaVisit(objValue));
(getTypeViaVisit(nodeValue));
(getTypeViaVisit(arrValue));
(getTypeViaVisit(uintValue));
(getTypeViaVisit(doubleValue));
(getTypeViaVisit(stringValue));
}
state.SetItemsProcessed(8 * state.iterations());
}
BENCHMARK_REGISTER_F(DomValueBenchmark, AzDomValueGetType_UsingVariantVisit);
BENCHMARK_DEFINE_F(DomValueBenchmark, AzDomValueMakeComplexObject)(benchmark::State& state)
{
for (auto _ : state)
{
TakeAndDiscardWithoutTimingDtor(GenerateDomBenchmarkPayload(state.range(0), state.range(1)), state);
}
state.SetItemsProcessed(state.range(0) * state.range(0) * state.iterations());
}
DOM_REGISTER_SERIALIZATION_BENCHMARK_MS(DomValueBenchmark, AzDomValueMakeComplexObject)
BENCHMARK_DEFINE_F(DomValueBenchmark, AzDomValueShallowCopy)(benchmark::State& state)
{
Value original = GenerateDomBenchmarkPayload(state.range(0), state.range(1));
for (auto _ : state)
{
Value copy = original;
benchmark::DoNotOptimize(copy);
}
state.SetItemsProcessed(state.iterations());
}
DOM_REGISTER_SERIALIZATION_BENCHMARK_NS(DomValueBenchmark, AzDomValueShallowCopy)
BENCHMARK_DEFINE_F(DomValueBenchmark, AzDomValueCopyAndMutate)(benchmark::State& state)
{
Value original = GenerateDomBenchmarkPayload(state.range(0), state.range(1));
for (auto _ : state)
{
Value copy = original;
copy["entries"]["Key0"].ArrayPushBack(Value(42));
TakeAndDiscardWithoutTimingDtor(AZStd::move(copy), state);
}
state.SetItemsProcessed(state.iterations());
}
DOM_REGISTER_SERIALIZATION_BENCHMARK_MS(DomValueBenchmark, AzDomValueCopyAndMutate)
BENCHMARK_DEFINE_F(DomValueBenchmark, AzDomValueDeepCopy)(benchmark::State& state)
{
Value original = GenerateDomBenchmarkPayload(state.range(0), state.range(1));
for (auto _ : state)
{
Value copy = Utils::DeepCopy(original);
TakeAndDiscardWithoutTimingDtor(AZStd::move(copy), state);
}
state.SetItemsProcessed(state.iterations());
}
DOM_REGISTER_SERIALIZATION_BENCHMARK_MS(DomValueBenchmark, AzDomValueDeepCopy)
BENCHMARK_DEFINE_F(DomValueBenchmark, LookupMemberByName)(benchmark::State& state)
{
Value value(Type::Object);
AZStd::vector<AZ::Name> keys;
for (int64_t i = 0; i < state.range(0); ++i)
{
AZ::Name key(AZStd::string::format("key%" PRId64, i));
keys.push_back(key);
value[key] = i;
}
for (auto _ : state)
{
for (const AZ::Name& key : keys)
{
benchmark::DoNotOptimize(value[key]);
}
}
state.SetItemsProcessed(state.iterations() * state.range(0));
}
BENCHMARK_REGISTER_F(DomValueBenchmark, LookupMemberByName)->Arg(100)->Arg(1000)->Arg(10000)->Unit(benchmark::kMillisecond);
BENCHMARK_DEFINE_F(DomValueBenchmark, LookupMemberByString)(benchmark::State& state)
{
Value value(Type::Object);
AZStd::vector<AZStd::string> keys;
for (int64_t i = 0; i < state.range(0); ++i)
{
AZStd::string key(AZStd::string::format("key%" PRId64, i));
keys.push_back(key);
value[key] = i;
}
for (auto _ : state)
{
for (const AZStd::string& key : keys)
{
benchmark::DoNotOptimize(value[key]);
}
}
state.SetItemsProcessed(state.iterations() * state.range(0));
}
BENCHMARK_REGISTER_F(DomValueBenchmark, LookupMemberByString)->Arg(100)->Arg(1000)->Arg(10000)->Unit(benchmark::kMillisecond);
BENCHMARK_DEFINE_F(DomValueBenchmark, LookupMemberByStringComparison)(benchmark::State& state)
{
Value value(Type::Object);
AZStd::vector<AZStd::string> keys;
for (int64_t i = 0; i < state.range(0); ++i)
{
AZStd::string key(AZStd::string::format("key%" PRId64, i));
keys.push_back(key);
value[key] = i;
}
for (auto _ : state)
{
for (const AZStd::string& key : keys)
{
const Object::ContainerType& object = value.GetObject();
benchmark::DoNotOptimize(AZStd::find_if(
object.cbegin(), object.cend(),
[&key](const Object::EntryType& entry)
{
return key == entry.first.GetStringView();
}));
}
}
state.SetItemsProcessed(state.iterations() * state.range(0));
}
BENCHMARK_REGISTER_F(DomValueBenchmark, LookupMemberByStringComparison)->Arg(100)->Arg(1000)->Arg(10000)->Unit(benchmark::kMillisecond);
} // namespace AZ::Dom::Benchmark
Code/Framework/AzCore/Tests/DOM/DomValueTests.cpp
+384
View File
@@ -0,0 +1,384 @@
/*
* Copyright (c) Contributors to the Open 3D Engine Project.
* For complete copyright and license terms please see the LICENSE at the root of this distribution.
*
* SPDX-License-Identifier: Apache-2.0 OR MIT
*
*/
#include <AzCore/DOM/Backends/JSON/JsonBackend.h>
#include <AzCore/DOM/Backends/JSON/JsonSerializationUtils.h>
#include <AzCore/DOM/DomUtils.h>
#include <AzCore/DOM/DomValue.h>
#include <AzCore/Name/NameDictionary.h>
#include <AzCore/Serialization/Json/JsonSerialization.h>
#include <AzCore/Serialization/Json/JsonUtils.h>
#include <AzCore/UnitTest/TestTypes.h>
#include <AzCore/std/numeric.h>
#include <Tests/DOM/DomFixtures.h>
namespace AZ::Dom::Tests
{
class DomValueTests : public DomTestFixture
{
public:
void TearDown() override
{
m_value = Value();
DomTestFixture::TearDown();
}
void PerformValueChecks()
{
Value shallowCopy = m_value;
EXPECT_EQ(m_value, shallowCopy);
EXPECT_TRUE(Utils::DeepCompareIsEqual(m_value, shallowCopy));
Value deepCopy = Utils::DeepCopy(m_value);
EXPECT_TRUE(Utils::DeepCompareIsEqual(m_value, deepCopy));
}
Value m_value;
};
TEST_F(DomValueTests, EmptyArray)
{
m_value.SetArray();
EXPECT_TRUE(m_value.IsArray());
EXPECT_EQ(m_value.ArraySize(), 0);
PerformValueChecks();
}
TEST_F(DomValueTests, SimpleArray)
{
m_value.SetArray();
for (int i = 0; i < 5; ++i)
{
m_value.ArrayPushBack(Value(i));
EXPECT_EQ(m_value.ArraySize(), i + 1);
EXPECT_EQ(m_value[i].GetInt64(), i);
}
PerformValueChecks();
}
TEST_F(DomValueTests, NestedArrays)
{
Value x(5);
m_value.SetArray();
for (int j = 0; j < 5; ++j)
{
Value nestedArray(Type::Array);
for (int i = 0; i < 5; ++i)
{
nestedArray.ArrayPushBack(Value(i));
}
m_value.ArrayPushBack(AZStd::move(nestedArray));
}
EXPECT_EQ(m_value.ArraySize(), 5);
for (int i = 0; i < 3; ++i)
{
EXPECT_EQ(m_value[i].ArraySize(), 5);
for (int j = 0; j < 5; ++j)
{
EXPECT_EQ(m_value[i][j].GetInt64(), j);
}
}
PerformValueChecks();
}
TEST_F(DomValueTests, EmptyObject)
{
m_value.SetObject();
EXPECT_EQ(m_value.MemberCount(), 0);
PerformValueChecks();
}
TEST_F(DomValueTests, SimpleObject)
{
m_value.SetObject();
for (int i = 0; i < 5; ++i)
{
AZStd::string key = AZStd::string::format("Key%i", i);
m_value.AddMember(key, Value(i));
EXPECT_EQ(m_value.MemberCount(), i + 1);
EXPECT_EQ(m_value[key].GetInt64(), i);
}
PerformValueChecks();
}
TEST_F(DomValueTests, NestedObjects)
{
m_value.SetObject();
for (int j = 0; j < 3; ++j)
{
Value nestedObject(Type::Object);
for (int i = 0; i < 5; ++i)
{
nestedObject.AddMember(AZStd::string::format("Key%i", i), Value(i));
}
m_value.AddMember(AZStd::string::format("Obj%i", j), AZStd::move(nestedObject));
}
EXPECT_EQ(m_value.MemberCount(), 3);
for (int j = 0; j < 3; ++j)
{
const Value& nestedObject = m_value[AZStd::string::format("Obj%i", j)];
EXPECT_EQ(nestedObject.MemberCount(), 5);
for (int i = 0; i < 5; ++i)
{
EXPECT_EQ(nestedObject[AZStd::string::format("Key%i", i)].GetInt64(), i);
}
}
PerformValueChecks();
}
TEST_F(DomValueTests, EmptyNode)
{
m_value.SetNode("Test");
EXPECT_EQ(m_value.GetNodeName(), AZ::Name("Test"));
EXPECT_EQ(m_value.MemberCount(), 0);
EXPECT_EQ(m_value.ArraySize(), 0);
PerformValueChecks();
}
TEST_F(DomValueTests, SimpleNode)
{
m_value.SetNode("Test");
for (int i = 0; i < 10; ++i)
{
m_value.ArrayPushBack(Value(i));
EXPECT_EQ(m_value.ArraySize(), i + 1);
EXPECT_EQ(m_value[i].GetInt64(), i);
if (i < 5)
{
AZ::Name key = AZ::Name(AZStd::string::format("TwoTimes%i", i));
m_value.AddMember(key, Value(i * 2));
EXPECT_EQ(m_value.MemberCount(), i + 1);
EXPECT_EQ(m_value[key].GetInt64(), i * 2);
}
}
PerformValueChecks();
}
TEST_F(DomValueTests, NestedNodes)
{
m_value.SetNode("TopLevel");
const AZ::Name childNodeName("ChildNode");
for (int i = 0; i < 5; ++i)
{
Value childNode(Type::Node);
childNode.SetNodeName(childNodeName);
childNode.SetNodeValue(Value(i));
childNode.AddMember("foo", Value(i));
childNode.AddMember("bar", Value("test", false));
m_value.ArrayPushBack(childNode);
}
EXPECT_EQ(m_value.ArraySize(), 5);
for (int i = 0; i < 5; ++i)
{
const Value& childNode = m_value[i];
EXPECT_EQ(childNode.GetNodeName(), childNodeName);
EXPECT_EQ(childNode.GetNodeValue().GetInt64(), i);
EXPECT_EQ(childNode["foo"].GetInt64(), i);
EXPECT_EQ(childNode["bar"].GetString(), "test");
}
PerformValueChecks();
}
TEST_F(DomValueTests, Int64)
{
m_value.SetObject();
m_value["int64_min"] = AZStd::numeric_limits<int64_t>::min();
m_value["int64_max"] = AZStd::numeric_limits<int64_t>::max();
EXPECT_EQ(m_value["int64_min"].GetType(), Type::Int64);
EXPECT_EQ(m_value["int64_min"].GetInt64(), AZStd::numeric_limits<int64_t>::min());
EXPECT_EQ(m_value["int64_max"].GetType(), Type::Int64);
EXPECT_EQ(m_value["int64_max"].GetInt64(), AZStd::numeric_limits<int64_t>::max());
PerformValueChecks();
}
TEST_F(DomValueTests, Uint64)
{
m_value.SetObject();
m_value["uint64_min"] = AZStd::numeric_limits<uint64_t>::min();
m_value["uint64_max"] = AZStd::numeric_limits<uint64_t>::max();
EXPECT_EQ(m_value["uint64_min"].GetType(), Type::Uint64);
EXPECT_EQ(m_value["uint64_min"].GetInt64(), AZStd::numeric_limits<uint64_t>::min());
EXPECT_EQ(m_value["uint64_max"].GetType(), Type::Uint64);
EXPECT_EQ(m_value["uint64_max"].GetInt64(), AZStd::numeric_limits<uint64_t>::max());
PerformValueChecks();
}
TEST_F(DomValueTests, Double)
{
m_value.SetObject();
m_value["double_min"] = AZStd::numeric_limits<double>::min();
m_value["double_max"] = AZStd::numeric_limits<double>::max();
EXPECT_EQ(m_value["double_min"].GetType(), Type::Double);
EXPECT_EQ(m_value["double_min"].GetDouble(), AZStd::numeric_limits<double>::min());
EXPECT_EQ(m_value["double_max"].GetType(), Type::Double);
EXPECT_EQ(m_value["double_max"].GetDouble(), AZStd::numeric_limits<double>::max());
PerformValueChecks();
}
TEST_F(DomValueTests, Null)
{
m_value.SetObject();
m_value["null_value"] = Value(Type::Null);
EXPECT_EQ(m_value["null_value"].GetType(), Type::Null);
EXPECT_EQ(m_value["null_type"], Value());
PerformValueChecks();
}
TEST_F(DomValueTests, Bool)
{
m_value.SetObject();
m_value["true_value"] = true;
m_value["false_value"] = false;
EXPECT_EQ(m_value["true_value"].GetType(), Type::Bool);
EXPECT_EQ(m_value["true_value"].GetBool(), true);
EXPECT_EQ(m_value["false_value"].GetType(), Type::Bool);
EXPECT_EQ(m_value["false_value"].GetBool(), false);
PerformValueChecks();
}
TEST_F(DomValueTests, String)
{
const char* s1 = "reference string long enough to avoid SSO";
const char* s2 = "copy string long enough to avoid SSO";
m_value.SetObject();
AZStd::string stringToReference = s1;
m_value["no_copy"] = Value(stringToReference, false);
AZStd::string stringToCopy = s2;
m_value["copy"] = Value(stringToCopy, true);
EXPECT_EQ(m_value["no_copy"].GetType(), Type::String);
EXPECT_EQ(m_value["no_copy"].GetString(), s1);
stringToReference.at(0) = 'F';
EXPECT_NE(m_value["no_copy"].GetString(), s1);
EXPECT_EQ(m_value["copy"].GetType(), Type::String);
EXPECT_EQ(m_value["copy"].GetString(), s2);
stringToCopy.at(0) = 'F';
EXPECT_EQ(m_value["copy"].GetString(), s2);
PerformValueChecks();
}
TEST_F(DomValueTests, CopyOnWrite_Object)
{
Value v1(Type::Object);
v1["foo"] = 5;
Value nestedObject(Type::Object);
v1["obj"] = nestedObject;
Value v2 = v1;
EXPECT_EQ(&v1.GetObject(), &v2.GetObject());
EXPECT_EQ(&v1.FindMember("obj")->second.GetObject(), &v2.FindMember("obj")->second.GetObject());
v2["foo"] = 0;
EXPECT_NE(&v1.GetObject(), &v2.GetObject());
EXPECT_EQ(&v1.FindMember("obj")->second.GetObject(), &v2.FindMember("obj")->second.GetObject());
v2["obj"]["key"] = true;
EXPECT_NE(&v1.GetObject(), &v2.GetObject());
EXPECT_NE(&v1.FindMember("obj")->second.GetObject(), &v2.FindMember("obj")->second.GetObject());
v2 = v1;
EXPECT_EQ(&v1.GetObject(), &v2.GetObject());
EXPECT_EQ(&v1.FindMember("obj")->second.GetObject(), &v2.FindMember("obj")->second.GetObject());
}
TEST_F(DomValueTests, CopyOnWrite_Array)
{
Value v1(Type::Array);
v1.ArrayPushBack(Value(1));
v1.ArrayPushBack(Value(2));
Value nestedArray(Type::Array);
v1.ArrayPushBack(nestedArray);
Value v2 = v1;
EXPECT_EQ(&v1.GetArray(), &v2.GetArray());
EXPECT_EQ(&v1.ArrayAt(2).GetArray(), &v2.ArrayAt(2).GetArray());
v2[0] = 0;
EXPECT_NE(&v1.GetArray(), &v2.GetArray());
EXPECT_EQ(&v1.ArrayAt(2).GetArray(), &v2.ArrayAt(2).GetArray());
v2[2].ArrayPushBack(Value(42));
EXPECT_NE(&v1.GetArray(), &v2.GetArray());
EXPECT_NE(&v1.ArrayAt(2).GetArray(), &v2.ArrayAt(2).GetArray());
v2 = v1;
EXPECT_EQ(&v1.GetArray(), &v2.GetArray());
EXPECT_EQ(&v1.ArrayAt(2).GetArray(), &v2.ArrayAt(2).GetArray());
}
TEST_F(DomValueTests, CopyOnWrite_Node)
{
Value v1;
v1.SetNode("TopLevel");
v1.ArrayPushBack(Value(1));
v1.ArrayPushBack(Value(2));
v1["obj"].SetNode("Nested");
Value v2 = v1;
EXPECT_EQ(&v1.GetNode(), &v2.GetNode());
EXPECT_EQ(&v1["obj"].GetNode(), &v2["obj"].GetNode());
v2[0] = 0;
EXPECT_NE(&v1.GetNode(), &v2.GetNode());
EXPECT_EQ(&v1["obj"].GetNode(), &v2["obj"].GetNode());
v2["obj"].ArrayPushBack(Value(42));
EXPECT_NE(&v1.GetNode(), &v2.GetNode());
EXPECT_NE(&v1["obj"].GetNode(), &v2["obj"].GetNode());
v2 = v1;
EXPECT_EQ(&v1.GetNode(), &v2.GetNode());
EXPECT_EQ(&v1["obj"].GetNode(), &v2["obj"].GetNode());
}
} // namespace AZ::Dom::Tests
Code/Framework/AzCore/Tests/EBus.cpp
+15 -15
View File
@@ -373,8 +373,8 @@ namespace UnitTest
: public AllocatorsFixture
{
public:
using Handler = Handler<Bus>;
using MultiHandlerById = MultiHandlerById<Bus>;
using BusHandler = Handler<Bus>;
using BusMultiHandlerById = MultiHandlerById<Bus>;
EBusTestAll()
{
@@ -402,7 +402,7 @@ namespace UnitTest
{
for (int handler = 0; handler < numHandlersPerAddress; ++handler)
{
m_handlers[address].emplace_back(aznew Handler(address, connectOnConstruct));
m_handlers[address].emplace_back(aznew BusHandler(address, connectOnConstruct));
++m_numHandlers;
}
}
@@ -429,7 +429,7 @@ namespace UnitTest
{
for (const auto& handlerPair : m_handlers)
{
for (Handler* handler : handlerPair.second)
for (BusHandler* handler : handlerPair.second)
{
delete handler;
}
@@ -452,7 +452,7 @@ namespace UnitTest
if (AddressesAreOrdered())
{
// Collect the first handler from each address
using PairType = AZStd::pair<int, Handler*>;
using PairType = AZStd::pair<int, BusHandler*>;
AZStd::vector<PairType> sortedHandlers;
for (const auto& handlerPair : m_handlers)
{
@@ -495,7 +495,7 @@ namespace UnitTest
{
auto& handlers = m_handlers[id];
for (Handler* handler : handlers)
for (BusHandler* handler : handlers)
{
EXPECT_EQ(expected, handler->m_eventCalls);
}
@@ -505,11 +505,11 @@ namespace UnitTest
{
// Sort the handlers the same way we expect the bus to sort them
auto sortedHandlers = handlers;
AZStd::sort(sortedHandlers.begin(), sortedHandlers.end(), AZStd::bind(&Handler::Compare, AZStd::placeholders::_1, AZStd::placeholders::_2));
AZStd::sort(sortedHandlers.begin(), sortedHandlers.end(), AZStd::bind(&BusHandler::Compare, AZStd::placeholders::_1, AZStd::placeholders::_2));
// Iterate over the list, and validate that they were called in the correct order
unsigned int lastExecuted = 0;
for (const Handler* handler : sortedHandlers)
for (const BusHandler* handler : sortedHandlers)
{
if (lastExecuted > 0)
{
@@ -550,7 +550,7 @@ namespace UnitTest
}
protected:
AZStd::unordered_map<int, AZStd::vector<Handler*>> m_handlers;
AZStd::unordered_map<int, AZStd::vector<BusHandler*>> m_handlers;
int m_numHandlers = 0;
};
TYPED_TEST_CASE(EBusTestAll, BusTypesAll);
@@ -578,7 +578,7 @@ namespace UnitTest
TYPED_TEST(EBusTestAll, ConnectDisconnect)
{
using Bus = TypeParam;
using Handler = typename EBusTestAll<Bus>::Handler;
using Handler = typename EBusTestAll<Bus>::BusHandler;
constexpr bool connectOnConstruct{ true };
Handler meh(0, connectOnConstruct);
@@ -602,13 +602,13 @@ namespace UnitTest
TYPED_TEST(EBusTestIdMultiHandlers, EnumerateHandlers_MultiHandler)
{
using Bus = TypeParam;
using MultiHandlerById = typename EBusTestAll<Bus>::MultiHandlerById;
using BusMultiHandlerById = typename EBusTestAll<Bus>::BusMultiHandlerById;
MultiHandlerById sourceMultiHandler{ 0, 1, 2 };
MultiHandlerById multiHandlerWithOverlappingIds{ 1, 3, 5 };
BusMultiHandlerById sourceMultiHandler{ 0, 1, 2 };
BusMultiHandlerById multiHandlerWithOverlappingIds{ 1, 3, 5 };
// Test handlers' enumeration functionality
Bus::EnumerateHandlers([](typename MultiHandlerById::Interface* interfaceInst) -> bool
Bus::EnumerateHandlers([](typename BusMultiHandlerById::Interface* interfaceInst) -> bool
{
interfaceInst->OnEvent();
return true;
@@ -618,7 +618,7 @@ namespace UnitTest
TYPED_TEST(EBusTestId, FindFirstHandler)
{
using Bus = TypeParam;
using Handler = typename EBusTestAll<Bus>::Handler;
using Handler = typename EBusTestAll<Bus>::BusHandler;
constexpr bool connectOnConstruct{ true };
Handler meh0(0, connectOnConstruct); /// <-- Bind to bus 0
Handler meh1(1, connectOnConstruct); /// <-- Bind to bus 1
Code/Framework/AzCore/Tests/Math/MathTest.h
+19
View File
@@ -0,0 +1,19 @@
/*
* Copyright (c) Contributors to the Open 3D Engine Project.
* For complete copyright and license terms please see the LICENSE at the root of this distribution.
*
* SPDX-License-Identifier: Apache-2.0 OR MIT
*
*/
#pragma once
#include <AzCore/UnitTest/TestTypes.h>
#if AZ_DEBUG_BUILD
#define AZ_MATH_TEST_START_TRACE_SUPPRESSION AZ_TEST_START_TRACE_SUPPRESSION
#define AZ_MATH_TEST_STOP_TRACE_SUPPRESSION(x) AZ_TEST_STOP_TRACE_SUPPRESSION(x)
#else
#define AZ_MATH_TEST_START_TRACE_SUPPRESSION
#define AZ_MATH_TEST_STOP_TRACE_SUPPRESSION(x)
#endif
Code/Framework/AzCore/Tests/Math/PlaneTests.cpp
+10 -1
View File
@@ -12,6 +12,7 @@
#include <AzCore/Math/Vector3.h>
#include <AzCore/Math/Vector4.h>
#include <AzCore/UnitTest/TestTypes.h>
#include <Math/MathTest.h>
using namespace AZ;
@@ -47,7 +48,9 @@ namespace UnitTest
TEST(MATH_Plane, TestSet)
{
Plane pl;
AZ_MATH_TEST_START_TRACE_SUPPRESSION;
pl.Set(12.0f, 13.0f, 14.0f, 15.0f);
AZ_MATH_TEST_STOP_TRACE_SUPPRESSION(1);
AZ_TEST_ASSERT_FLOAT_CLOSE(pl.GetDistance(), 15.0f);
AZ_TEST_ASSERT_FLOAT_CLOSE(pl.GetNormal().GetX(), 12.0f);
AZ_TEST_ASSERT_FLOAT_CLOSE(pl.GetNormal().GetY(), 13.0f);
@@ -57,7 +60,9 @@ namespace UnitTest
TEST(MATH_Plane, TestSetVector3)
{
Plane pl;
AZ_MATH_TEST_START_TRACE_SUPPRESSION;
pl.Set(Vector3(22.0f, 23.0f, 24.0f), 25.0f);
AZ_MATH_TEST_STOP_TRACE_SUPPRESSION(1);
AZ_TEST_ASSERT_FLOAT_CLOSE(pl.GetDistance(), 25.0f);
AZ_TEST_ASSERT_FLOAT_CLOSE(pl.GetNormal().GetX(), 22.0f);
AZ_TEST_ASSERT_FLOAT_CLOSE(pl.GetNormal().GetY(), 23.0f);
@@ -177,17 +182,21 @@ namespace UnitTest
pl.Set(1.0f, 0.0f, 0.0f, 0.0f);
AZ_TEST_ASSERT(pl.IsFinite());
const float infinity = std::numeric_limits<float>::infinity();
AZ_MATH_TEST_START_TRACE_SUPPRESSION;
pl.Set(infinity, infinity, infinity, infinity);
AZ_MATH_TEST_STOP_TRACE_SUPPRESSION(1);
AZ_TEST_ASSERT(!pl.IsFinite());
}
TEST(MATH_Plane, CreateFromVectorCoefficients_IsEquivalentToCreateFromCoefficients)
{
AZ_MATH_TEST_START_TRACE_SUPPRESSION;
Plane planeFromCoefficients = Plane::CreateFromCoefficients(1.0, 2.0, 3.0, 4.0);
AZ_MATH_TEST_STOP_TRACE_SUPPRESSION(1);
Vector4 coefficients(1.0, 2.0, 3.0, 4.0);
Plane planeFromVectorCoefficients = Plane::CreateFromVectorCoefficients(coefficients);
EXPECT_EQ(planeFromVectorCoefficients, planeFromCoefficients);
}
}
Code/Framework/AzCore/Tests/ScriptMath.cpp
+8
View File
@@ -15,6 +15,8 @@
#include <AzCore/Math/Obb.h>
#include <AzCore/Math/Aabb.h>
#include <Math/MathTest.h>
using namespace AZ;
namespace UnitTest
@@ -1409,13 +1411,17 @@ namespace UnitTest
script->Execute("AZTestAssertFloatClose(pl:GetNormal().y,-1)");
script->Execute("AZTestAssertFloatClose(pl:GetNormal().z,0)");
AZ_MATH_TEST_START_TRACE_SUPPRESSION;
script->Execute("pl:Set(12, 13, 14, 15)");
AZ_MATH_TEST_STOP_TRACE_SUPPRESSION(1);
script->Execute("AZTestAssertFloatClose(pl:GetDistance(), 15)");
script->Execute("AZTestAssertFloatClose(pl:GetNormal().x, 12)");
script->Execute("AZTestAssertFloatClose(pl:GetNormal().y, 13)");
script->Execute("AZTestAssertFloatClose(pl:GetNormal().z, 14)");
AZ_MATH_TEST_START_TRACE_SUPPRESSION;
script->Execute("pl:Set(Vector3(22, 23, 24), 25)");
AZ_MATH_TEST_STOP_TRACE_SUPPRESSION(1);
script->Execute("AZTestAssertFloatClose(pl:GetDistance(), 25)");
script->Execute("AZTestAssertFloatClose(pl:GetNormal().x, 22)");
script->Execute("AZTestAssertFloatClose(pl:GetNormal().y, 23)");
@@ -1493,7 +1499,9 @@ namespace UnitTest
script->Execute("pl:Set(1, 0, 0, 0)");
script->Execute("AZTestAssert(pl:IsFinite())");
AZ_MATH_TEST_START_TRACE_SUPPRESSION;
script->Execute("pl:Set(math.huge, math.huge, math.huge, math.huge)");
AZ_MATH_TEST_STOP_TRACE_SUPPRESSION(1);
script->Execute("AZTestAssert( not pl:IsFinite())");
}
Code/Framework/AzCore/Tests/Serialization.cpp
+11 -6
View File
@@ -4014,9 +4014,12 @@ TEST_F(SerializeBasicTest, BasicTypeTest_Succeed)
};
}
} // namespace UnitTest
AZ_TYPE_INFO_SPECIALIZE(UnitTest::EditTest::MyEditStruct3::EditEnum, "{4AF433C2-055E-4E34-921A-A7D16AB548CA}");
AZ_TYPE_INFO_SPECIALIZE(UnitTest::EditTest::MyEditStruct3::EditEnumClass, "{4FEC2F0B-A599-4FCD-836B-89E066791793}");
namespace AZ
{
AZ_TYPE_INFO_SPECIALIZE(UnitTest::EditTest::MyEditStruct3::EditEnum, "{4AF433C2-055E-4E34-921A-A7D16AB548CA}");
AZ_TYPE_INFO_SPECIALIZE(UnitTest::EditTest::MyEditStruct3::EditEnumClass, "{4FEC2F0B-A599-4FCD-836B-89E066791793}");
}
namespace UnitTest
{
@@ -7798,10 +7801,12 @@ namespace UnitTest
};
}
AZ_TYPE_INFO_SPECIALIZE(UnitTest::TestUnscopedSerializationEnum, "{83383BFA-F6DA-4124-BE4F-2FAAB7C594E7}");
AZ_TYPE_INFO_SPECIALIZE(UnitTest::TestScopedSerializationEnum, "{17341C5E-81C3-44CB-A40D-F97D49C2531D}");
AZ_TYPE_INFO_SPECIALIZE(UnitTest::TestUnsignedEnum, "{0F91A5AE-DADA-4455-B158-8DB79D277495}");
namespace AZ
{
AZ_TYPE_INFO_SPECIALIZE(UnitTest::TestUnscopedSerializationEnum, "{83383BFA-F6DA-4124-BE4F-2FAAB7C594E7}");
AZ_TYPE_INFO_SPECIALIZE(UnitTest::TestScopedSerializationEnum, "{17341C5E-81C3-44CB-A40D-F97D49C2531D}");
AZ_TYPE_INFO_SPECIALIZE(UnitTest::TestUnsignedEnum, "{0F91A5AE-DADA-4455-B158-8DB79D277495}");
}
namespace UnitTest
{
Code/Framework/AzCore/Tests/azcoretests_files.cmake
+5
View File
@@ -148,6 +148,7 @@ set(FILES
Math/Matrix4x4PerformanceTests.cpp
Math/Matrix4x4Tests.cpp
Math/MatrixUtilsTests.cpp
Math/MathTest.h
Math/MathTestData.h
Math/ObbPerformanceTests.cpp
Math/ObbTests.cpp
@@ -214,8 +215,12 @@ set(FILES
AZStd/Variant.cpp
AZStd/VariantSerialization.cpp
AZStd/VectorAndArray.cpp
DOM/DomFixtures.cpp
DOM/DomFixtures.h
DOM/DomJsonTests.cpp
DOM/DomJsonBenchmarks.cpp
DOM/DomValueTests.cpp
DOM/DomValueBenchmarks.cpp
)
# Prevent the following files from being grouped in UNITY builds