root/lang/objective-cplusplus/i3/trunk/src/mil/src/Test1.cpp @ 33762

Revision 33762, 12.8 kB (checked in by saturday06, 5 years ago)

sineeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeaioesgsmbdfik

Line 
1#include <mil/PrecompiledHeaders.h>
2#include <boost/test/unit_test.hpp>
3
4
5int global = 0;
6
7
8/* ---------------------------------------
9   select test
10   --------------------------------------- */
11
12//#define def_test_FMTQueue
13//#define def_test_TSTL
14//#define def_test_fast_pool_allocator
15#define def_test_Module
16#define def_test_Thread
17
18/* ---------------------------------------
19   test cases
20   --------------------------------------- */
21
22
23#ifdef def_test_Module
24
25#include <mil/Module.h>
26
27#if defined(MIL_GUI_WINDOWS)
28#  include <mil/gui-windows/GuiModule.h>
29#elif defined(MIL_GUI_COCOA)
30#  include <mil/gui-cocoa/GuiModule.h>
31#else
32#  include <mil/gui-cocoa/GuiModule.h>
33#endif
34
35namespace ns_test_Module
36{
37using namespace mil;
38
39struct FooEvent
40{
41    int value;
42};
43
44struct BarEvent
45{
46    int value;
47    int padding;
48};
49
50struct InfinityIncEvent
51{
52};
53
54struct Plus5
55{
56    int pad[5];
57};
58
59struct Minus3
60{
61};
62
63struct Plus5_3Times
64{
65    int count;
66    Plus5_3Times() : count(0)
67    {
68    }
69};
70
71struct Destroy
72{
73};
74
75struct AppendString
76{
77    std::string* str;
78    void* pad[5];
79};
80
81struct FooModule : mil::Module<FooModule>
82{
83    void run()
84    {
85        loop();
86    }
87    std::string str;
88    void execute(AppendString& e)
89    {
90        str += *(e.str);
91        delete e.str;
92    }
93
94    void execute(FooEvent& e)
95    {
96        global = e.value;
97        repostEvent();
98    }
99    void execute(BarEvent& e)
100    {
101        global = e.value;
102    }
103    void execute(InfinityIncEvent& i)
104    {
105        global++;
106        repostEvent();
107    }
108    void execute(Plus5& e)
109    {
110        global += 5;
111    }
112    void execute(Minus3& e)
113    {
114        global -= 3;
115    }
116    void execute(Plus5_3Times& e)
117    {
118        e.count++;
119        if (e.count <= 3)
120        {
121            global += 5;
122            repostEvent();
123        }
124    }
125    void execute(Destroy& e)
126    {
127        destroy();
128    }
129};
130struct FooGuiModule : mil::GuiModule<FooGuiModule>
131{
132    void run()
133    {
134                createUI();
135        loop();
136    }
137    std::string str;
138    void execute(AppendString& e)
139    {
140        str += *(e.str);
141        delete e.str;
142    }
143
144    void createUI()
145    {
146#ifdef MIL_GUI_WINDOWS
147        HINSTANCE hInstance = GetModuleHandle(NULL);
148        const TCHAR ClassName[] = _T("GuiModuleTestajiodjrfau89a");
149        int nCmdShow = SW_SHOW;
150
151        WNDCLASSEX wc;
152        wc.cbSize        = sizeof(WNDCLASSEX);
153        wc.style         = CS_HREDRAW | CS_VREDRAW | WS_OVERLAPPED;
154        wc.lpfnWndProc   = DefWindowProc;
155        wc.cbClsExtra    = 0;
156        wc.cbWndExtra    = 0;
157        wc.hInstance     = hInstance;
158        wc.hIcon         = NULL;
159        wc.hCursor       = LoadCursor(NULL, IDC_ARROW);
160        wc.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
161        wc.lpszMenuName  = NULL;
162        wc.lpszClassName = ClassName;
163        wc.hIconSm       = NULL;
164
165        RegisterClassEx(&wc);
166
167        HWND hWnd = CreateWindowEx(
168                        0, ClassName, _T("GuiModule Test"), WS_OVERLAPPEDWINDOW, CW_USEDEFAULT,
169                        CW_USEDEFAULT,200,50,NULL,NULL,hInstance,NULL
170                    );
171        assert(IsWindow(hWnd));
172        setWindow(hWnd);
173
174        ShowWindow(hWnd, nCmdShow);
175        UpdateWindow(hWnd);
176        wndproc.set(hWnd);
177#endif
178    }
179
180    void execute(FooEvent& e)
181    {
182        global = e.value;
183        repostEvent();
184    }
185
186    void execute(BarEvent& e)
187    {
188        global = e.value;
189    }
190    void execute(InfinityIncEvent& i)
191    {
192        global++;
193        repostEvent();
194    }
195    void execute(Plus5& e)
196    {
197        global += 5;
198    }
199    void execute(Minus3& e)
200    {
201        global -= 3;
202    }
203    void execute(Plus5_3Times& e)
204    {
205        e.count++;
206        if (e.count <= 3)
207        {
208            global += 5;
209            repostEvent();
210        }
211    }
212    void execute(Destroy& e)
213    {
214        destroy();
215    }
216};
217
218struct FooSingleThreadedGuiModule : public FooGuiModule {
219        FooSingleThreadedGuiModule() {
220                createUI();
221        }
222};
223
224template <typename TestModuleType>
225void test()
226{
227    {
228        global = 0;
229        TestModuleType m;
230        FooEvent e = {100};
231        m.post(e, m);
232        m.execute_front();
233        BOOST_REQUIRE(global == 100);
234    }
235
236    {
237        global = 0;
238        TestModuleType m;
239        FooEvent e = {50};
240        m.post(e, m);
241        m.execute_front();
242        BOOST_REQUIRE(global == 50);
243    }
244
245    {
246        global = 0;
247        TestModuleType m;
248        FooEvent e = {-1};
249        m.post(e, m);
250        m.execute_front();
251        BOOST_REQUIRE(global == -1);
252    }
253
254    {
255        global = 0;
256        TestModuleType m;
257        InfinityIncEvent i;
258        m.post(i, m);
259        m.execute_front();
260        BOOST_REQUIRE(global == 1);
261    }
262
263    {
264        TestModuleType m;
265        FooEvent e = {100};
266        m.post(e, m);
267        global = 0;
268        m.execute_front();
269        BOOST_REQUIRE(global == 100);
270        global = 0;
271        m.execute_front();
272        BOOST_REQUIRE(global == 100);
273    }
274   
275    {
276        global = 0;
277        TestModuleType m;
278        InfinityIncEvent i;
279        m.post(i, m);
280        m.execute_front();
281        m.execute_front();
282        m.execute_front();
283        BOOST_REQUIRE(global == 3);
284    }
285    {
286        global = 0;
287        TestModuleType foo;
288        Plus5 p;
289        InfinityIncEvent i;
290        Minus3 m;
291        foo.post(p, foo);
292        foo.post(p, foo);
293        foo.post(m, foo);
294        foo.post(i, foo);
295        foo.post(p, foo);
296        foo.post(i, foo);
297
298        foo.execute_front();
299        BOOST_REQUIRE(global == 5);
300        foo.execute_front();
301        BOOST_REQUIRE(global == 10);
302        foo.execute_front();
303        BOOST_REQUIRE(global == 7);
304        foo.execute_front();
305        BOOST_REQUIRE(global == 8);
306        foo.execute_front();
307        BOOST_REQUIRE(global == 13);
308        foo.execute_front();
309        BOOST_REQUIRE(global == 14);
310        foo.execute_front();
311        BOOST_REQUIRE(global == 15);
312        foo.execute_front();
313        BOOST_REQUIRE(global == 16);
314        foo.execute_front();
315        BOOST_REQUIRE(global == 17);
316    }
317    {
318        global = 3;
319        TestModuleType foo;
320
321        AppendString s1;
322        s1.str = new std::string("foo");
323        foo.post(s1, foo);
324        foo.execute_front();
325        BOOST_REQUIRE(foo.str == "foo");
326        Plus5_3Times p5_3;
327        foo.post(p5_3, foo);
328        BOOST_REQUIRE(global == 3);
329        foo.execute_front();
330        BOOST_REQUIRE(global == 8);
331        foo.execute_front();
332        BOOST_REQUIRE(global == 13);
333        foo.execute_front();
334        BOOST_REQUIRE(global == 18);
335        foo.execute_front();
336        BOOST_REQUIRE(global == 18);
337        foo.execute_front();
338        BOOST_REQUIRE(global == 18);
339        AppendString s2;
340        s2.str = new std::string("bar");
341        foo.post(s2, foo);
342        foo.execute_front();
343        BOOST_REQUIRE(foo.str == "foobar");
344    }
345   
346}
347
348}
349BOOST_AUTO_TEST_CASE(test_Module)
350{
351    using namespace ns_test_Module;
352    test<FooModule>();
353    test<FooSingleThreadedGuiModule>();
354}
355
356
357#endif
358
359#ifdef def_test_Thread
360#include <mil/Thread.h>
361
362namespace ns_test_Thread {
363
364template <typename TestModuleType>
365void test()
366{
367    using namespace mil;
368    using namespace ns_test_Module;
369   
370    {
371        TestModuleType m;
372        FooEvent e = {100};
373        m.post(e, m);
374        global = 0;
375        m.execute_front();
376        BOOST_REQUIRE(global == 100);
377        global = 0;
378        m.execute_front();
379        BOOST_REQUIRE(global == 100);
380    }
381    {
382        global = 0;
383        TestModuleType m;
384        InfinityIncEvent i;
385        m.post(i, m);
386        m.execute_front();
387        m.execute_front();
388        m.execute_front();
389        BOOST_REQUIRE(global == 3);
390    }
391    {
392        global = 0;
393        TestModuleType foo;
394        Plus5 p;
395        InfinityIncEvent i;
396        Minus3 m;
397        foo.post(p, foo);
398        foo.post(p, foo);
399        foo.post(m, foo);
400        foo.post(i, foo);
401        foo.post(p, foo);
402        foo.post(i, foo);
403
404        foo.execute_front();
405        BOOST_REQUIRE(global == 5);
406        foo.execute_front();
407        BOOST_REQUIRE(global == 10);
408        foo.execute_front();
409        BOOST_REQUIRE(global == 7);
410        foo.execute_front();
411        BOOST_REQUIRE(global == 8);
412        foo.execute_front();
413        BOOST_REQUIRE(global == 13);
414        foo.execute_front();
415        BOOST_REQUIRE(global == 14);
416        foo.execute_front();
417        BOOST_REQUIRE(global == 15);
418        foo.execute_front();
419        BOOST_REQUIRE(global == 16);
420        foo.execute_front();
421        BOOST_REQUIRE(global == 17);
422    }
423    {
424        mil::Tls tls(0);
425        global = 3;
426        TestModuleType foo;
427        Plus5_3Times p5_3;
428        foo.post(p5_3, foo);
429        BOOST_REQUIRE(global == 3);
430        foo.execute_front();
431        BOOST_REQUIRE(global == 8);
432        foo.execute_front();
433        BOOST_REQUIRE(global == 13);
434        foo.execute_front();
435        BOOST_REQUIRE(global == 18);
436        foo.execute_front();
437        BOOST_REQUIRE(global == 18);
438        foo.execute_front();
439        BOOST_REQUIRE(global == 18);
440    }
441}
442
443
444
445template <typename TestModuleType>
446void ttest2()
447{
448    using namespace mil;
449    using namespace ns_test_Module;
450   
451    {
452        TestModuleType t;
453    }
454
455    {
456        TestModuleType t;
457        t.start();
458    }
459
460    {
461        global = 0;
462        TestModuleType t;
463        Plus5 e;
464        t.start();
465                sleep(1);
466        t.post(e, t);
467                sleep(1);
468        BOOST_REQUIRE(global == 5);
469    }
470
471    {
472        global = 0;
473        TestModuleType t;
474        Plus5 e;
475        t.start();
476                sleep(1);
477        for (int i = 0; i < 50; i++) {
478            t.post(e, t);
479        }
480                sleep(1);
481        BOOST_REQUIRE(global == 50 * 5);
482    }
483
484    {
485        global = 0;
486        TestModuleType t1;
487        TestModuleType t2;
488        Plus5 e;
489        t1.start();
490                sleep(1);
491        for (int i = 0; i < 50; i++) {
492            t1.post(e, t2);
493        }
494                sleep(1);
495        BOOST_REQUIRE(global == 50 * 5);
496        global = 0;
497        t2.start();
498                sleep(1);
499        for (int i = 0; i < 60; i++) {
500            t2.post(e, t1);
501        }
502                sleep(1);
503        BOOST_REQUIRE(global == 60 * 5);
504    }
505}
506
507BOOST_AUTO_TEST_CASE(test_Thread)
508{
509        using namespace ns_test_Thread;
510        using namespace ns_test_Module;
511    test<FooModule>();
512    test<FooSingleThreadedGuiModule>();
513
514    ttest2<FooModule>();
515    ttest2<FooGuiModule>();
516    BOOST_CHECK(true);
517}
518}
519
520#endif
521
522#ifdef def_test_fast_pool_allocator
523#include <boost/thread.hpp>
524#include <boost/thread/mutex.hpp>
525#include <boost/intrusive/slist.hpp>
526#include <boost/intrusive/slist_hook.hpp>
527#include <boost/intrusive/list.hpp>
528#include <boost/intrusive/list_hook.hpp>
529#include <boost/pool/object_pool.hpp>
530#include <boost/pool/pool.hpp>
531#include <boost/pool/singleton_pool.hpp>
532#include <boost/pool/pool_alloc.hpp>
533
534boost::details::pool::default_mutex m;
535boost::mutex m2;
536
537class Foo : public boost::intrusive::slist_base_hook<>
538{
539public:
540    int value;
541};
542class MyObject
543            : public boost::intrusive::slist_base_hook<>
544{
545public:
546    MyObject(int v) : value(v) {}
547    int value;
548};
549BOOST_AUTO_TEST_CASE(test_fast_pool_allocator)
550//int main()
551{
552    //std::list<int, boost::fast_pool_allocator<int> > l;
553    //l.push_back(100);
554    //BOOST_CHECK(l.front() == 100);
555    //int i = rand();
556    //l.push_back(i);
557    //BOOST_CHECK(l.back() == i);
558    //BOOST_CHECK(l.front() == 100);
559    //l.pop_back();
560    //BOOST_CHECK(l.back() == 100);
561
562    MyObject* pa;
563    {
564        boost::details::pool::guard<boost::details::pool::default_mutex> g(m);
565        //boost::mutex::scoped_lock lk(m2);
566        pa = new MyObject(100);
567    }
568    {
569        boost::intrusive::slist<MyObject> l;
570        l.push_front(*pa);
571        //l.push_back(*f);
572        char aaa[sizeof(l)+1] = {};
573        memcpy(aaa, (char*)&l, sizeof(l));
574        printf("TEST %s TEST\n", aaa);
575    }
576    {
577        //boost::mutex::scoped_lock lk(m2);
578        boost::details::pool::guard<boost::details::pool::default_mutex> g(m);
579        delete pa;
580    }
581}
582#endif
583
584#ifdef def_test_TSTL
585
586#include <TSTL/TSTL.h>
587#include <TSTL/queue.h>
588
589BOOST_AUTO_TEST_CASE(test_TSTL)
590{
591    Queue<int> q;
592}
593#endif
594
595#ifdef def_test_FMTQueue
596
597#include <fecti/config.h>
598#include <fecti/Utility/FMTQueue.h>
599
600BOOST_AUTO_TEST_CASE(test_FMTQueue)
601{
602    fecti::util::FMTQueue<int> queue(10);
603    queue.push(100);
604    int j = 0;
605    queue.pop(&j);
606    BOOST_CHECK(j == 100);
607
608    int i = rand();
609    queue.push(i);
610    queue.pop(&j);
611    BOOST_CHECK(j == i);
612}
613
614#endif
Note: See TracBrowser for help on using the browser.