+Unity Runtime codeHEADmaster

1 files changed, 537 insertions, 0 deletions

diff --git a/Runtime/Testing/HighLevelTest.cpp b/Runtime/Testing/HighLevelTest.cpp
new file mode 100644
index 0000000..dc4018d
--- /dev/null
+++ b/Runtime/Testing/HighLevelTest.cpp
@@ -0,0 +1,537 @@
+#include "UnityPrefix.h"
+
+#if ENABLE_UNIT_TESTS
+
+#include "HighLevelTest.h"
+#include "Runtime/Math/Vector2.h"
+#include "Runtime/Misc/GameObjectUtility.h"
+#include "Runtime/Graphics/Transform.h"
+#include "Runtime/Serialize/DumpSerializedDataToText.h"
+#include "Runtime/Serialize/TypeTree.h"
+#include "Runtime/BaseClasses/SupportedMessageOptimization.h"
+#include "Runtime/Allocator/MemoryManager.h"
+
+#if !UNITY_XENON && !UNITY_ANDROID
+#include "PlatformDependent/CommonWebPlugin/Verification.h"
+#endif
+#include "Runtime/Serialize/TransferUtility.h"
+#include "Runtime/BaseClasses/ManagerContext.h"
+#include "Runtime/Serialize/PersistentManager.h"
+#include "Runtime/Graphics/Texture2D.h"
+
+#include "Runtime/Misc/BuildSettings.h"
+#if UNITY_EDITOR
+#include "Editor/Platform/Interface/EditorUtility.h"
+#include "Editor/Src/Prefabs/PrefabMergingTest.h"
+#include "Editor/Src/Prefabs/PropertyModification.h"
+#endif
+
+void* RunObjectResetTests (void* userData);
+void RunAllObjectResetTests();
+void TestVersions ();
+void TestLaunchingALotOfTasks ();
+void TestSerializedPropertyPath ();
+void TestEditorComponentUtility();
+void TestAssetImporterCallsPostTransfer ();
+
+void RunHighLevelTest ()
+{	
+	#if !UNITY_XENON && !UNITY_ANDROID && !UNITY_PEPPER
+	ErrorIf(!VerifySignature("a", "98ad49733651a83f333d7b91a2f76f77510bfaf89316e34d0025b5b38526c8f8d269e47be24044b9f0dd8675fc781b21fc425da801e33702f9744462c488b400ce9af75b8ae3ec02e6915ce980adcc700fd9d5b2633812ac168d2dea24906bb1cdb3de2bffa4ddeeeb9bc5966b0768e7bc20a8320bf6a0a48cf57b26e31f98b0"));
+	ErrorIf(!VerifySignature("abc", "5ac52e1f8f7e331cf1b1c5bef6254cfbc81c4b48296ae4b4e8a8c536de61c9cade1c77c45b047ce880b8f74829f52860c87b2ecf82a96803059e9189c879a63770a071483ab9d7b688cadcf3aa2a857849f86ff3fdecd725cf34e99f5fc5e4496ca9b810c841dc3a5527c7b3bc866ced1daf120ade08614ec6273d293c293880"));
+	ErrorIf(!VerifySignature("abcd", "584e7bf6042e8a93585bd9a1c08115705f59e0e7e07656a09b16a526b4b76cbc92f5a7246fdd706031f4186361d8cf87ae2062ab877ea9a2576c59be8a9a3139c374345b61a56046376e174ec510cc0d9be46176f8fb0096aeca259b8e754abd424dd3ef50f3473d552fcba6c946bff1908e70cea57584c9002c4bc245e15e35"));
+
+	ErrorIf(!VerifySignature("http://webplayer.unity3d.com/", "99874573f0651e46ac2c9b0f872a7ecf1ee9c101195bf2d06cd6cd00508b412aa58db8b61fa898ecc0f5e37b7efd6c2762081eb5aa9810e6001c9e5a7d32d9b1fdd6ce11d7cd666a997b2c443f123173dac380ca9e06d9ac7aef7c3794d4f3dfc2b62eaf0684cb5a8ba762700b1ae74ef35ce768312c483020455936ed47bf46"));
+	ErrorIf(!VerifySignature("http://wp-fusionfall.unity3d.com/", "606558a42652f6d31130505aa3a9a24dfbd9801b15f79181fac171e0807064799313a6f4369883c276361efb757fd6e979e607be4e981e6ff36308078c13b7bdf59a1f4f06a8f4a5bf78848fb8f4597e2028e9fcd43882a1dcdcf2c1f3756ebf2afab65492e117d53894b81e19435ba8c913a89d07c64c1095b1abe7fa632c15"));
+	ErrorIf(!VerifySignature("http://wp-jumpstart.unity3d.com/", "9f5dce353ddccf0adca627c070135fdc8de70925b366ee661d704c4e90c33fa760a452cc741862ca2e87bc722a2cbf1b0948b2116132f88e45a11e6461cc70190db80f97268a55e0cc96d062272d9eb22d5041e9152d1cc980a4448de1282bdf4dbfe27c558ec0f922b1277fcad57b607364d724d0658500a2b5c2dd0245b050"));
+	#endif
+	
+	#if !UNITY_PEPPER
+	//Some access the default resources as part of their reset procedure, which are not loaded at this stage in NaCl yet.
+	//So we skip this test in Pepper.
+	RunAllObjectResetTests ();
+	#endif
+	
+	TestVersions();
+
+	void TestHighLevelShaderNameRegistryTests();
+	TestHighLevelShaderNameRegistryTests();
+	
+	
+	#if UNITY_EDITOR
+		
+	TestPropertyModification();
+	TestPrefabModification();
+	
+	// TestLaunchingALotOfTasks ();
+
+	TestEditorComponentUtility();
+
+	TestAssetImporterCallsPostTransfer();
+
+	#if UNITY_WIN
+	void TestGetActualPathWindows();
+	TestGetActualPathWindows();
+	#endif // #if UNITY_WIN
+
+	#endif // #if UNITY_EDITOR
+}
+
+#if UNITY_EDITOR
+/// @TODO: Cant do this on every launch of unity, integrate into properl C++ unit test suite
+void TestLaunchingALotOfTasks ()
+{
+	#if UNITY_OSX
+	for (int i=0;i<400;i++)
+	{
+		if (!LaunchTask ("/bin/ls", NULL, NULL))
+			LogString("Fail");
+	}
+
+	for (int i=0;i<400;i++)
+	{
+		string output;
+		if (!LaunchTask ("/bin/ls", &output, NULL) && !output.empty())
+			LogString("Fail");
+	}
+	#endif
+}
+#endif
+
+
+void TestVersions ()
+{
+	int current = 0;
+	int previous = 0;
+	
+	current = GetNumericVersion("2.6.0b1"); Assert(current > previous); previous = current;
+	current = GetNumericVersion("2.6.0b7"); Assert(current > previous); previous = current;
+	current = GetNumericVersion("2.6.0b9"); Assert(current > previous); previous = current;
+	current = GetNumericVersion("2.6.0"); Assert(current > previous); previous = current;
+	current = GetNumericVersion("2.6.0f1"); Assert(current > previous); previous = current;
+	current = GetNumericVersion("2.6.0f4"); Assert(current > previous); previous = current;
+	current = GetNumericVersion("2.6.0f8"); Assert(current > previous); previous = current;
+	current = GetNumericVersion("2.6.0f9"); Assert(current > previous); previous = current;
+	current = GetNumericVersion("2.6.0f14"); Assert(current > previous); previous = current;
+	current = GetNumericVersion("2.6.1b1"); Assert(current > previous); previous = current;
+	current = GetNumericVersion("2.6.1b10"); Assert(current > previous); previous = current;
+	current = GetNumericVersion("2.6.1"); Assert(current > previous); previous = current;
+	current = GetNumericVersion("2.6.1f1"); Assert(current > previous); previous = current;
+	current = GetNumericVersion("2.6.1f15"); Assert(current > previous); previous = current;
+	current = GetNumericVersion("2.6.1f16"); Assert(current > previous); previous = current;
+	current = GetNumericVersion("2.6.2b1"); Assert(current > previous); previous = current;
+}
+
+// If tests fail because they access the GameObject or other components in Awake, DO NOT
+// disable them here. Instead fix Awake not to do that in if IsActive() is not true. 
+// That will also fix crashes for importing broken prefabs, and is cleaner in general.
+const int kDisabledAwakeFromLoad[] = { 
+0
+, 89 // Cubemap (Error using invalid texture)
+, 93 // TextureRect (Error using invalid texture)
+, 117 // Texture3D (Error using invalid texture)
+, 117 // Texture3D (Error using invalid texture)
+, 28 // Texture2D (Error using invalid texture)
+, 48 // Shader  (Gives error parsing invalid shader)
+, 152 // MovieTexture gives error on awake from load because movie data is not valid
+, 156 // TerrainData gives error loading because of invalid heightmap
+
+};
+
+#define kDisabledAwakeFromLoadThreaded kDisabledAwakeFromLoad
+
+#if ENABLE_MEMORY_MANAGER
+#define ADD_CUSTOM_ALLOCATOR(Allocator) GetMemoryManager().AddCustomAllocator(Allocator)
+#define REMOVE_CUSTOM_ALLOCATOR(Allocator) GetMemoryManager().RemoveCustomAllocator(Allocator)
+#else
+#define ADD_CUSTOM_ALLOCATOR(Allocator) kMemDefault
+#define REMOVE_CUSTOM_ALLOCATOR(Allocator) {}
+#endif
+
+class UsePreallocatedMemory : public BaseAllocator
+	{
+	public:
+		UInt8 uninitializedValue;
+		
+		UsePreallocatedMemory (int size, UInt8 value, const char* name) : BaseAllocator(name)
+		{
+			baseMemory = memory = (unsigned char*) MemoryManager::LowLevelAllocate(size);
+			total = 0;
+			totalSize = size;
+			uninitializedValue = value;
+			for (int i=0;i<size;i++) 
+				baseMemory[i] = uninitializedValue;
+			id = ADD_CUSTOM_ALLOCATOR(this).label;
+		}
+		
+		virtual ~UsePreallocatedMemory () { 
+			MemoryManager::LowLevelFree(baseMemory);
+			REMOVE_CUSTOM_ALLOCATOR(this);
+		}
+		
+		virtual void* Allocate (size_t size, int align)
+		{
+			Assert(*memory == uninitializedValue);
+			
+			memory = (unsigned char*)AlignPtr(memory + sizeof(SInt32), align);
+			*reinterpret_cast<SInt32*> (memory - sizeof(SInt32)) = size;
+			memory += size;
+			total += size;
+			
+			Assert(baseMemory+totalSize > memory);
+
+			return memory - size;
+		}
+		
+		virtual void Deallocate (void* p) { total -= *(reinterpret_cast<SInt32*> (p) - 1); }
+		virtual bool Contains (const void* p)  { return p > baseMemory && p <= memory ; }
+		
+		virtual size_t GetPtrSize(const void* ptr) const {return *(reinterpret_cast<const SInt32*> (ptr) - 1); }
+
+		unsigned char* memory;
+		unsigned char* baseMemory;
+		int total;
+		int totalSize;
+		MemLabelIdentifier id;
+	};
+
+enum { kMaxGeneratedObjectCount = 5000 };
+
+struct Parameters
+{
+	ObjectCreationMode mode;
+	Object* objects[kMaxGeneratedObjectCount];
+	BaseAllocator* allocator[kMaxGeneratedObjectCount];
+};
+
+void SetObjectDirtyDisallowCalling (Object* obj)
+{
+	AssertString("SetDirty should never be called from Awake / Reset / Constructor etc");
+}
+
+static void ClearAllManagers ()
+{
+	for (int i=0;i<ManagerContext::kManagerCount;i++)
+		SetManagerPtrInContext(i, NULL);
+}
+
+static void AssignAllManagers (Object** managers)
+{
+	for (int i=0;i<ManagerContext::kManagerCount;i++)
+		SetManagerPtrInContext(i, managers[i]);
+}
+
+
+void RunAllObjectResetTests ()
+{
+#if UNITY_EDITOR
+	Object::ObjectDirtyCallbackFunction* oldCallBack  = Object::GetDirtyCallback ();
+	
+////@TODO: Enable this some day. Creating an object, especially when loaded from disk should not mark it dirty. 	
+//	Object::RegisterDirtyCallback (SetObjectDirtyDisallowCalling);
+	
+
+	Object*	managers[ManagerContext::kManagerCount];
+	memcpy(managers, GetManagerContext().m_Managers, sizeof(managers));
+	
+	Parameters paramMainThread;
+	memset(&paramMainThread, 0, sizeof(paramMainThread));
+	paramMainThread.mode = kCreateObjectDefault;
+	RunObjectResetTests (&paramMainThread);
+	
+	ClearAllManagers();
+	
+	Parameters paramResetThread;
+	memset(&paramResetThread, 0, sizeof(paramResetThread));
+	paramResetThread.mode = kCreateObjectFromNonMainThread;
+	Thread resetThread;
+	resetThread.Run(RunObjectResetTests, &paramResetThread);
+	resetThread.WaitForExit();
+	
+	for (int i=0;i<kMaxGeneratedObjectCount;i++)
+	{
+		if (paramResetThread.objects[i])
+		{
+			Object::RegisterInstanceID(paramResetThread.objects[i]);
+			bool ignoreAwake = false;
+			for (int j=0;j<sizeof(kDisabledAwakeFromLoadThreaded) / sizeof(int);j++)
+				ignoreAwake |= kDisabledAwakeFromLoadThreaded[j] == paramResetThread.objects[i]->GetClassID();
+			if (!ignoreAwake)
+				paramResetThread.objects[i]->AwakeFromLoad(kDidLoadThreaded);
+		}
+		
+		// IntegrateLoadedImmediately must be called between AwakeFromLoadThreaded and AwakeFromLoad!
+		Texture2D::IntegrateLoadedImmediately();
+		
+		AssignAllManagers(managers);
+
+		DestroyObjectHighLevel(paramResetThread.objects[i]);
+		memset(&paramMainThread, 0, sizeof(paramMainThread));
+		REMOVE_CUSTOM_ALLOCATOR(paramResetThread.allocator[i]);
+		UNITY_DELETE(paramResetThread.allocator[i],kMemDefault);
+	}
+	
+	AssignAllManagers(managers);
+	
+	Object::RegisterDirtyCallback (oldCallBack);
+#endif
+}
+
+// Compare only every 4 bytes. This is because we can't detect unaligned variables.
+// Unaligned blocks of memory will never be touched, thus will trigger an error.
+void CompareMemoryForAllValuesTouched (UsePreallocatedMemory& lhs, UsePreallocatedMemory& rhs, int klassID, const char* msg)
+{
+	// this is not a valid or complete test. We need custom code in order to test this for each object. turned off for now
+	return;
+	const int kAlignedDataSize = 16;
+	for (int j=0;j<lhs.total;j+=kAlignedDataSize)
+	{
+		bool anythingModified = false;
+		for (int p=0;p<kAlignedDataSize;p++)
+		{
+			if (lhs.baseMemory[j+p] != lhs.uninitializedValue || rhs.baseMemory[j+p] != rhs.uninitializedValue)
+				anythingModified = true;
+		}
+		
+		if (!anythingModified)
+		{
+			ErrorString("Class is not completely initialized by constructor +  " + string(msg)  + " " + Object::ClassIDToString(klassID));
+			return;
+		}
+	}
+}
+
+void DumpData (Object& obj)
+{
+	printf_console("--- Dumping %s - %s\n", obj.GetClassName().c_str(), obj.GetName());
+	TypeTree typeTree;
+	dynamic_array<UInt8> output(kMemTempAlloc);
+	GenerateTypeTree(obj, &typeTree);
+	WriteObjectToVector(obj, &output);
+	DumpSerializedDataToText(typeTree, output);
+}
+
+const static int kBaseVeryHighInstanceID = (std::numeric_limits<SInt32>::max()-1) - 5000 * 4;
+const static int kBaseVeryHighInstanceID2 = (std::numeric_limits<SInt32>::max()-1) - 10000 * 4;
+
+void* RunObjectResetTests (void* userData)
+{
+	Parameters& parameters = *((Parameters*)userData);
+	
+	vector<SInt32> klasses;
+	Object::FindAllDerivedClasses(ClassID(Object), &klasses);
+	
+	int kMaxSize = 1024 * 64;
+
+	for (int i=0;i<klasses.size();i++)
+	{
+		int klassID = klasses[i];
+		
+		if (Object::ClassIDToRTTI(klassID)->isAbstract)
+			continue;
+		// Ignore game manager derived
+		if (Object::IsDerivedFromClassID(klassID, 9))
+			continue;
+			
+		if(klassID == ClassID(Transform))
+			continue;	// ???
+		
+		if(klassID == 1027) // ignore GUISerializer. This is really just a very custom class that sets up some global state
+			continue;
+		if(klassID == 1048) // ignore InspectorExpandedState since it is a singleton class
+			continue;
+		if(klassID == 1049) // ignore AnnotationManager since it is a singleton class
+			continue;
+		if(klassID == 159) // ignore editor settings
+			continue;
+		if(klassID == 162) // ignore editor user settings 
+			continue;
+		if(klassID == 115) // ignore MonoScript, it accesses MonoManager from serialization. This is fine but doesn't fit well into the framework.
+			continue;
+		if(klassID == 148) // ignore NetworkView, Registers itself in constructor with networkmanager
+			continue;
+		if(klassID == 1037) // ignore AssetServerCache, singleton
+			continue;
+		if(klassID == 142) // ignore AssetBundle, for it to destroy we need to call UnloadAssetBundle
+			continue;
+		if(klassID == 184 || klassID == 185 || klassID == 186) // ignore SubstanceArchive, ProceduralMaterial, ProceduralTexture
+			continue;
+		
+		////// @TODO: Work in progress, need to be fixed!!!!
+		if (klassID == 156) // Terrain has some issues left
+			continue;
+
+		bool ignoreAwake = false;
+		for (int j=0;j<sizeof(kDisabledAwakeFromLoad) / sizeof(int);j++)
+			ignoreAwake |= kDisabledAwakeFromLoad[j] == klassID;
+
+		/// Run for editor classes , we might be using datatemp
+		
+		dynamic_array<UInt8> serialized1(kMemTempAlloc);
+		dynamic_array<UInt8> serialized2(kMemTempAlloc);
+		
+		UsePreallocatedMemory* mem1 = UNITY_NEW(UsePreallocatedMemory (kMaxSize, 0, "Mem1"),kMemDefault);
+		MemLabelId mem1Label = ADD_CUSTOM_ALLOCATOR(mem1);
+		Object* obj1 = Object::Produce(klassID, kBaseVeryHighInstanceID + i * 2, mem1Label, parameters.mode);
+
+		obj1->Reset();
+		
+		WriteObjectToVector(*obj1, &serialized1);
+
+		UsePreallocatedMemory* mem2 = UNITY_NEW(UsePreallocatedMemory (kMaxSize, 255, "Mem2"),kMemDefault);
+		MemLabelId mem2Label = ADD_CUSTOM_ALLOCATOR(mem2);
+		Object* obj2 = Object::Produce(klassID, kBaseVeryHighInstanceID + 2 + i * 2, mem2Label, parameters.mode);
+
+		obj2->Reset();
+		
+		WriteObjectToVector(*obj2, &serialized2);
+		
+		if (!ignoreAwake)
+		{
+			if (parameters.mode == kCreateObjectDefault)
+			{
+				obj1->AwakeFromLoad(kDidLoadFromDisk);
+				obj2->AwakeFromLoad(kDidLoadFromDisk);
+			}
+			else if (parameters.mode == kCreateObjectFromNonMainThread)
+			{
+				obj1->AwakeFromLoadThreaded();
+				obj2->AwakeFromLoadThreaded();
+			}
+		}
+		else
+		{
+			obj1->HackSetAwakeWasCalled();
+			obj2->HackSetAwakeWasCalled();
+		}
+		
+		if (mem1->total != mem2->total)
+		{
+			ErrorString("Class is different size after initialized by constructor + Reset " + Object::ClassIDToString(klassID));
+			// Dump serialized data to console.log
+			DumpData(*obj1);
+			DumpData(*obj2);
+		}
+		
+		if( !serialized1.equals(serialized2) )
+		{
+			ErrorString("Class is serialized different after initialized by constructor + Reset " + Object::ClassIDToString(klassID));
+			// Dump serialized data to console.log			
+			DumpData(*obj1);
+			DumpData(*obj2);
+		}
+		
+		if (!ignoreAwake && parameters.mode == kCreateObjectDefault)
+		{
+			// Compare only every 4 bytes. This is because we can't detect unaligned variables.
+			// Unaligned blocks of memory will never be touched, thus will trigger an error.
+			CompareMemoryForAllValuesTouched (*mem1, *mem2, klassID, "Reset");
+		}
+		
+		UsePreallocatedMemory* mem3 = UNITY_NEW(UsePreallocatedMemory (kMaxSize, 125, "Mem3"),kMemDefault);
+		MemLabelId mem3Label = ADD_CUSTOM_ALLOCATOR(mem3);
+		Object* obj3 = Object::Produce(klassID, kBaseVeryHighInstanceID2 + i * 2, mem3Label, parameters.mode);
+
+		ReadObjectFromVector(obj3, serialized1);
+		obj3->HackSetAwakeWasCalled();
+
+		CompareMemoryForAllValuesTouched (*mem1, *mem3, klassID, "Serialize Read");
+
+		WriteObjectToVector(*obj3, &serialized2);
+		if(!serialized1.equals(serialized2))
+		{
+			ErrorString("Class is serialized different after write and reading back " + Object::ClassIDToString(klassID));
+			// Dump serialized data to console.log			
+			DumpData(*obj3);
+		}
+		
+		if (parameters.mode == kCreateObjectDefault)
+		{
+			DestroyObjectHighLevel(obj1);
+			DestroyObjectHighLevel(obj2);
+			DestroyObjectHighLevel(obj3);
+		
+			AssertIf(mem1->total != 0);
+			AssertIf(mem2->total != 0);
+			AssertIf(mem3->total != 0);
+			
+			REMOVE_CUSTOM_ALLOCATOR(mem1);
+			UNITY_DELETE( mem1,kMemDefault);
+			REMOVE_CUSTOM_ALLOCATOR(mem2);
+			UNITY_DELETE( mem2,kMemDefault);
+			REMOVE_CUSTOM_ALLOCATOR(mem3);
+			UNITY_DELETE( mem3,kMemDefault);
+		}
+		else
+		{
+			parameters.objects[i * 3 + 0] = obj1;
+			parameters.objects[i * 3 + 1] = obj2;
+			parameters.objects[i * 3 + 2] = obj3;
+
+			parameters.allocator[i * 3 + 0] = mem1;
+			parameters.allocator[i * 3 + 1] = mem2;
+			parameters.allocator[i * 3 + 2] = mem3;
+		}
+		
+	}
+
+	return NULL;
+}
+
+struct TestData
+{
+	PPtr<Texture2D> m_Tex;
+	Texture2D* m_CachedTexture;
+	
+	// Property m_ActiveMatrixName; /// HOW TO SUPPORT THIS???
+
+	Vector2f m_Position;
+	Vector2f m_Scale;
+	
+	TestData ()
+	{
+		m_CachedTexture = NULL;
+		m_Tex = NULL;
+		m_Position = Vector2f(0,0);
+		m_Scale = Vector2f(1,1);
+	}
+};
+
+#if UNITY_EDITOR
+#include "Editor/Src/AssetPipeline/AssetImporter.h"
+
+void TestAssetImporterCallsPostTransfer ()
+{
+	vector<SInt32> klasses;
+	Object::FindAllDerivedClasses (ClassID (AssetImporter), &klasses);
+	UsePreallocatedMemory* mem1 = new UsePreallocatedMemory (50 * 1024, 0, "Mem1");
+	MemLabelId mem1Label = ADD_CUSTOM_ALLOCATOR(mem1);
+
+	for (int i = 0; i < klasses.size (); i++)
+	{
+		int klassID = klasses[i];
+		AssetImporter* importer = static_cast<AssetImporter*> (Object::Produce (klassID, 0, mem1Label, kCreateObjectDefault));
+		importer->Reset ();
+		importer->HackSetAwakeWasCalled ();
+
+		YAMLWrite write (0);
+		importer->VirtualRedirectTransfer (write);
+		std::string str;
+		write.OutputToString (str);
+
+		size_t offset = str.find ("m_UserData:");
+		if (offset == string::npos)
+			ErrorString (Format ("%s did not call PostTransfer in its Transfer function", importer->GetClassName ().c_str ()).c_str ());
+
+		DestroyObjectHighLevel (importer);
+	}
+
+	REMOVE_CUSTOM_ALLOCATOR(mem1);
+	delete mem1;
+}
+
+#endif
+
+
+
+#endif