![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to wraptest.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Synchronet] / sbbs / src / xpdev|
Return to wraptest.c CVS log | Up to [Synchronet] / sbbs / src / xpdev |
1.1 root 1: /* wraptest.c */
2:
3: /* Verification of cross-platform development wrappers */
4:
5: /* $Id: wraptest.c,v 1.44 2006/04/21 02:47:43 deuce Exp $ */
6:
7: #include <time.h> /* ctime */
8:
9: #include "genwrap.h"
10: #include "conwrap.h"
11: #include "dirwrap.h"
12: #include "filewrap.h"
13: #include "sockwrap.h"
14: #include "threadwrap.h"
15: #include "xpbeep.h"
16: #include "xpendian.h"
17:
18: #define LOCK_FNAME "test.fil"
19: #define LOCK_OFFSET 0
20: #define LOCK_LEN 4
21:
22: static void getkey(void);
23: static void sem_test_thread(void* arg);
24: static void sem_test_thread_block(void* arg);
25: static void sleep_test_thread(void* arg);
26: static void sopen_test_thread(void* arg);
27: static void sopen_child_thread(void* arg);
28: static void lock_test_thread(void* arg);
29:
30:
31: typedef struct {
32: sem_t parent_sem;
33: sem_t child_sem;
34: } thread_data_t;
35:
36: int main()
37: {
38: char str[128];
39: char compiler[128];
40: char fpath[MAX_PATH+1];
41: char* path = ".";
42: char* glob_pattern = "*wrap*";
43: int i;
44: int ch;
45: uint u;
46: time_t t;
47: glob_t g;
48: DIR* dir;
49: DIRENT* dirent;
50: thread_data_t thread_data;
51: int fd;
52: int fd2;
53: int canrelock=0;
54: clock_t ticks;
55:
56: /* Show platform details */
57: DESCRIBE_COMPILER(compiler);
58: printf("%-15s: %s\n","Platform",PLATFORM_DESC);
59: printf("%-15s: %s\n","Version",os_version(str));
60: printf("%-15s: %s\n","Compiler" ,compiler);
61: printf("%-15s: %d\n","Random Number",xp_random(1000));
62:
63: for(i=0;i<3;i++) {
64: if(_beginthread(
65: sopen_child_thread /* entry point */
66: ,0 /* stack size (0=auto) */
67: ,(void*)i /* data */
68: )==(unsigned long)-1)
69: printf("_beginthread failed\n");
70: else
71: SLEEP(1);
72: }
73: printf("Waiting for all sopen_child_threads to close...\n");
74: SLEEP(5000); /* wait for all threads to quit */
75:
76: /* Exclusive sopen test */
77: printf("\nsopen() test\n");
78: if((fd=sopen(LOCK_FNAME,O_RDWR|O_CREAT,SH_DENYRW,S_IREAD|S_IWRITE))==-1) {
79: perror(LOCK_FNAME);
80: return(errno);
81: }
82: printf("%s is opened with an exclusive (read/write) lock\n",LOCK_FNAME);
83: getkey();
84: if(_beginthread(
85: sopen_test_thread /* entry point */
86: ,0 /* stack size (0=auto) */
87: ,NULL /* data */
88: )==(unsigned long)-1)
89: printf("_beginthread failed\n");
90: else
91: SLEEP(1000);
92: close(fd);
93:
94: /* sopen()/lock test */
95: printf("\nlock() test\n");
96: if((fd=sopen(LOCK_FNAME,O_RDWR|O_CREAT,SH_DENYNO,S_IREAD|S_IWRITE))==-1) {
97: perror(LOCK_FNAME);
98: return(errno);
99: }
100: write(fd,"lock testing\n",LOCK_LEN);
101: if(lock(fd,LOCK_OFFSET,LOCK_LEN)==0)
102: printf("lock() succeeds\n");
103: else
104: printf("!FAILURE: lock() non-functional (or file already locked)\n");
105: if(lock(fd,LOCK_OFFSET,LOCK_LEN)==0) {
106: printf("!FAILURE: Subsequent lock of region was allowed (will skip some tests)\n");
107: canrelock=1;
108: }
109:
110: if(_beginthread(
111: lock_test_thread /* entry point */
112: ,0 /* stack size (0=auto) */
113: ,NULL /* data */
114: )==(unsigned long)-1)
115: printf("_beginthread failed\n");
116: else
117: SLEEP(1000);
118: if(canrelock)
119: printf("?? Skipping some tests due to inability to detect own locks\n");
120: else {
121: if(lock(fd,LOCK_OFFSET,LOCK_LEN))
122: printf("Locks in first thread survive open()/close() in other thread\n");
123: else
124: printf("!FAILURE: lock() in first thread lost by open()/close() in other thread\n");
125: if(lock(fd,LOCK_OFFSET+LOCK_LEN+1,LOCK_LEN))
126: printf("!FAILURE: file locking\n");
127: else
128: printf("Record locking\n");
129: }
130: if((fd2=sopen(LOCK_FNAME,O_RDWR,SH_DENYRW))==-1) {
131: printf("Cannot reopen SH_DENYRW while lock is held\n");
132: close(fd2);
133: }
134: else {
135: printf("!FAILURE: can reopen SH_DENYRW while lock is held\n");
136: }
137: if(unlock(fd,LOCK_OFFSET,LOCK_LEN))
138: printf("!FAILURE: unlock() non-functional\n");
139: if(lock(fd,LOCK_OFFSET+LOCK_LEN+1,LOCK_LEN))
140: printf("Cannot re-lock after non-overlapping unlock()\n");
141: else
142: printf("!FAILURE: can re-lock after non-overlappping unlock()\n");
143: if(lock(fd,LOCK_OFFSET,LOCK_LEN))
144: printf("!FAILURE: cannot re-lock unlocked area\n");
145: close(fd);
146:
147: /* getch test */
148: printf("\ngetch() test (ESC to continue)\n");
149: do {
150: ch=getch();
151: printf("getch() returned %d\n",ch);
152: } while(ch!=ESC);
153:
154: /* kbhit test */
155: printf("\nkbhit() test (any key to continue)\n");
156: while(!kbhit()) {
157: printf(".");
158: fflush(stdout);
159: SLEEP(500);
160: }
161: getch(); /* remove character from keyboard buffer */
162:
163: /* BEEP test */
164: printf("\nBEEP() test\n");
165: getkey();
166: for(i=750;i>250;i-=5)
167: BEEP(i,15);
168: for(;i<1000;i+=5)
169: BEEP(i,15);
170:
171: /* SLEEP test */
172: printf("\nSLEEP(5 second) test\n");
173: getkey();
174: t=time(NULL);
175: printf("sleeping... ");
176: fflush(stdout);
177: ticks=msclock();
178: SLEEP(5000);
179: printf("slept %ld seconds (%ld according to msclock)\n",time(NULL)-t,(msclock()-ticks)/MSCLOCKS_PER_SEC);
180:
181: /* Thread SLEEP test */
182: printf("\nThread SLEEP(5 second) test\n");
183: getkey();
184: i=0;
185: if(_beginthread(
186: sleep_test_thread /* entry point */
187: ,0 /* stack size (0=auto) */
188: ,&i /* data */
189: )==(unsigned long)-1)
190: printf("_beginthread failed\n");
191: else {
192: SLEEP(1); /* yield to child thread */
193: while(i==0) {
194: printf(".");
195: fflush(stdout);
196: SLEEP(1000);
197: }
198: }
199:
200: /* glob test */
201: printf("\nglob(%s) test\n",glob_pattern);
202: getkey();
203: i=glob(glob_pattern,GLOB_MARK,NULL,&g);
204: if(i==0) {
205: for(u=0;u<g.gl_pathc;u++)
206: printf("%s\n",g.gl_pathv[u]);
207: globfree(&g);
208: } else
209: printf("glob(%s) returned %d\n",glob_pattern,i);
210:
211: /* opendir (and other directory functions) test */
212: printf("\nopendir(%s) test\n",path);
213: getkey();
214: printf("\nDirectory of %s\n\n",FULLPATH(fpath,path,sizeof(fpath)));
215: dir=opendir(path);
216: while(dir!=NULL && (dirent=readdir(dir))!=NULL) {
217: t=fdate(dirent->d_name);
218: printf("%.24s %10lu %06o %s%c\n"
219: ,ctime(&t)
220: ,flength(dirent->d_name)
221: ,getfattr(dirent->d_name)
222: ,dirent->d_name
223: ,isdir(dirent->d_name) ? '/':0
224: );
225: }
226: if(dir!=NULL)
227: closedir(dir);
228: printf("\nFree disk space: %lu kbytes\n",getfreediskspace(path,1024));
229:
230: /* Thread (and inter-process communication) test */
231: printf("\nSemaphore test\n");
232: getkey();
233: if(sem_init(&thread_data.parent_sem
234: ,0 /* shared between processes */
235: ,0 /* initial count */
236: )) {
237: printf("sem_init failed\n");
238: }
239: if(sem_init(&thread_data.child_sem
240: ,0 /* shared between processes */
241: ,0 /* initial count */
242: )) {
243: printf("sem_init failed\n");
244: }
245: if(_beginthread(
246: sem_test_thread /* entry point */
247: ,0 /* stack size (0=auto) */
248: ,&thread_data /* data */
249: )==(unsigned long)-1)
250: printf("_beginthread failed\n");
251: else {
252: sem_wait(&thread_data.child_sem); /* wait for thread to begin */
253: for(i=0;i<10;i++) {
254: printf("<parent>");
255: sem_post(&thread_data.parent_sem);
256: sem_wait(&thread_data.child_sem);
257: }
258: sem_wait(&thread_data.child_sem); /* wait for thread to end */
259: }
260: sem_destroy(&thread_data.parent_sem);
261: sem_destroy(&thread_data.child_sem);
262:
263: printf("\nSemaphore blocking test\n");
264: getkey();
265: sem_init(&thread_data.parent_sem
266: ,0 /* shared between processes */
267: ,0 /* initial count */
268: );
269: sem_init(&thread_data.child_sem
270: ,0 /* shared between processes */
271: ,0 /* initial count */
272: );
273: if(_beginthread(
274: sem_test_thread_block /* entry point */
275: ,0 /* stack size (0=auto) */
276: ,&thread_data /* data */
277: )==(unsigned long)-1)
278: printf("_beginthread failed\n");
279: else {
280: sem_wait(&thread_data.child_sem); /* wait for thread to begin */
281: for(i=0;i<10;i++) {
282: printf("<parent>");
283: SLEEP(5000);
284: sem_post(&thread_data.parent_sem);
285: sem_wait(&thread_data.child_sem);
286: }
287: sem_wait(&thread_data.child_sem); /* wait for thread to end */
288: }
289: printf("\nsem_trywait_block test...");
290: t=time(NULL);
291: sem_trywait_block(&thread_data.parent_sem,5000);
292: printf("\ntimed-out after %ld seconds (should be 5 seconds)\n",time(NULL)-t);
293: sem_destroy(&thread_data.parent_sem);
294: sem_destroy(&thread_data.child_sem);
295: printf("\nendian check...");
296: memcpy(&i,"\x01\x02\x03\x04",4);
297: if(LE_LONG(i)==67305985) {
298: printf("OK!\n");
299: }
300: else {
301: printf("FAILED!\n");
302: }
303: return 0;
304: }
305:
306: static void getkey(void)
307: {
308: printf("Hit any key to continue...");
309: fflush(stdout);
310: getch();
311: printf("\r%30s\r","");
312: fflush(stdout);
313: }
314:
315: static void sleep_test_thread(void* arg)
316: {
317: time_t t=time(NULL);
318: printf("child sleeping");
319: fflush(stdout);
320: SLEEP(5000);
321: printf("\nchild awake after %ld seconds\n",time(NULL)-t);
322:
323: *(int*)arg=1; /* signal parent: we're done */
324: }
325:
326: static void sem_test_thread(void* arg)
327: {
328: ulong i;
329: thread_data_t* data = (thread_data_t*)arg;
330:
331: printf("sem_test_thread entry\n");
332: sem_post(&data->child_sem); /* signal parent: we've started */
333:
334: for(i=0;i<10;i++) {
335: sem_wait(&data->parent_sem);
336: printf(" <child>\n");
337: sem_post(&data->child_sem);
338: }
339:
340: printf("sem_test_thread exit\n");
341: sem_post(&data->child_sem); /* signal parent: we're done */
342: }
343:
344: static void sem_test_thread_block(void* arg)
345: {
346: ulong i;
347: thread_data_t* data = (thread_data_t*)arg;
348:
349: printf("sem_test_thread_block entry\n");
350: sem_post(&data->child_sem); /* signal parent: we've started */
351:
352: for(i=0;i<10;i++) {
353: if(sem_trywait_block(&data->parent_sem,500)) {
354: printf(" sem_trywait_block() timed out");
355: sem_wait(&data->parent_sem);
356: }
357: else {
358: printf(" FAILURE: Didn't block");
359: }
360: printf(" <child>\n");
361: sem_post(&data->child_sem);
362: }
363:
364: printf("sem_test_thread_block exit\n");
365: sem_post(&data->child_sem); /* signal parent: we're done */
366: }
367:
368: static void lock_test_thread(void* arg)
369: {
370: int fd;
371:
372: fd=sopen(LOCK_FNAME,O_RDWR,SH_DENYNO);
373: if(lock(fd,LOCK_OFFSET,LOCK_LEN)==0)
374: printf("!FAILURE: Lock not effective between threads\n");
375: else
376: printf("Locks effective between threads\n");
377: close(fd);
378: fd=sopen(LOCK_FNAME,O_RDWR,SH_DENYNO);
379: if(lock(fd,LOCK_OFFSET,LOCK_LEN))
380: printf("Locks survive file open()/close() in other thread\n");
381: else
382: printf("!FAILURE: Locks do not survive file open()/close() in other thread\n");
383: close(fd);
384: }
385:
386: static void sopen_test_thread(void* arg)
387: {
388: int fd;
389:
390: if((fd=sopen(LOCK_FNAME,O_RDWR,SH_DENYWR))!=-1)
391: printf("!FAILURE: allowed to reopen with SH_DENYWR\n");
392: else if((fd=sopen(LOCK_FNAME,O_RDWR,SH_DENYRW))!=-1)
393: printf("!FAILURE: allowed to reopen with SH_DENYRW\n");
394: else
395: printf("reopen disallowed\n");
396:
397: if(fd!=-1)
398: close(fd);
399: }
400:
401: static void sopen_child_thread(void* arg)
402: {
403: int fd;
404:
405: printf("sopen_child_thread: %d begin\n",(int)arg);
406: if((fd=sopen(LOCK_FNAME,O_RDWR,SH_DENYRW))!=-1) {
407: if(arg)
408: printf("!FAILURE: was able to reopen in child thread\n");
409: else {
410: SLEEP(5000);
411: }
412: close(fd);
413: } else if(arg==0)
414: perror(LOCK_FNAME);
415: printf("sopen_child_thread: %d end\n",(int)arg);
416: }
417:
418: /* End of wraptest.c */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.