139 lines
3.4 KiB
C++
139 lines
3.4 KiB
C++
// Copyright Epic Games, Inc. All Rights Reserved.
|
|
|
|
#include "TestNetSerializerFixture.h"
|
|
#include "Iris/Serialization/FloatNetSerializers.h"
|
|
#include "Iris/Core/BitTwiddling.h"
|
|
#include <limits>
|
|
|
|
namespace UE::Net::Private
|
|
{
|
|
|
|
static FTestMessage& PrintFloatNetSerializerConfig(FTestMessage& Message, const FNetSerializerConfig& InConfig)
|
|
{
|
|
return Message;
|
|
}
|
|
|
|
template<typename T>
|
|
class FTestFloatNetSerializerBase : public TTestNetSerializerFixture<PrintFloatNetSerializerConfig, T>
|
|
{
|
|
typedef TTestNetSerializerFixture<PrintFloatNetSerializerConfig, T> Super;
|
|
|
|
public:
|
|
FTestFloatNetSerializerBase(const FNetSerializer& Serializer) : Super(Serializer) {}
|
|
|
|
void TestIsEqual();
|
|
void TestSerialize();
|
|
void TestSerializeDelta();
|
|
|
|
protected:
|
|
static const T Values[];
|
|
static const SIZE_T ValueCount;
|
|
};
|
|
|
|
template<typename T>
|
|
const T FTestFloatNetSerializerBase<T>::Values[] =
|
|
{
|
|
std::numeric_limits<T>::infinity(),
|
|
-std::numeric_limits<T>::infinity(),
|
|
std::numeric_limits<T>::quiet_NaN(),
|
|
-0.0f,
|
|
+0.0f,
|
|
std::numeric_limits<T>::max(),
|
|
std::numeric_limits<T>::lowest(),
|
|
47.11f,
|
|
757575.0f,
|
|
757576.0f,
|
|
1.26698556E-23f,
|
|
};
|
|
template<typename T>
|
|
const SIZE_T FTestFloatNetSerializerBase<T>::ValueCount = sizeof(Values)/sizeof(Values[0]);
|
|
|
|
class FTestFloatNetSerializer : public FTestFloatNetSerializerBase<float>
|
|
{
|
|
public:
|
|
FTestFloatNetSerializer() : FTestFloatNetSerializerBase<float>(UE_NET_GET_SERIALIZER(FFloatNetSerializer)) {}
|
|
};
|
|
|
|
class FTestDoubleNetSerializer : public FTestFloatNetSerializerBase<double>
|
|
{
|
|
public:
|
|
FTestDoubleNetSerializer() : FTestFloatNetSerializerBase<double>(UE_NET_GET_SERIALIZER(FDoubleNetSerializer)) {}
|
|
};
|
|
|
|
UE_NET_TEST_FIXTURE(FTestFloatNetSerializer, TestIsEqual)
|
|
{
|
|
TestIsEqual();
|
|
}
|
|
|
|
UE_NET_TEST_FIXTURE(FTestFloatNetSerializer, TestSerialize)
|
|
{
|
|
TestSerialize();
|
|
}
|
|
|
|
UE_NET_TEST_FIXTURE(FTestFloatNetSerializer, TestSerializeDelta)
|
|
{
|
|
TestSerializeDelta();
|
|
}
|
|
|
|
UE_NET_TEST_FIXTURE(FTestDoubleNetSerializer, TestIsEqual)
|
|
{
|
|
TestIsEqual();
|
|
}
|
|
|
|
UE_NET_TEST_FIXTURE(FTestDoubleNetSerializer, TestSerialize)
|
|
{
|
|
TestSerialize();
|
|
}
|
|
|
|
UE_NET_TEST_FIXTURE(FTestDoubleNetSerializer, TestSerializeDelta)
|
|
{
|
|
TestSerializeDelta();
|
|
}
|
|
|
|
//
|
|
template<typename T>
|
|
void FTestFloatNetSerializerBase<T>::TestIsEqual()
|
|
{
|
|
T CompareValues[2][sizeof(Values)/sizeof(Values[0])];
|
|
bool ExpectedResults[2][sizeof(Values)/sizeof(Values[0])];
|
|
|
|
for (SIZE_T ValueIt = 0; ValueIt < ValueCount; ++ValueIt)
|
|
{
|
|
CompareValues[0][ValueIt] = Values[ValueIt];
|
|
ExpectedResults[0][ValueIt] = true;
|
|
}
|
|
for (SIZE_T ValueIt = 0; ValueIt < ValueCount; ++ValueIt)
|
|
{
|
|
CompareValues[1][ValueIt] = Values[(ValueIt + 1) % ValueCount];
|
|
ExpectedResults[1][ValueIt] = false;
|
|
}
|
|
|
|
const FFloatNetSerializerConfig Config;
|
|
for (SIZE_T TestRoundIt = 0, TestRoundEndIt = 2; TestRoundIt != TestRoundEndIt; ++TestRoundIt)
|
|
{
|
|
constexpr bool bQuantizedCompare = false;
|
|
bool bSuccess = Super::TestIsEqual(Values, CompareValues[TestRoundIt], ExpectedResults[TestRoundIt], ValueCount, Config, bQuantizedCompare);
|
|
if (!bSuccess)
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
template<typename T>
|
|
void FTestFloatNetSerializerBase<T>::TestSerialize()
|
|
{
|
|
const FFloatNetSerializerConfig Config;
|
|
constexpr bool bQuantizedCompare = false;
|
|
Super::TestSerialize(Values, Values, ValueCount, Config, bQuantizedCompare);
|
|
}
|
|
|
|
template<typename T>
|
|
void FTestFloatNetSerializerBase<T>::TestSerializeDelta()
|
|
{
|
|
const FFloatNetSerializerConfig Config;
|
|
Super::TestSerializeDelta(Values, ValueCount, Config);
|
|
}
|
|
|
|
}
|