Cachepolicy (#36)

* Copy CachePolicy implementation from UE5/Release-5.0. Add backwards compatability for clients and upstreams that are using the old protocol.

* Add RefPtr templated move operator and constructor, so that RefPtr<const Foo*> A = std::move(RefPtr<Foo*>()) will do a move.

* Fix broken CachePolicy tests and add tests for new Save/Load.

* Remove TODO comments

* CachePolicy Save/Load Fixes from codereview

* Fix comment to match code change.

* Remove backwards compatibility for CachePolicy change. Convert policy string tokens to PascalCase. Fix tests for new policy text. Change ParseCachePolicy to assert string is non-empty and always succeed.

* Fix release build: use ZEN_WITH_TESTS define

1 files changed, 164 insertions, 0 deletions

diff --git a/zenserver-test/cachepolicy-tests.cpp b/zenserver-test/cachepolicy-tests.cpp
new file mode 100644
index 000000000..686ff818c
--- /dev/null
+++ b/zenserver-test/cachepolicy-tests.cpp
@@ -0,0 +1,164 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#include <zencore/zencore.h>
+
+#if ZEN_WITH_TESTS
+
+#	include <zencore/compactbinary.h>
+#	include <zencore/compactbinarybuilder.h>
+#	include <zencore/string.h>
+#	include <zencore/testing.h>
+#	include <zencore/uid.h>
+#	include <zenutil/cache/cachepolicy.h>
+
+namespace zen::tests {
+
+using namespace std::literals;
+
+TEST_CASE("cachepolicy")
+{
+	SUBCASE("atomics serialization")
+	{
+		CachePolicy SomeAtomics[] = {CachePolicy::None,
+									 CachePolicy::QueryLocal,
+									 CachePolicy::StoreRemote,
+									 CachePolicy::SkipData,
+									 CachePolicy::KeepAlive,
+									 CachePolicy::Disable};
+		for (CachePolicy Atomic : SomeAtomics)
+		{
+			CHECK(ParseCachePolicy(WriteToString<128>(Atomic)) == Atomic);
+		}
+		// Also verify that we ignore unrecognized bits
+		for (CachePolicy Atomic : SomeAtomics)
+		{
+			CHECK(ParseCachePolicy(WriteToString<128>(Atomic | (CachePolicy)0x10000000)) == Atomic);
+		}
+	}
+	SUBCASE("aliases serialization")
+	{
+		CachePolicy SomeAliases[] = {CachePolicy::Query, CachePolicy::Local};
+		for (CachePolicy Alias : SomeAliases)
+		{
+			CHECK(ParseCachePolicy(WriteToString<128>(Alias)) == Alias);
+		}
+		// Also verify that we ignore unrecognized bits
+		for (CachePolicy Alias : SomeAliases)
+		{
+			CHECK(ParseCachePolicy(WriteToString<128>(Alias | (CachePolicy)0x10000000)) == Alias);
+		}
+	}
+	SUBCASE("aliases take priority over atomics")
+	{
+		CHECK(WriteToString<128>(CachePolicy::Default).ToView() == "Default"sv);
+		CHECK(WriteToString<128>(CachePolicy::Query).ToView() == "Query"sv);
+		CHECK(WriteToString<128>(CachePolicy::Local).ToView() == "Local"sv);
+	}
+	SUBCASE("policies requiring multiple strings work")
+	{
+		char		Delimiter	= ',';
+		CachePolicy Combination = CachePolicy::SkipData | CachePolicy::QueryLocal;
+		CHECK(WriteToString<128>(Combination).ToView().find(Delimiter) != std::string_view::npos);
+		CHECK(ParseCachePolicy(WriteToString<128>(Combination)) == Combination);
+	}
+	SUBCASE("parsing invalid text")
+	{
+		CHECK(ParseCachePolicy(",,,") == CachePolicy::None);
+		CHECK(ParseCachePolicy("fee,fie,foo,fum") == CachePolicy::None);
+		CHECK(ParseCachePolicy("fee,KeepAlive,foo,fum") == CachePolicy::KeepAlive);
+	}
+}
+
+TEST_CASE("cacherecordpolicy")
+{
+	SUBCASE("policy with no values")
+	{
+		CachePolicy				 Policy = CachePolicy::SkipData | CachePolicy::QueryLocal;
+		CacheRecordPolicy		 RecordPolicy;
+		CacheRecordPolicyBuilder Builder(Policy);
+		RecordPolicy = Builder.Build();
+		SUBCASE("construct")
+		{
+			CHECK(RecordPolicy.IsUniform());
+			CHECK(RecordPolicy.GetRecordPolicy() == Policy);
+			CHECK(RecordPolicy.GetDefaultValuePolicy() == Policy);
+			CHECK(RecordPolicy.GetValuePolicy(Oid::NewOid()) == Policy);
+			CHECK(RecordPolicy.GetValuePolicies().size() == 0);
+		}
+		SUBCASE("saveload")
+		{
+			CbWriter Writer;
+			RecordPolicy.Save(Writer);
+			CbObject		  Saved	 = Writer.Save()->AsObject();
+			CacheRecordPolicy Loaded = CacheRecordPolicy::Load(Saved);
+			CHECK(Loaded.IsUniform());
+			CHECK(Loaded.GetRecordPolicy() == Policy);
+			CHECK(Loaded.GetDefaultValuePolicy() == Policy);
+			CHECK(Loaded.GetValuePolicy(Oid::NewOid()) == Policy);
+			CHECK(Loaded.GetValuePolicies().size() == 0);
+		}
+	}
+
+	SUBCASE("policy with values")
+	{
+		CachePolicy DefaultPolicy  = CachePolicy::StoreRemote | CachePolicy::QueryLocal;
+		CachePolicy PartialOverlap = CachePolicy::StoreRemote;
+		CachePolicy NoOverlap	   = CachePolicy::QueryRemote;
+		CachePolicy UnionPolicy	   = DefaultPolicy | PartialOverlap | NoOverlap;
+
+		CacheRecordPolicy		 RecordPolicy;
+		CacheRecordPolicyBuilder Builder(DefaultPolicy);
+		Oid						 PartialOid	  = Oid::NewOid();
+		Oid						 NoOverlapOid = Oid::NewOid();
+		Oid						 OtherOid	  = Oid::NewOid();
+		Builder.AddValuePolicy(PartialOid, PartialOverlap);
+		Builder.AddValuePolicy(NoOverlapOid, NoOverlap);
+		RecordPolicy = Builder.Build();
+		SUBCASE("construct")
+		{
+			CHECK(!RecordPolicy.IsUniform());
+			CHECK(RecordPolicy.GetRecordPolicy() == UnionPolicy);
+			CHECK(RecordPolicy.GetDefaultValuePolicy() == DefaultPolicy);
+			CHECK(RecordPolicy.GetValuePolicy(PartialOid) == PartialOverlap);
+			CHECK(RecordPolicy.GetValuePolicy(NoOverlapOid) == NoOverlap);
+			CHECK(RecordPolicy.GetValuePolicy(OtherOid) == DefaultPolicy);
+			CHECK(RecordPolicy.GetValuePolicies().size() == 2);
+		}
+		SUBCASE("saveload")
+		{
+			CbWriter Writer;
+			RecordPolicy.Save(Writer);
+			CbObject		  Saved	 = Writer.Save()->AsObject();
+			CacheRecordPolicy Loaded = CacheRecordPolicy::Load(Saved);
+			CHECK(!RecordPolicy.IsUniform());
+			CHECK(RecordPolicy.GetRecordPolicy() == UnionPolicy);
+			CHECK(RecordPolicy.GetDefaultValuePolicy() == DefaultPolicy);
+			CHECK(RecordPolicy.GetValuePolicy(PartialOid) == PartialOverlap);
+			CHECK(RecordPolicy.GetValuePolicy(NoOverlapOid) == NoOverlap);
+			CHECK(RecordPolicy.GetValuePolicy(OtherOid) == DefaultPolicy);
+			CHECK(RecordPolicy.GetValuePolicies().size() == 2);
+		}
+	}
+
+	SUBCASE("parsing invalid text")
+	{
+		CacheRecordPolicy Loaded = CacheRecordPolicy::Load(CbObject());
+		CHECK(Loaded.IsUniform());
+		CHECK(Loaded.GetRecordPolicy() == CachePolicy::Default);
+		CHECK(Loaded.GetDefaultValuePolicy() == CachePolicy::Default);
+		CHECK(Loaded.GetValuePolicy(Oid::NewOid()) == CachePolicy::Default);
+		CHECK(Loaded.GetValuePolicies().size() == 0);
+
+		CachePolicy Policy = CachePolicy::SkipData;
+		Loaded			   = CacheRecordPolicy::Load(CbObject(), Policy);
+		CHECK(Loaded.IsUniform());
+		CHECK(Loaded.GetRecordPolicy() == Policy);
+		CHECK(Loaded.GetDefaultValuePolicy() == Policy);
+		CHECK(Loaded.GetValuePolicy(Oid::NewOid()) == Policy);
+		CHECK(Loaded.GetValuePolicies().size() == 0);
+	}
+}
+
+}  // namespace zen::tests
+
+#endif