home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / doc / xms / test / test.c < prev    next >
C/C++ Source or Header  |  1989-02-06  |  9KB  |  343 lines
  1. /*
  2.  *    HITEST.C - Test Routines for HIMEM.SYS
  3.  *
  4.  *    Copyright (c) 1988, Microsoft Corporation
  5.  */
  6.  
  7. #include    "xmm.h"
  8.  
  9. int    quiet = 0;
  10.  
  11. #define    MAXHANDLES    (32*2)
  12. #define    BUFLEN        1024
  13.  
  14. struct    HandleInfo {
  15.     short        Handle;
  16.     short        Length;
  17.     short        Filler;
  18.     unsigned long    RealAddress;
  19. };
  20.  
  21. struct HandleInfo    HandleTable[MAXHANDLES];
  22.  
  23. struct XMM_Move MoveS;
  24.  
  25. short    BufferLow[BUFLEN];
  26. short    BufferExt[BUFLEN];
  27. short    BufferHi[BUFLEN];
  28.  
  29. main(argc, argv)
  30. char *argv[];
  31. {
  32.     long        XMM_Ret;
  33.     int        Request_Amount;
  34.     int        Handle, hi;
  35.     long        Alloc_Ret;
  36.     short        TotalAllocated = 0;
  37.     short        Handles;
  38.     short        MemPerHandle;
  39.  
  40.     if ( argc > 1 && argv[1][0] == 'q' )
  41.         quiet = 1;
  42.  
  43.     if ( XMM_Installed() ) {
  44.         printf("Extended Memory Manager Found\n\n");
  45.         XMM_Ret = XMM_Version();
  46.         printf("XMM Version %4X, Internal Version %4x\n\n",
  47.             (short)XMM_Ret, (short)(XMM_Ret >> 16));
  48.     } else {
  49.         printf("No Extended Memory Manager Present\n\n");
  50.         Exit_Test();
  51.     }
  52.     Request_Amount = 0;
  53.     do { 
  54.         XMM_Ret = XMM_RequestHMA(Request_Amount);
  55.         if ( XMM_Ret == 0 )
  56.             break;
  57.         Request_Amount++;
  58.     } while ( Request_Amount );
  59.     if ( XMM_Ret == 0 ) {
  60.         printf("Got HMA with Request of %d Kb\n", Request_Amount);
  61.         if ( XMM_RequestHMA(Request_Amount) == 0 ) {
  62.             printf("Unexpected success requesting HMA again\n");
  63.         }
  64.         XMM_Ret = XMM_ReleaseHMA();
  65.         if ( XMM_Ret )
  66.             Error("Could not release HMA", XMM_Ret);
  67.         else
  68.             printq("Released HMA\n");
  69.     } else {
  70.         Error("Could not Get HMA", XMM_Ret);
  71.     }
  72.     EnableA20();
  73.     EnableA20();
  74.     DisableA20();
  75.     EnableA20();
  76.     DisableA20();
  77.     EnableA20();
  78.     DisableA20();
  79.     DisableA20();
  80.  
  81.     /* Soak up all extended memory and handles */
  82.     hi = 0;
  83.     while ( hi < MAXHANDLES ) {
  84.         long    FreeExtended;
  85.         FreeExtended = XMM_QueryLargestFree();
  86.         if ( FreeExtended < 0 ) {
  87.             if ( XMSERROR(FreeExtended) == (char)0xA0 )
  88.                 FreeExtended = 0L;
  89.             else {
  90.                 Error("Query Free Extended Failed", FreeExtended);
  91.                 break;
  92.             }
  93.         }
  94.         if ( hi < MAXHANDLES -1  && FreeExtended > 1 )
  95.             FreeExtended /= 2;
  96.         if ( !quiet )
  97.             printf("Attempt to Allocate %d Kb\n", FreeExtended);
  98.         Alloc_Ret = XMM_AllocateExtended(FreeExtended);
  99.         if ( Alloc_Ret < 0 ) {
  100.             if ( XMSERROR(Alloc_Ret) == (char)0xA1 )
  101.                 break;
  102.             Error("Allocate Failed", Alloc_Ret);
  103.         } else {
  104.             TotalAllocated += FreeExtended;
  105.             HandleTable[hi].Handle = (short)Alloc_Ret;
  106.         }
  107.         hi++;
  108.     }
  109.     Handles = hi;
  110.     printf("%d Kb Free Found and Allocated \n", TotalAllocated);
  111.     printf("%d handle(s) allocated\n", Handles);
  112.     printq("Freeing first handle\n");
  113.     XMM_Ret = XMM_FreeExtended(HandleTable[0].Handle);
  114.     if ( XMM_Ret )
  115.         Error("Free Extended Memory Block", XMM_Ret);
  116.     printq("Reallocate first handle with 0 length\n");
  117.     Alloc_Ret = XMM_AllocateExtended(0);
  118.     if ( Alloc_Ret < 0 )
  119.         Error("Zero Length Allocate failed", Alloc_Ret);
  120.     else
  121.         HandleTable[0].Handle = (short)Alloc_Ret;
  122.     hi = 0;
  123.     while ( hi < Handles ) {
  124.         if ( HandleTable[hi].Handle == 0 )
  125.             break;
  126.         if ( !quiet )
  127.             printf("Freeing Handle #%d (%x)\n", hi,
  128.                 HandleTable[hi].Handle);
  129.         XMM_Ret = XMM_FreeExtended(HandleTable[hi].Handle);
  130.         if ( XMM_Ret )
  131.             Error("Free Extended Memory Block", XMM_Ret);
  132.         hi++;
  133.     }
  134.  
  135.     if ( Handles == 0 )
  136.         Exit_Test();
  137.     MemPerHandle = TotalAllocated / Handles + 1;
  138.     if ( (long)BUFLEN < MemPerHandle * 512L )
  139.         MemPerHandle = BUFLEN/512;
  140.     if ( !quiet )
  141.         printf("Allocating in %d Kb chunks\n", MemPerHandle);
  142.     hi = 0;
  143.     while ( hi < Handles ) {
  144.         XMM_Ret = XMM_AllocateExtended(MemPerHandle);
  145.         if ( XMM_Ret < 0 ) {
  146.             if ( XMSERROR(XMM_Ret) != 0xA0 )
  147.                 Error("Allocate", XMM_Ret);
  148.             break;
  149.         }
  150.         HandleTable[hi].Handle = (short)XMM_Ret;
  151.         HandleTable[hi].Length = MemPerHandle;
  152.         XMM_Ret = XMM_LockExtended((short)XMM_Ret);
  153.         if ( XMM_Ret < 0 ) {
  154.             printf("Handle %4x: ", HandleTable[hi].Handle);
  155.             Error("Lock Failed", XMM_Ret);
  156.         }
  157.         if ( !quiet )
  158.             printf("Handle %4x: Real Address %lx\n", HandleTable[hi].Handle,XMM_Ret);
  159.         HandleTable[hi].RealAddress = XMM_Ret;
  160.         XMM_Ret = XMM_FreeExtended(HandleTable[hi].Handle);
  161.         if ( XMM_Ret >= 0 ) {
  162.             printf("Unexpected success freeing locked Handle\n");
  163.             break;
  164.         } else if ( XMSERROR(XMM_Ret) != (char)0xAB ) {
  165.             Error("Freeing Locked Handle", XMM_Ret);
  166.         }
  167.         Fill(BufferExt, HandleTable[hi].Handle ^ 0xAAAA, BUFLEN);
  168.         MoveS.Length = MemPerHandle*1024L;
  169.         MoveS.SourceHandle = 0;
  170.         (char far *)MoveS.SourceOffset = (char far *)BufferExt;
  171.         MoveS.DestHandle = HandleTable[hi].Handle;
  172.         MoveS.DestOffset = 0L;
  173.         XMM_Ret = XMM_MoveExtended(&MoveS);
  174.         if ( XMM_Ret < 0 )
  175.             Error("Move to Extended Memory Failed", XMM_Ret);
  176.         hi++;
  177.     }
  178.     Handles = hi;        /* How many we got this time */
  179.  
  180.     if ( hi == 0 )
  181.         Exit_Test();
  182.  
  183.     while ( --hi >= 0 ) {
  184.         if ( !quiet )
  185.             printf("Checking Handle %x\n", HandleTable[hi].Handle);
  186.         Fill(BufferLow, HandleTable[hi].Handle ^ 0xAAAA, BUFLEN);
  187.         MoveS.Length = MemPerHandle*1024L;
  188.         MoveS.SourceHandle = HandleTable[hi].Handle;
  189.         MoveS.SourceOffset = 0L;
  190.         MoveS.DestHandle = 0;
  191.         (char far *)MoveS.DestOffset = (char far *)BufferHi;
  192.         XMM_Ret = XMM_MoveExtended(&MoveS);
  193.         if ( XMM_Ret < 0 )
  194.             Error("Move from Extended Memory Failed", XMM_Ret);
  195.         if ( Cmp(BufferLow, BufferHi, BUFLEN) )
  196.             printf("Comparison Failed, Handle %x\n",
  197.                 HandleTable[hi].Handle);
  198.         XMM_Ret = XMM_UnlockExtended(HandleTable[hi].Handle);
  199.         if ( XMM_Ret < 0 )
  200.             Error("Unlock of Extended Memory Failed", XMM_Ret);
  201.     }
  202.  
  203.     hi = 0;
  204.     while ( hi < Handles ) {
  205.         Fill(BufferLow, HandleTable[hi].Handle ^ 0xAAAA, BUFLEN);
  206.         MoveS.Length = MemPerHandle*1024L;
  207.         MoveS.SourceHandle = HandleTable[hi].Handle;
  208.         MoveS.SourceOffset = 0L;
  209.         MoveS.DestHandle = 0;
  210.         (char far *)MoveS.DestOffset = (char far *)BufferHi;
  211.         XMM_Ret = XMM_MoveExtended(&MoveS);
  212.         if ( XMM_Ret < 0 )
  213.             Error("Move from Unlocked Extended Memory Failed", XMM_Ret);
  214.         if ( Cmp(BufferLow, BufferHi, MemPerHandle*512) )
  215.             printf("Comparison Failed, Unlocked Handle %x\n",
  216.                 HandleTable[hi].Handle);
  217.  
  218.             /* Check weird cases */
  219.         MoveS.Length = 1;
  220.         XMM_Ret = XMM_MoveExtended(&MoveS);
  221.         if ( XMSERROR(XMM_Ret) != (char)0xA7 )
  222.             Error("Move Extended with Odd Length", XMM_Ret);
  223.  
  224.         MoveS.Length = MemPerHandle*1024L + 2;
  225.         XMM_Ret = XMM_MoveExtended(&MoveS);
  226.         if ( XMSERROR(XMM_Ret) != (char)0xA7 )
  227.             Error("Move Extended with Length too long", XMM_Ret);
  228.  
  229.         MoveS.Length = MemPerHandle*1024L -2;
  230.         MoveS.SourceOffset = 4L;
  231.         XMM_Ret = XMM_MoveExtended(&MoveS);
  232.         if ( XMM_Ret >= 0 )
  233.             Error("Move Extended Base+Length too large", XMM_Ret);
  234.  
  235.         XMM_Ret = XMM_FreeExtended(HandleTable[hi].Handle);
  236.         if ( XMM_Ret < 0 )
  237.             Error("Free of Extended Memory Failed", XMM_Ret);
  238.  
  239.         XMM_Ret = XMM_MoveExtended(&MoveS);
  240.         if ( XMSERROR(XMM_Ret) != (char)0xA3 )
  241.             Error("Move Extended from Invalid Handle", XMM_Ret);
  242.         hi++;
  243.     }
  244.  
  245.     TestWrap();
  246.  
  247.     Exit_Test();
  248. }
  249.  
  250. TestWrap()
  251. {
  252.     long        XMM_Ret;
  253.  
  254.     printq("Try Moves from Wrap Area\n");
  255.     MoveS.Length = BUFLEN*2;
  256.     MoveS.SourceHandle = 0;
  257.     MoveS.SourceOffset = 0xFFFFF800L;
  258.     XMM_Ret = XMM_MoveExtended(&MoveS);
  259.     if ( XMM_Ret < 0 )
  260.         Error("Move Extended at end of Conventional", XMM_Ret);
  261.  
  262.     MoveS.Length += 2;
  263.     XMM_Ret = XMM_MoveExtended(&MoveS);
  264.     if ( XMSERROR(XMM_Ret) != (char)0xA7 )
  265.         Error("Move Extended overflowing end of Conventional", XMM_Ret);
  266. }
  267.  
  268. EnableA20()
  269. {
  270.     long    XMM_Ret;
  271.  
  272.     printq("Enable A20: ");
  273.     XMM_Ret = XMM_EnableA20();
  274.     if ( XMM_Ret < 0 )
  275.         Error("A20 not enabled", XMM_Ret);
  276.     QueryA20();
  277. }
  278.  
  279. DisableA20()
  280. {
  281.     long    XMM_Ret;
  282.  
  283.     printq("Disable A20: ");
  284.     XMM_Ret = XMM_DisableA20();
  285.     if ( XMM_Ret < 0 )
  286.         Error("A20 not disabled", XMM_Ret);
  287.     QueryA20();
  288. }
  289.  
  290. QueryA20()
  291. {
  292.     long    XMM_Ret;
  293.  
  294.     printq("Query A20: ");
  295.     XMM_Ret = XMM_QueryA20();
  296.     if ( XMM_Ret == 1 )
  297.         printq("A20 Enabled\n");
  298.     else if ( XMM_Ret == 0 )
  299.         printq("A20 Disabled\n");
  300.     else
  301.         Error("Failed", XMM_Ret);
  302. }
  303.  
  304. Fill(ptr, pattern, count)
  305. int *ptr;
  306. {
  307.     while ( count-- )
  308.         *ptr++ = pattern++;
  309. }
  310.  
  311. Cmp(ptr1, ptr2, count)
  312. int *ptr1, *ptr2;
  313. {
  314.     while ( count-- )
  315.         if ( *ptr1++ != *ptr2++ )
  316.             return(1);
  317.  
  318.     return(0);
  319. }
  320.  
  321. printq(arg)
  322. {
  323.     if ( !quiet )
  324.         printf(arg);
  325. }
  326.  
  327. Error(string, code)
  328. char    *string;
  329. long     code;
  330. {
  331.     if ( code < 0 ) {
  332.         code = XMSERROR(code);
  333.         printf("%s, Error Code %2x\n", string, (unsigned)code);
  334.     } else if ( !quiet )
  335.         printf("%s\n", string);
  336. }
  337.  
  338. Exit_Test()
  339. {
  340.     printf("\nXMM Test Completed\n");
  341.     exit(0);
  342. }
  343.