home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 177.lha / DRes_v1.3 / util / test.c < prev    next >
Encoding:
C/C++ Source or Header  |  1988-04-28  |  8.2 KB  |  320 lines
  1.  
  2. /*
  3.  *  TEST.C
  4.  *
  5.  *  Test Library Functions.
  6.  */
  7.  
  8. #include <typedefs.h>
  9. #include <stdio.h>
  10.  
  11. typedef struct Library LIB;
  12.  
  13. LIST ListA;
  14. LIST ListB;
  15. NODE Node1;
  16. NODE Node2;
  17. NODE Node3;
  18. short Glob;
  19.  
  20. extern int Enable_Abort;
  21.  
  22. LIB *DMiscSupportBase;
  23.  
  24. extern LIB *OpenLibrary();
  25. extern char *AllocMem();
  26. extern char *GetHead();
  27. extern char *GetTail();
  28. extern char *GetSucc();
  29. extern char *GetPred();
  30. extern char *GetHeadOff();
  31. extern char *GetTailOff();
  32. extern char *GetSuccOff();
  33. extern char *GetPredOff();
  34. extern long srch();
  35.  
  36. main()
  37. {
  38.     Enable_Abort = 0;
  39.     DMiscSupportBase = OpenLibrary("dmiscsup.library", 0);
  40.     if (!DMiscSupportBase) {
  41.     puts("Unable to open library");
  42.     exit(1);
  43.     }
  44.     printf("library at: %08lx\n", DMiscSupportBase);
  45.     printf("library flags: %02lx  Rev: %ld  OpenCnt: %ld\n",
  46.     DMiscSupportBase->lib_Flags,
  47.     DMiscSupportBase->lib_Revision,
  48.     DMiscSupportBase->lib_OpenCnt
  49.     );
  50.     NewList(&ListA);
  51.     NewList(&ListB);
  52.     AddTail(&ListA, &Node1);
  53.     AddTail(&ListA, &Node2);
  54.     AddTail(&ListA, &Node3);
  55.     printf("\nGetHead()         "); fflush(stdout);
  56.     results((NODE *)GetHead(&ListA) == &Node1);
  57.     results(GetHead(&ListB) == NULL);
  58.     printf("\nGetTail()         "); fflush(stdout);
  59.     results((NODE *)GetTail(&ListA) == &Node3);
  60.     results(GetTail(&ListB) == NULL);
  61.     printf("\nGetSucc()         "); fflush(stdout);
  62.     results((NODE *)GetSucc(&Node1) == &Node2);
  63.     results((NODE *)GetSucc(&Node3) == NULL);
  64.     printf("\nGetPred()         "); fflush(stdout);
  65.     results((NODE *)GetPred(&Node3) == &Node2);
  66.     results((NODE *)GetPred(&Node1) == NULL);
  67.     printf("\nGetHeadOff()      "); fflush(stdout);
  68.     results(GetHeadOff(&ListA, 3) == (char *)&Node1 - 3);
  69.     results(GetHeadOff(&ListB, 3) == NULL);
  70.     printf("\nGetTailOff()      "); fflush(stdout);
  71.     results(GetTailOff(&ListA, 3) == (char *)&Node3 - 3);
  72.     results(GetTailOff(&ListB, 3) == NULL);
  73.     printf("\nGetSuccOff()      "); fflush(stdout);
  74.     results(GetSuccOff((char *)&Node1 - 3, 3) == (char *)&Node2 - 3);
  75.     results(GetSuccOff((char *)&Node3 - 3, 3) == NULL);
  76.     printf("\nGetPredOff()      "); fflush(stdout);
  77.     results(GetPredOff((char *)&Node2 - 3, 3) == (char *)&Node1 - 3);
  78.     results(GetPredOff((char *)&Node1 - 3, 3) == NULL);
  79.     printf("\nSearchFwdNode()   "); fflush(stdout);
  80.     Glob = 0; SearchFwdNodeOff(NULL, srch, 3, 27); results(Glob == 0);
  81.     Glob = 0; SearchFwdNodeOff(GetHeadOff(&ListA, 3), srch, 3, 27); results(Glob == 3);
  82.     printf("\nSearchRvsNode()   "); fflush(stdout);
  83.     Glob = 0; SearchRvsNodeOff(NULL, srch, 3, 27); results(Glob == 0);
  84.     Glob = 0; SearchRvsNodeOff(GetTailOff(&ListA, 3), srch, 3, 27); results(Glob == 3);
  85.     puts("");
  86.     wildtest();
  87.     memory_test();
  88.     RemLibrary(DMiscSupportBase);
  89.     CloseLibrary(DMiscSupportBase);
  90. }
  91.  
  92. results(bool)
  93. {
  94.     if (bool)
  95.     printf("   ok");
  96.     else
  97.     printf(" fail");
  98.     fflush(stdout);
  99. }
  100.  
  101. srch(sptr, arg)
  102. {
  103.     ++Glob;
  104.     printf(".");
  105.     fflush(stdout);
  106.     if (arg != 27)      /*  failure */
  107.     return(1);
  108.     return(NULL);
  109. }
  110.  
  111. /*
  112.  *  TEST:   WildCmp()
  113.  */
  114.  
  115. wildtest()
  116. {
  117.     printf("WildCmp()         "); fflush(stdout);
  118.     results(WildCmp("a??b", "axeb") == 1);
  119.     results(WildCmp("a??b", "axebx")== 0);
  120.     results(WildCmp("*/x*y*b", "a/x/u/xcharliey/b") == 1);
  121.     results(WildCmp("*/x*y*b", "a/x/u/xcharlieq/b") == 0);
  122.     puts("");
  123. }
  124.  
  125. /*
  126.  *  TEST:   BZero(), BSet(), BMov(), and BCmp();
  127.  */
  128.  
  129. memory_test()
  130. {
  131.     long Size = 80000;        /*    MUST BE 80000    */
  132.     short result;
  133.     short i;
  134.     char *ary1 = AllocMem(Size, MEMF_PUBLIC);
  135.     char *ary2 = AllocMem(Size, MEMF_PUBLIC);
  136.  
  137.     printf("\nTEST MEMORY SUBROUTINES:\n");
  138.     if (!ary1 || !ary2) {
  139.     puts("    UNABLE TO ALLOCATE TWO CONTIGUOUS 80K SEGMENTS");
  140.     puts("    THUS, CANNOT PERFORM MEMORY ROUTINES TEST.");
  141.     goto fail;
  142.     }
  143.  
  144.     /*
  145.      *    Test BZero/BSet (both are the same subroutine, essentially).
  146.      *    Test:    >64K, odd start, odd length.
  147.      */
  148.  
  149.     printf(" BZero():   "); fflush(stdout);
  150.  
  151.     xbset(ary1, Size, 43);
  152.     xbset(ary2, Size, 43);
  153.     printf("."); fflush(stdout);
  154.     BZero(ary1 + 1000, 20);
  155.     BZero(ary1 + 1200, 70000);
  156.     BZero(ary2 + 512 + 3, 70000);
  157.     printf("."); fflush(stdout);
  158.     results(xbcheck(ary1, 1000, 43));
  159.     results(xbcheck(ary1 + 1000, 20, 0));
  160.     results(xbcheck(ary1 + 1020, 1200 - 1020, 43));
  161.     results(xbcheck(ary1 + 1200, 70000, 0));
  162.     results(xbcheck(ary1 + 1200 + 70000, Size - 1200 - 70000, 43));
  163.  
  164.     printf("\n BSet():   "); fflush(stdout);
  165.     xbset(ary1, Size, 43);
  166.     xbset(ary2, Size, 43);
  167.     printf("."); fflush(stdout);
  168.     BSet(ary1 + 999, 21, 5);
  169.     BSet(ary1 + 1201, 70001, 6);
  170.     BSet(ary2 + 512 + 1, 69999, 7);
  171.     printf("."); fflush(stdout);
  172.     results(xbcheck(ary1, 999, 43));
  173.     results(xbcheck(ary1 + 999, 21, 5));
  174.     results(xbcheck(ary1 + 999 + 21, 1201 - 999 - 21, 43));
  175.     results(xbcheck(ary1 + 1201, 70001, 6));
  176.     results(xbcheck(ary1 + 1201 + 70001, Size - 1201 - 70001, 43));
  177.     results(xbcheck(ary2, 512 + 1, 43));
  178.     results(xbcheck(ary2 + 512 + 1, 69999, 7));
  179.     results(xbcheck(ary2 + 512 + 1 + 69999, Size - 69999 - 512 - 1, 43));
  180.  
  181.     /*
  182.      *    TEST BMov().  Odd start, overlapping blocks in forward and
  183.      *    reverse.
  184.      */
  185.  
  186.     printf("\n BMov(): 1"); fflush(stdout);
  187.     xbset(ary1, Size, 43);
  188.     xbset(ary2, Size, 43);
  189.     xbiset(ary1 + 1001, 69999, 1);
  190.     xbiset(ary2 + 1003, 70001, 1);
  191.     BMov(ary1 + 1001, ary1 + 997, 69999);
  192.     BMov(ary2 + 1003, ary2 + 1008, 70001);
  193.     results(xbicheck(ary1 + 997, 69999, 1));
  194.     results(xbicheck(ary2 + 1008, 70001, 1));
  195.     results(xbcheck(ary1, 997, 43));
  196.     results(xbcheck(ary1 + 1001 + 69999, Size - 1001 - 69999, 43));
  197.     results(xbcheck(ary2, 1003, 43));
  198.     results(xbcheck(ary2 + 1008 + 70001, Size - 1008 - 70001, 43));
  199.     printf("\n BMov(): 2"); fflush(stdout);
  200.     xbset(ary1, Size, 43);
  201.     xbset(ary2, Size, 43);
  202.     xbiset(ary1 + 1024, 70000, 1);
  203.     xbiset(ary2 + 1024, 70000, 1);
  204.     BMov(ary1 + 1024, ary1 + 1004, 70000);
  205.     BMov(ary2 + 1024, ary2 + 1044, 70000);
  206.     results(xbicheck(ary1 + 1004, 70000, 1));
  207.     results(xbicheck(ary2 + 1044, 70000, 1));
  208.     results(xbcheck(ary1, 1004, 43));
  209.     results(xbcheck(ary1 + 1024 + 70000, Size - 70000 - 1024, 43));
  210.     results(xbcheck(ary2, 1024, 43));
  211.     results(xbcheck(ary1 + 1044 + 70000, Size - 70000 - 1044, 43));
  212.     puts("");
  213.     printf(" SPEEDTEST (K/sec BMov lw bndry, fastmem): %ld K/sec\n", speedtest(MEMF_FAST, 0, 0));
  214.     printf(" SPEEDTEST (K/sec BSet lw bndry, fastmem): %ld K/sec\n", speedtest(MEMF_FAST, 1, 0));
  215.     printf(" SPEEDTEST (K/sec BMov lw bndry, chipmem): %ld K/sec\n", speedtest(MEMF_CHIP, 0, 0));
  216.     printf(" SPEEDTEST (K/sec BSet lw bndry, chipmem): %ld K/sec\n", speedtest(MEMF_CHIP, 1, 0));
  217.     puts("");
  218.     printf(" SPEEDTEST (K/sec BMov by bndry, fastmem): %ld K/sec\n", speedtest(MEMF_FAST, 0, 1));
  219.     printf(" SPEEDTEST (K/sec BMov by bndry, chipmem): %ld K/sec\n", speedtest(MEMF_CHIP, 0, 1));
  220. fail:
  221.     if (ary1)
  222.     FreeMem(ary1, Size);
  223.     if (ary2)
  224.     FreeMem(ary2, Size);
  225. }
  226.  
  227. speedtest(memtype, zero, off)
  228. {
  229.     char *buf = AllocMem(65536+256, memtype);
  230.     short i;
  231.     long s;
  232.  
  233.     if (!buf)
  234.     return(0);
  235.     s = ltm();
  236.     for (i = 0; i < 128; ++i) {
  237.     if (zero)
  238.         BSet(buf + off, 65536, 1);
  239.     else
  240.         BMov(buf + off, buf + 128 + off, 65536);
  241.     }
  242.     s = ltm() - s;          /*  1/50ths second for 64K * 128 */
  243.     FreeMem(buf, 65536+256);
  244.     return(64 * 128 * 50 / s);
  245. }
  246.  
  247. ltm()
  248. {
  249.     long st[3];
  250.  
  251.     DateStamp(st);
  252.     return(st[2] + 50 * 60 * st[1] + 50 * 60 * 60 * 24 * st[0]);
  253. }
  254.  
  255. xbset(s, n, v)
  256. register char *s;
  257. register long n;
  258. register char v;
  259. {
  260.     while (n--)
  261.     *s++ = v;
  262. }
  263.  
  264. xbiset(s, n, v)
  265. register char *s;
  266. register long n;
  267. register char v;
  268. {
  269.     while (n--) {
  270.     ++v;
  271.     *s++ = v;
  272.     }
  273. }
  274.  
  275.  
  276. xbcheck(s, n, v)
  277. register char *s;
  278. register long n;
  279. register char v;
  280. {
  281.     char *orig = s;
  282.     short errs = 255;
  283.     while (n--) {
  284.     if (*s++ != v) {
  285.         if (errs) {
  286.         --errs;
  287.         printf("(%ld)", s - orig - 1);
  288.         } else {
  289.         printf("giveup");
  290.         return(0);
  291.         }
  292.     }
  293.     }
  294.     return(errs == 255);
  295. }
  296.  
  297. xbicheck(s, n, v)
  298. register char *s;
  299. register long n;
  300. register char v;
  301. {
  302.     char *orig = s;
  303.     short errs = 255;
  304.     while (n--) {
  305.     ++v;
  306.     if (*s++ != v) {
  307.         if (errs) {
  308.         --errs;
  309.         printf("(%ld)", s - orig);
  310.         } else {
  311.         printf("giveup");
  312.         return(0);
  313.         }
  314.     }
  315.     }
  316.     return(errs == 255);
  317. }
  318.  
  319.  
  320.