![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to platformtest.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [truecrypt] / truecrypt / platform|
Return to platformtest.cpp CVS log | Up to [truecrypt] / truecrypt / platform |
1.1 root 1: /*
2: Copyright (c) 2008 TrueCrypt Foundation. All rights reserved.
3:
4: Governed by the TrueCrypt License 2.4 the full text of which is contained
5: in the file License.txt included in TrueCrypt binary and source code
6: distribution packages.
7: */
8:
9: #include "PlatformTest.h"
10: #include "Exception.h"
11: #include "FileStream.h"
12: #include "Finally.h"
13: #include "ForEach.h"
14: #include "MemoryStream.h"
15: #include "Mutex.h"
16: #include "Serializable.h"
17: #include "SharedPtr.h"
18: #include "StringConverter.h"
19: #include "Thread.h"
20:
21: namespace TrueCrypt
22: {
23: // make_shared_auto, File, Stream, MemoryStream, Endian, Serializer, Serializable
24: void PlatformTest::SerializerTest ()
25: {
26: shared_ptr <Stream> stream (new MemoryStream);
27:
28: #if 0
29: make_shared_auto (File, file);
30: finally_do_arg (File&, *file, { if (finally_arg.IsOpen()) finally_arg.Delete(); });
31:
32: try
33: {
34: file->Open ("truecrypt-serializer-test.tmp", File::CreateReadWrite);
35: stream = shared_ptr <Stream> (new FileStream (file));
36: }
37: catch (...) { }
38: #endif
39:
40: Serializer ser (stream);
41:
42: uint32 i32 = 0x12345678;
43: uint64 i64 = 0x0123456789abcdefULL;
44: string str = "string test";
45: wstring wstr = L"wstring test";
46:
47: list <string> stringList;
48: stringList.push_back (str + "1");
49: stringList.push_back (str + "2");
50: stringList.push_back (str + "3");
51:
52: list <wstring> wstringList;
53: wstringList.push_back (wstr + L"1");
54: wstringList.push_back (wstr + L"2");
55: wstringList.push_back (wstr + L"3");
56:
57: Buffer buffer (10);
58: for (size_t i = 0; i < buffer.Size(); i++)
59: buffer[i] = (byte) i;
60:
61: ser.Serialize ("int32", i32);
62: ser.Serialize ("int64", i64);
63: ser.Serialize ("string", str);
64: ser.Serialize ("wstring", wstr);
65: ser.Serialize ("stringList", stringList);
66: ser.Serialize ("wstringList", wstringList);
67: ser.Serialize ("buffer", ConstBufferPtr (buffer));
68:
69: ExecutedProcessFailed ex (SRC_POS, "cmd", -123, "error output");
70: ex.Serialize (stream);
71:
72: list < shared_ptr <ExecutedProcessFailed> > exList;
73: exList.push_back (make_shared <ExecutedProcessFailed> (ExecutedProcessFailed (SRC_POS, "cmd", -123, "error output1")));
74: exList.push_back (make_shared <ExecutedProcessFailed> (ExecutedProcessFailed (SRC_POS, "cmd", -234, "error output2")));
75: exList.push_back (make_shared <ExecutedProcessFailed> (ExecutedProcessFailed (SRC_POS, "cmd", -567, "error output3")));
76: Serializable::SerializeList (stream, exList);
77:
78: #if 0
79: if (file->IsOpen())
80: file->SeekAt (0);
81: #endif
82:
83: uint32 di32;
84: ser.Deserialize ("int32", di32);
85: if (i32 != di32)
86: throw TestFailed (SRC_POS);
87:
88: uint64 di64;
89: ser.Deserialize ("int64", di64);
90: if (i64 != di64)
91: throw TestFailed (SRC_POS);
92:
93: string dstr;
94: ser.Deserialize ("string", dstr);
95: if (str != dstr)
96: throw TestFailed (SRC_POS);
97:
98: wstring dwstr;
99: ser.Deserialize ("wstring", dwstr);
100: if (str != dstr)
101: throw TestFailed (SRC_POS);
102:
103: int i = 1;
104: foreach (string item, ser.DeserializeStringList ("stringList"))
105: {
106: stringstream s;
107: s << str << i++;
108: if (item != s.str())
109: throw TestFailed (SRC_POS);
110: }
111:
112: i = 1;
113: foreach (wstring item, ser.DeserializeWStringList ("wstringList"))
114: {
115: wstringstream s;
116: s << wstr << i++;
117: if (item != s.str())
118: throw TestFailed (SRC_POS);
119: }
120:
121: Buffer dbuffer (10);
122: ser.Deserialize ("buffer", buffer);
123: for (size_t i = 0; i < buffer.Size(); i++)
124: if (buffer[i] != (byte) i)
125: throw TestFailed (SRC_POS);
126:
127: shared_ptr <ExecutedProcessFailed> dex = Serializable::DeserializeNew <ExecutedProcessFailed> (stream);
128: if (!dex
129: || dex->GetCommand() != "cmd"
130: || dex->GetExitCode() != -123
131: || dex->GetErrorOutput() != "error output")
132: throw TestFailed (SRC_POS);
133:
134: list < shared_ptr <ExecutedProcessFailed> > dexList;
135: Serializable::DeserializeList (stream, dexList);
136: i = 1;
137: foreach_ref (const ExecutedProcessFailed &ex, dexList)
138: {
139: stringstream s;
140: s << "error output" << i++;
141: if (ex.GetErrorOutput() != s.str())
142: throw TestFailed (SRC_POS);
143: }
144: }
145:
146: // shared_ptr, Mutex, ScopeLock, Thread
147: void PlatformTest::ThreadTest ()
148: {
149: Mutex mutex;
150: mutex.Lock();
151: mutex.Unlock();
152:
153: const int maxThreads = 3;
154: make_shared_auto (int, SharedIntPtr);
155: *SharedIntPtr = 0;
156:
157: for (int i = 0; i < maxThreads; i++)
158: {
159: Thread t;
160: t.Start (&ThreadTestProc, (void *)&SharedIntPtr);
161: }
162:
163: for (int i = 0; i < 50; i++)
164: {
165: if (SharedIntPtr.use_count() == 1 && *SharedIntPtr == maxThreads)
166: break;
167:
168: Thread::Sleep(100);
169: }
170:
171: if (SharedIntPtr.use_count() != 1 || *SharedIntPtr != maxThreads)
172: throw TestFailed (SRC_POS);
173: }
174:
175: TC_THREAD_PROC PlatformTest::ThreadTestProc (void *param)
176: {
177: static Mutex mutex;
178: shared_ptr <int> sharedIntPtr = *(shared_ptr <int> *) param;
179:
180: {
181: ScopeLock sl (mutex);
182: (*sharedIntPtr)++;
183: }
184:
185: return 0;
186: }
187:
188: bool PlatformTest::TestAll ()
189: {
190: // Integer types
191: if (sizeof (byte) != 1 || sizeof (int8) != 1 || sizeof (__int8) != 1) throw TestFailed (SRC_POS);
192: if (sizeof (uint16) != 2 || sizeof (int16) != 2 || sizeof (__int16) != 2) throw TestFailed (SRC_POS);
193: if (sizeof (uint32) != 4 || sizeof (int32) != 4 || sizeof (__int32) != 4) throw TestFailed (SRC_POS);
194: if (sizeof (uint64) != 8 || sizeof (int64) != 8 || sizeof (__int64) != 8) throw TestFailed (SRC_POS);
195:
196: // Exception handling
197: TestFlag = false;
198: try
199: {
200: try
201: {
202: throw TestFailed (SRC_POS);
203: }
204: catch (...)
205: {
206: throw;
207: }
208: return false;
209: }
210: catch (Exception &)
211: {
212: TestFlag = true;
213: }
214: if (!TestFlag)
215: return false;
216:
217: // RTTI
218: RttiTest rtti;
219: RttiTestBase &rttiBaseRef = rtti;
220: RttiTestBase *rttiBasePtr = &rtti;
221:
222: if (typeid (rttiBaseRef) != typeid (rtti))
223: throw TestFailed (SRC_POS);
224:
225: if (typeid (*rttiBasePtr) != typeid (rtti))
226: throw TestFailed (SRC_POS);
227:
228: if (dynamic_cast <RttiTest *> (rttiBasePtr) == nullptr)
229: throw TestFailed (SRC_POS);
230:
231: try
232: {
233: dynamic_cast <RttiTest &> (rttiBaseRef);
234: }
235: catch (...)
236: {
237: throw TestFailed (SRC_POS);
238: }
239:
240: // finally
241: TestFlag = false;
242: {
243: finally_do ({ TestFlag = true; });
244: if (TestFlag)
245: throw TestFailed (SRC_POS);
246: }
247: if (!TestFlag)
248: throw TestFailed (SRC_POS);
249:
250: TestFlag = false;
251: {
252: finally_do_arg (bool&, TestFlag, { finally_arg = true; });
253: if (TestFlag)
254: throw TestFailed (SRC_POS);
255: }
256: if (!TestFlag)
257: throw TestFailed (SRC_POS);
258:
259: TestFlag = false;
260: int tesFlag2 = 0;
261: {
262: finally_do_arg2 (bool&, TestFlag, int&, tesFlag2, { finally_arg = true; finally_arg2 = 2; });
263: if (TestFlag || tesFlag2 != 0)
264: throw TestFailed (SRC_POS);
265: }
266: if (!TestFlag || tesFlag2 != 2)
267: throw TestFailed (SRC_POS);
268:
269: // uint64, vector, list, string, wstring, stringstream, wstringstream
270: // shared_ptr, make_shared, StringConverter, foreach
271: list <shared_ptr <uint64> > numList;
272:
273: numList.push_front (make_shared <uint64> (StringConverter::ToUInt64 (StringConverter::FromNumber (0xFFFFffffFFFFfffeULL))));
274: numList.push_front (make_shared <uint64> (StringConverter::ToUInt32 (StringConverter::GetTrailingNumber ("str2"))));
275: numList.push_front (make_shared <uint64> (3));
276:
277: list <wstring> testList;
278: wstringstream wstream (L"test");
279: foreach_reverse_ref (uint64 n, numList)
280: {
281: wstream.str (L"");
282: wstream << L"str" << n;
283: testList.push_back (wstream.str());
284: }
285:
286: stringstream sstream;
287: sstream << "dummy";
288: sstream.str ("");
289: sstream << "str18446744073709551614,str2" << " str" << StringConverter::Trim (StringConverter::ToSingle (L"\t 3 \r\n"));
290: foreach (const string &s, StringConverter::Split (sstream.str(), ", "))
291: {
292: if (testList.front() != StringConverter::ToWide (s))
293: throw TestFailed (SRC_POS);
294: testList.pop_front();
295: }
296:
297: SerializerTest();
298: ThreadTest();
299:
300: return true;
301: }
302:
303: bool PlatformTest::TestFlag;
304: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.