Initial mirror commitHEADmaster

1 files changed, 350 insertions, 0 deletions

diff --git a/Platform/PlatformTest.cpp b/Platform/PlatformTest.cpp
new file mode 100644
index 0000000..7c7b7e8
--- /dev/null
+++ b/Platform/PlatformTest.cpp
@@ -0,0 +1,350 @@
+/*
+ Copyright (c) 2008-2009 TrueCrypt Developers Association. All rights reserved.
+
+ Governed by the TrueCrypt License 3.0 the full text of which is contained in
+ the file License.txt included in TrueCrypt binary and source code distribution
+ packages.
+*/
+
+#include "PlatformTest.h"
+#include "Exception.h"
+#include "FileStream.h"
+#include "Finally.h"
+#include "ForEach.h"
+#include "MemoryStream.h"
+#include "Mutex.h"
+#include "Serializable.h"
+#include "SharedPtr.h"
+#include "StringConverter.h"
+#include "SyncEvent.h"
+#include "Thread.h"
+#include "Common/Tcdefs.h"
+
+namespace TrueCrypt
+{
+	// make_shared_auto, File, Stream, MemoryStream, Endian, Serializer, Serializable
+	void PlatformTest::SerializerTest ()
+	{
+		shared_ptr <Stream> stream (new MemoryStream);
+
+#if 0
+		make_shared_auto (File, file);
+		finally_do_arg (File&, *file, { if (finally_arg.IsOpen()) finally_arg.Delete(); });
+
+		try
+		{
+			file->Open ("truecrypt-serializer-test.tmp", File::CreateReadWrite);
+			stream = shared_ptr <Stream> (new FileStream (file));
+		}
+		catch (...) { }
+#endif
+
+		Serializer ser (stream);
+
+		uint32 i32 = 0x12345678;
+		uint64 i64 = 0x0123456789abcdefULL;
+		string str = "string test";
+		wstring wstr = L"wstring test";
+
+		string convStr = "test";
+		StringConverter::ToSingle (wstr, convStr);
+		if (convStr != "wstring test")
+			throw TestFailed (SRC_POS);
+
+		StringConverter::Erase (convStr);
+		if (convStr != "            ")
+			throw TestFailed (SRC_POS);
+
+		wstring wEraseTest = L"erase test";
+		StringConverter::Erase (wEraseTest);
+		if (wEraseTest != L"          ")
+			throw TestFailed (SRC_POS);
+
+		list <string> stringList;
+		stringList.push_back (str + "1");
+		stringList.push_back (str + "2");
+		stringList.push_back (str + "3");
+
+		list <wstring> wstringList;
+		wstringList.push_back (wstr + L"1");
+		wstringList.push_back (wstr + L"2");
+		wstringList.push_back (wstr + L"3");
+
+		Buffer buffer (10);
+		for (size_t i = 0; i < buffer.Size(); i++)
+			buffer[i] = (byte) i;
+
+		ser.Serialize ("int32", i32);
+		ser.Serialize ("int64", i64);
+		ser.Serialize ("string", str);
+		ser.Serialize ("wstring", wstr);
+		ser.Serialize ("stringList", stringList);
+		ser.Serialize ("wstringList", wstringList);
+		ser.Serialize ("buffer", ConstBufferPtr (buffer));
+
+		ExecutedProcessFailed ex (SRC_POS, "cmd", -123, "error output");
+		ex.Serialize (stream);
+
+		list < shared_ptr <ExecutedProcessFailed> > exList;
+		exList.push_back (make_shared <ExecutedProcessFailed> (ExecutedProcessFailed (SRC_POS, "cmd", -123, "error output1")));
+		exList.push_back (make_shared <ExecutedProcessFailed> (ExecutedProcessFailed (SRC_POS, "cmd", -234, "error output2")));
+		exList.push_back (make_shared <ExecutedProcessFailed> (ExecutedProcessFailed (SRC_POS, "cmd", -567, "error output3")));
+		Serializable::SerializeList (stream, exList);
+
+#if 0
+		if (file->IsOpen())
+			file->SeekAt (0);
+#endif
+
+		uint32 di32;
+		ser.Deserialize ("int32", di32);
+		if (i32 != di32)
+			throw TestFailed (SRC_POS);
+
+		uint64 di64;
+		ser.Deserialize ("int64", di64);
+		if (i64 != di64)
+			throw TestFailed (SRC_POS);
+
+		string dstr;
+		ser.Deserialize ("string", dstr);
+		if (str != dstr)
+			throw TestFailed (SRC_POS);
+
+		wstring dwstr;
+		ser.Deserialize ("wstring", dwstr);
+		if (str != dstr)
+			throw TestFailed (SRC_POS);
+
+		int i = 1;
+		foreach (string item, ser.DeserializeStringList ("stringList"))
+		{
+			stringstream s;
+			s << str << i++;
+			if (item != s.str())
+				throw TestFailed (SRC_POS);
+		}
+
+		i = 1;
+		foreach (wstring item, ser.DeserializeWStringList ("wstringList"))
+		{
+			wstringstream s;
+			s << wstr << i++;
+			if (item != s.str())
+				throw TestFailed (SRC_POS);
+		}
+
+		Buffer dbuffer (10);
+		ser.Deserialize ("buffer", buffer);
+		for (size_t i = 0; i < buffer.Size(); i++)
+			if (buffer[i] != (byte) i)
+				throw TestFailed (SRC_POS);
+
+		shared_ptr <ExecutedProcessFailed> dex = Serializable::DeserializeNew <ExecutedProcessFailed> (stream);
+		if (!dex
+			|| dex->GetCommand() != "cmd"
+			|| dex->GetExitCode() != -123
+			|| dex->GetErrorOutput() != "error output")
+			throw TestFailed (SRC_POS);
+
+		list < shared_ptr <ExecutedProcessFailed> > dexList;
+		Serializable::DeserializeList (stream, dexList);
+		i = 1;
+		foreach_ref (const ExecutedProcessFailed &ex, dexList)
+		{
+			stringstream s;
+			s << "error output" << i++;
+			if (ex.GetErrorOutput() != s.str())
+				throw TestFailed (SRC_POS);
+		}
+	}
+	
+	// shared_ptr, Mutex, ScopeLock, SyncEvent, Thread
+	static struct 
+	{
+		shared_ptr <int> SharedIntPtr;
+		Mutex IntMutex;
+		SyncEvent ExitAllowedEvent;
+	} ThreadTestData;
+
+	void PlatformTest::ThreadTest ()
+	{
+		Mutex mutex;
+		mutex.Lock();
+		mutex.Unlock();
+
+		const int maxThreads = 3;
+		ThreadTestData.SharedIntPtr.reset (new int (0));
+
+		for (int i = 0; i < maxThreads; i++)
+		{
+			Thread t;
+			t.Start (&ThreadTestProc, (void *) &ThreadTestData);
+		}
+
+		for (int i = 0; i < 50; i++)
+		{
+			{
+				ScopeLock sl (ThreadTestData.IntMutex);
+				if (*ThreadTestData.SharedIntPtr == maxThreads)
+					break;
+			}
+
+			Thread::Sleep(100);
+		}
+
+		if (*ThreadTestData.SharedIntPtr != maxThreads)
+			throw TestFailed (SRC_POS);
+
+		for (int i = 0; i < 60000; i++)
+		{
+			ThreadTestData.ExitAllowedEvent.Signal();
+			Thread::Sleep(1);
+
+			ScopeLock sl (ThreadTestData.IntMutex);
+			if (*ThreadTestData.SharedIntPtr == 0)
+				break;
+		}
+
+		if (*ThreadTestData.SharedIntPtr != 0)
+			throw TestFailed (SRC_POS);
+	}
+
+	TC_THREAD_PROC PlatformTest::ThreadTestProc (void *arg)
+	{
+		
+		if (arg != (void *) &ThreadTestData)
+			return 0;
+
+		{
+			ScopeLock sl (ThreadTestData.IntMutex);
+			++(*ThreadTestData.SharedIntPtr);
+		}
+
+		ThreadTestData.ExitAllowedEvent.Wait();
+
+		{
+			ScopeLock sl (ThreadTestData.IntMutex);
+			--(*ThreadTestData.SharedIntPtr);
+		}
+
+		return 0;
+	}
+
+	bool PlatformTest::TestAll ()
+	{
+		// Integer types
+		if (sizeof (byte)   != 1 || sizeof (int8)  != 1 || sizeof (__int8)  != 1) throw TestFailed (SRC_POS);
+		if (sizeof (uint16) != 2 || sizeof (int16) != 2 || sizeof (__int16) != 2) throw TestFailed (SRC_POS);
+		if (sizeof (uint32) != 4 || sizeof (int32) != 4 || sizeof (__int32) != 4) throw TestFailed (SRC_POS);
+		if (sizeof (uint64) != 8 || sizeof (int64) != 8) throw TestFailed (SRC_POS);
+
+		// Exception handling
+		TestFlag = false;
+		try
+		{
+			try
+			{
+				throw TestFailed (SRC_POS);
+			}
+			catch (...)
+			{
+				throw;
+			}
+			return false;
+		}
+		catch (Exception &)
+		{
+			TestFlag = true;
+		}
+		if (!TestFlag)
+			return false;
+
+		// RTTI
+		RttiTest rtti;
+		RttiTestBase &rttiBaseRef = rtti;
+		RttiTestBase *rttiBasePtr = &rtti;
+
+		if (typeid (rttiBaseRef) != typeid (rtti))
+			throw TestFailed (SRC_POS);
+
+		if (typeid (*rttiBasePtr) != typeid (rtti))
+			throw TestFailed (SRC_POS);
+
+		if (dynamic_cast <RttiTest *> (rttiBasePtr) == nullptr)
+			throw TestFailed (SRC_POS);
+
+		try
+		{
+			dynamic_cast <RttiTest &> (rttiBaseRef);
+		}
+		catch (...)
+		{
+			throw TestFailed (SRC_POS);
+		}
+
+		// finally
+		TestFlag = false;
+		{
+			finally_do ({ TestFlag = true; });
+			if (TestFlag)
+				throw TestFailed (SRC_POS);
+		}
+		if (!TestFlag)
+			throw TestFailed (SRC_POS);
+
+		TestFlag = false;
+		{
+			finally_do_arg (bool*, &TestFlag, { *finally_arg = true; });
+			if (TestFlag)
+				throw TestFailed (SRC_POS);
+		}
+		if (!TestFlag)
+			throw TestFailed (SRC_POS);
+
+		TestFlag = false;
+		int tesFlag2 = 0;
+		{
+			finally_do_arg2 (bool*, &TestFlag, int*, &tesFlag2, { *finally_arg = true; *finally_arg2 = 2; });
+			if (TestFlag || tesFlag2 != 0)
+				throw TestFailed (SRC_POS);
+		}
+		if (!TestFlag || tesFlag2 != 2)
+			throw TestFailed (SRC_POS);
+
+		// uint64, vector, list, string, wstring, stringstream, wstringstream
+		// shared_ptr, make_shared, StringConverter, foreach
+		list <shared_ptr <uint64> > numList;
+		
+		numList.push_front (make_shared <uint64> (StringConverter::ToUInt64 (StringConverter::FromNumber ((uint64) 0xFFFFffffFFFFfffeULL))));
+		numList.push_front (make_shared <uint64> (StringConverter::ToUInt32 (StringConverter::GetTrailingNumber ("str2"))));
+		numList.push_front (make_shared <uint64> (3));
+
+		list <wstring> testList;
+		wstringstream wstream (L"test");
+		foreach_reverse_ref (uint64 n, numList)
+		{
+			wstream.str (L"");
+			wstream << L"str" << n;
+			testList.push_back (wstream.str());
+		}
+
+		stringstream sstream;
+		sstream << "dummy";
+		sstream.str ("");
+		sstream << "str18446744073709551614,str2" << " str" << StringConverter::Trim (StringConverter::ToSingle (L"\t 3 \r\n"));
+		foreach (const string &s, StringConverter::Split (sstream.str(), ", "))
+		{
+			if (testList.front() != StringConverter::ToWide (s))
+				throw TestFailed (SRC_POS);
+			testList.pop_front();
+		}
+
+		SerializerTest();
+		ThreadTest();
+
+		return true;
+	}
+
+	bool PlatformTest::TestFlag;
+}