/*************************************************************************** * emstest.c * * MODULE: EMSIF * * OS: DOS * * VERSION: 1.2 * * DATE: 06/15/93 * * * * Copyright (c) 1991, 1993 James W. Birdsall. All Rights Reserved. * * * * Requires emsif.h, testutil.h, and emstest.h to compile. * * Compiles under Borland C++ 2.0, TC 2.0, MSC/C++ 7.0, and * * MS Visual C++ 1.0. * * * * Regression test and example for EMSIF. * * * * This is part one of the regression tester and example for EMSIF. * * The other parts are named EMSTEST2.C and EMSTEST3.C. All three parts * * must be compiled and linked together along with the appropriate EMSIF * * library and a utilities file TESTUTIL.C to produce the tester * * executable. This program compiles under tiny, small, medium, compact, * * large, and huge models. Note that it doesn't quite fit into tiny * * model; the tiny model tester is actually three executables. The * * compact model under MSC 7.0 suffers from the same problem. When * * compiling for these configurations, one of the symbols PASS1, PASS2, * * or PASS3 must be defined. See the example makefiles for further * * details on what needs to be linked with what to produce these * * executables. * * * * To use this tester: just run it. It requires no arguments and produces * * output on stdout. It performs nearly 200 tests and parts of it run * * quite fast, even on an original IBM PC/XT (4.77 MHz). If you want to * * actually read the output, you should redirect the output to a file. * * If you just want to see whether the tests all pass, simply run it -- * * if a test fails, execution aborts immediately. * * * * Certain types of failure may cause EMSTEST to not deallocate EMS or * * conventional memory that it has allocated. This should only occur if * * the library itself is malfunctioning (which should never happen to * * you, only to me!) or if you are trying a different compiler or * * unsupported memory model and the compiler and library are therefore * * not communicating properly. It may also happen if you press control- * * break. * * * * Turbo C and older versions of Turbo C++ do not have the _fmemcmp() and * * _fmemset() functions; I don't know about older versions of MSC. If * * your compiler does not have these functions, define the symbol * * NO_FFUNC and functions in the ancillary file TESTUTIL.C will be used * * instead. * * * ***************************************************************************/ /* ** system includes <> */ #include #include #include /* ** custom includes "" */ #include "testutil.h" #include "emsif.h" #include "emstest.h" /* ** local #defines */ /* ** misc: copyright strings, version macros, etc. */ /* ** typedefs */ /* ** global variables */ int testno = 1; /* number of test currently being done */ unsigned char far *frameptr[4]; /* pointers to EMS frames */ char *gblmsg = ""; /* msg to be printed in test header */ /* ** static globals */ /* ** function prototypes */ /* ** functions */ /*************************************************************************** * FUNCTION: MAIN * * * * DESCRIPTION: * * * * The master function. * * * * ENTRY: * * * * None. * * * * EXIT: * * * * Void. * * * * CONSTRAINTS/SIDE EFFECTS: * * * ***************************************************************************/ main() { int status; /* return status from library functions */ /* ** check initialization test */ TESTHEADER(); printf("Making a call to EMMgetversion() before calling EMMlibinit().\n"); printf("The call should fail.\n"); EMMgetversion(); nofailcheck("EMMgetversion()", (int) _EMMerror, NULL, 0, 0); weirdcodechk("EMMgetversion()", EMM_NOINIT, NULL, 0, 0); TESTTAILER(); /* ** initialize EMSIF */ TESTHEADER(); printf("Calling EMMlibinit().\n"); printf("Should succeed if and only if Expanded Memory Manager for EMS version 3.0 or\n"); printf(" greater is present.\n"); status = EMMlibinit(); switch (status) { case EMMOOPS: printf("EMMlibinit() failed, code 0x%X.\n", (unsigned int) _EMMerror); exit(3); break; case NOEMM: printf("EMMlibinit() did not find an Expanded Memory Manager.\n"); exit(3); break; case 0: printf("EMMlibinit() returned OK.\n"); weirdcodechk("EMMlibinit()", 0, NULL, 0, 0); break; default: printf("EMMlibinit() returned strange value %d.\n", status); exit(3); break; } TESTTAILER(); /* ** The following section of code is included only in the first tiny-model ** executable and in non-tiny-model executables. */ #ifndef PASS2 #ifndef PASS3 /* ** test version call */ TESTHEADER(); printf("Testing EMMgetversion().\n"); printf("Results should match value in _EMMversion.\n"); status = EMMgetversion(); weirdcodechk("EMMgetversion()", 0, NULL, 0, 0); if (status != (int) _EMMversion) { printf("EMMgetversion() [0x%X] and _EMMversion [0x%X] differ.\n", status, (unsigned int) _EMMversion); exit(3); } printf("EMS version %d.%d.\n", ((status >> 4) & 0xF), (status & 0xF)); TESTTAILER(); /* ** test allocation functions */ do_alloc_tests(1L); do_alloc_tests(16384L); do_alloc_tests(55555L); do_alloc_tests(0L); #endif /* !PASS3 */ #endif /* !PASS2 */ /* ** test frame functions -- included in all executables */ do_frame_tests(); /* ** The following section of code is included only in the first tiny-model ** executable and in non-tiny-model executables. */ #ifndef PASS2 #ifndef PASS3 /* ** test name functions */ do_name_tests(); /* ** do mapping tests */ do_map_tests(); /* ** do realloc tests */ do_realloc_tests(); /* ** test the save/restore facility */ do_sr_tests(); #endif /* !PASS3 */ #endif /* !PASS2 */ /* ** The following section of code is included only in the second tiny-model ** executable and in non-tiny-model executables. */ #ifndef PASS1 #ifndef PASS3 /* ** test copies of <= one page, frame caching on */ gblmsg = " SHORT COPY TESTS"; do_shortcopy_tests(); gblmsg = ""; /* ** test frame cache control */ TESTHEADER(); printf("Testing frame caching enable/disable.\n"); if (_EMMframecache != 0) { printf("Frame caching is supposed to be off by default, seems to "); printf("be on.\n"); exit(3); } _EMMenc(); weirdcodechk("_EMMenc()", 0, NULL, 0, 0); if (_EMMframecache == 0) { printf("_EMMenc() did not enable frame caching.\n"); exit(3); } _EMMdisc(); weirdcodechk("_EMMdisc()", 0, NULL, 0, 0); if (_EMMframecache != 0) { printf("_EMMdisc() did not disable frame caching.\n"); exit(3); } printf("Flag and function calls correspond OK.\n"); TESTTAILER(); /* ** test copies of <= one page, frame caching on */ _EMMenc(); gblmsg = " SHORT COPY TESTS WITH FRAME CACHING ON"; do_shortcopy_tests(); _EMMdisc(); #endif /* !PASS3 */ /* ** The following section of code is included only in the third tiny-model ** executable and in non-tiny-model executables. */ #ifndef PASS2 /* ** test copies of > 1 page, frame caching off */ _EMMdisc(); gblmsg = " LONG COPY TESTS"; do_longcopy_tests(); /* ** test copies of > 1 page, frame caching on */ _EMMenc(); gblmsg = " LONG COPY TESTS WITH FRAME CACHING ON"; do_longcopy_tests(); gblmsg = ""; _EMMdisc(); #endif /* !PASS2 */ #endif /* !PASS1 */ /* end and cleanup */ printf(">>>END\n"); printf("All tests succeeded.\n"); exit(0); } /* end of main() */ /*************************************************************************** * FUNCTION: DO_FRAME_TESTS * * * * DESCRIPTION: * * * * This function tests EMSIF calls EMMgetnumframe(), * * EMMgetframeaddr(), and EMMgetsinfraddr(). * * * * ENTRY: * * * * Void. * * * * EXIT: * * * * Void. * * * * CONSTRAINTS/SIDE EFFECTS: * * * * Fills in the frameptr[] global array. * * * ***************************************************************************/ void do_frame_tests(void) { frameinfo *framebuf; int frames; int status; int loop; unsigned int segaddr; /* set header */ gblmsg = " FRAME TESTS"; /* get number of frames */ TESTHEADER(); printf("Getting number of frames with EMMgetnumframe().\n"); if (_EMMversion < 0x40) { printf("Should be exactly 4.\n"); } else { printf("Should be 4 or more.\n"); } frames = EMMgetnumframe(); weirdcodechk("EMMgetnumframe()", 0, NULL, 0, 0); if (frames < 4) { printf("EMMgetnumframe() returned OK but indicates only %d frames.\n", frames); exit(3); } if ((_EMMversion < 0x40) && (frames != 4)) { printf("EMMgetnumframe() returned OK but indicates wrong number of\n"); printf(" frames (%d) for this version.\n", frames); exit(3); } printf("EMMgetnumframe() returned OK, %d frames.\n", frames); TESTTAILER(); /* allocate memory for frame address buffer */ framebuf = (frameinfo *) calloc(frames, sizeof(frameinfo)); if (framebuf == (frameinfo *) NULL) { printf("OOPS! Couldn't allocate a buffer. Aborting.\n"); exit(3); } /* get frame segment addresses */ TESTHEADER(); printf("Getting frame address info with EMMgetframeaddr().\n"); printf("Should succeed.\n"); status = EMMgetframeaddr(framebuf); TRIPLECHECK("EMMgetframeaddr()", status, 0, framebuf, 0, 0); printf("EMMgetframeaddr() returned OK, checking info returned...\n"); for (loop = 0; loop < frames; loop++) { /* check for valid frame number */ if (framebuf[loop].frameno >= frames) { printf("Frame number in slot %d is bad (%u).\n", loop, framebuf[loop].frameno); free(framebuf); exit(3); } /* check that frame segment address is on a page (16K) boundary */ if ((framebuf[loop].segaddr & 0x3FF) != 0) { printf( "Frame segment %u, slot %d, frame number %u, not page aligned.\n", framebuf[loop].segaddr, loop, framebuf[loop].frameno); free(framebuf); exit(3); } /* if one of frames 0-3, save the address */ if (framebuf[loop].frameno < 4) { frameptr[framebuf[loop].frameno] = (unsigned char far *) MK_FP(framebuf[loop].segaddr, 0); } } printf("Info returned checks out OK.\n"); TESTTAILER(); /* now test EMMgetsinfraddr() */ TESTHEADER(); printf("Testing EMMgetsinfraddr() against data from EMMgetframeaddr().\n"); printf("Should succeed.\n"); /* loop through framebuf, calling EMMgetsinfraddr() on each */ for (loop = 0; loop < frames; loop++) { segaddr = EMMgetsinfraddr(framebuf[loop].frameno); weirdcodechk("EMMgetsinfraddr()", 0, framebuf, 0, 0); if (segaddr != framebuf[loop].segaddr) { printf("EMMgetsinfraddr(%u) succeeded but returned %u, not %u.\n", framebuf[loop].frameno, segaddr, framebuf[loop].segaddr); free(framebuf); exit(3); } } printf("EMMgetsinfraddr() returned all addresses OK.\n"); TESTTAILER(); /* clean up */ free(framebuf); gblmsg = ""; return; } /* end of do_frame_tests() */ /* ** The following section of code is included only in the first tiny-model ** executable and in non-tiny-model executables. */ #ifndef PASS2 #ifndef PASS3 /*************************************************************************** * FUNCTION: DO_ALLOC_TESTS * * * * DESCRIPTION: * * * * This function tests EMSIF calls EMMcoreleft(), EMMalloc(), and * * EMMfree(). Don't bother testing EMMallocpages() -- if EMMalloc() * * works, it's only because EMMallocpages() (used internally) works. * * * * ENTRY: * * * * bytes - number of bytes of EMS to try to allocate. * * * * EXIT: * * * * Void. * * * * CONSTRAINTS/SIDE EFFECTS: * * * ***************************************************************************/ void do_alloc_tests(unsigned long bytes) { unsigned long emsfree, emsfree2; unsigned long pagelen; int handle; /* set header */ gblmsg = " ALLOCATION TESTS"; /* get bytes value rounded up to nearest page, or 1 page if bytes == 0 */ if (bytes != 0L) { pagelen = bytes + 16383L; pagelen &= 0xFFFFC000L; } else { pagelen = 16384L; } /* test coreleft */ TESTHEADER(); printf("Testing EMMcoreleft().\n"); printf("Result should be multiple of 16384.\n"); emsfree = test_EMMcoreleft(); printf("EMMcoreleft() returned OK, shows %lu bytes (%lu pages) free.\n", emsfree, (emsfree / 16384L)); TESTTAILER(); /* make sure enough free */ if (emsfree < (MINFREE * 16384L)) { printf("Insufficient free EMS to perform all tests. Aborting.\n"); exit(1); } /* test allocation */ TESTHEADER(); printf("Testing EMMalloc(%lu).\n", bytes); printf("Should succeed. Free EMS should drop by %lu bytes (%lu pages).\n", pagelen, (pagelen / 16384L)); handle = test_EMMalloc(bytes); printf("EMMalloc() returned OK.\n"); emsfree2 = test_EMMcoreleft(); printf("EMMcoreleft() returned OK, shows %lu bytes (%lu pages) free.\n", emsfree2, (emsfree2 / 16384L)); if ((emsfree - emsfree2) != pagelen) { printf("EMMalloc(%lu) caused free to drop weirdly from %lu to %lu.\n", bytes, emsfree, emsfree2); EMMfree(handle); exit(3); } TESTTAILER(); /* test free */ TESTHEADER(); printf("Testing EMMfree() on handle just returned by EMMalloc().\n"); printf( "Should succeed. Free EMS should increase by %lu bytes (%lu pages).\n", pagelen, (pagelen / 16384L)); test_EMMfree(handle); printf("EMMfree() returned OK.\n"); emsfree2 = test_EMMcoreleft(); printf("EMMcoreleft() returned OK, shows %lu bytes (%lu pages) free.\n", emsfree2, (emsfree2 / 16384L)); if (emsfree2 != emsfree) { printf("Freeing handle returned by EMMalloc() did not restore\n"); printf(" free EMS count -- was %lu originally, now %lu.\n", emsfree, emsfree2); exit(3); } TESTTAILER(); gblmsg = ""; return; } /* end of do_alloc_tests() */ /*************************************************************************** * FUNCTION: DO_NAME_TESTS * * * * DESCRIPTION: * * * * This function tests EMSIF calls EMMgetname() and EMMsetname(). * * * * ENTRY: * * * * Void. * * * * EXIT: * * * * Void. * * * * CONSTRAINTS/SIDE EFFECTS: * * * ***************************************************************************/ void do_name_tests(void) { char name[9]; int handle, status; /* set header */ gblmsg = " NAME TESTS"; TESTHEADER(); printf("Testing EMMsetname() and EMMgetname().\n"); if (_EMMversion < 0x40) { printf( "EMMsetname() should fail, EMMgetname() return empty buffer.\n"); } else { printf("Should succeed.\n"); } /* allocate some EMS to assign a name to */ handle = test_EMMalloc(16384); printf("Calling EMMsetname() with name ABCDEFGH.\n"); status = EMMsetname(handle, "ABCDEFGH"); if (_EMMversion < 0x40) { nofailcheck("EMMsetname()", status, NULL, handle, 0); weirdretchk("EMMsetname()", status, NULL, handle, 0); weirdcodechk("EMMsetname()", EMM_BADVERS, NULL, handle, 0); printf("EMMsetname() failed OK.\n"); } else { TRIPLECHECK("EMMsetname()", status, 0, NULL, handle, 0); printf("EMMsetname() succeeded.\n"); } printf("Now calling EMMgetname().\n"); status = EMMgetname(handle, name); TRIPLECHECK("EMMgetname()", status, 0, NULL, handle, 0); if (_EMMversion < 0x40) { if (farmemcheck((unsigned char far *) name, 9, '\0') != 0) { printf("A character in name is not null.\n"); EMMfree(handle); exit(3); } } else { if (strcmp(name, "ABCDEFGH") != 0) { printf("Got name %s back.\n", name); EMMfree(handle); exit(3); } } printf("EMMgetname() succeeded.\n"); test_EMMfree(handle); TESTTAILER(); gblmsg = ""; return; } /* end of do_name_tests() */ /*************************************************************************** * FUNCTION: DO_MAP_TESTS * * * * DESCRIPTION: * * * * This function tests EMSIF call EMMmappage(). * * * * ENTRY: * * * * Void. * * * * EXIT: * * * * Void. * * * * CONSTRAINTS/SIDE EFFECTS: * * * ***************************************************************************/ void do_map_tests(void) { int handle1, handle2; int loop; int status; /* set header */ gblmsg = " MAPPING TESTS"; /* first, allocate some EMS to map */ handle1 = test_EMMallocpages(6); handle2 = test_EMMallocpages(2); /* initial test of EMMmappage() */ TESTHEADER(); printf("Calling EMMmappage(frameno = 0, first handle, logpage = 0).\n"); printf("Should succeed.\n"); test_EMMmappage(0, handle1, 0); printf("EMMmappage() returned OK.\n"); TESTTAILER(); /* calling EMMmappage() with a bad logical page number */ TESTHEADER(); printf("Calling EMMmappage(frameno = 0, first handle, logpage = 6).\n"); printf("Should fail.\n"); status = EMMmappage(0, handle1, 6); nofailcheck("EMMmappage()", status, NULL, handle1, handle2); weirdretchk("EMMmappage()", status, NULL, handle1, handle2); weirdcodechk("EMMmappage()", EMM_BADLOGPAGE, NULL, handle1, handle2); printf("EMMmappage() failed OK.\n"); TESTTAILER(); TESTHEADER(); printf("Writing data pattern to page 0, first handle... "); FMEMSET(frameptr[0], 0, 16384); printf("Verifying... "); if (farmemcheck(frameptr[0], 16384, 0) != 0) { printf("Verify failed!\n"); test_EMMfree(handle1); test_EMMfree(handle2); exit(3); } printf("OK.\n"); printf("Calling EMMmappage(frameno = 0, first handle, logpage = 1).\n"); test_EMMmappage(0, handle1, 1); printf("EMMmappage() returned OK.\n"); printf("Writing data pattern to page 1, first handle... "); FMEMSET(frameptr[0], 1, 16384); printf("Verifying... "); if (farmemcheck(frameptr[0], 16384, 1) != 0) { printf("Verify failed!\n"); test_EMMfree(handle1); test_EMMfree(handle2); exit(3); } printf("OK.\n"); printf("Now mapping page 0 back, see if it's still OK.\n"); test_EMMmappage(0, handle1, 0); printf("EMMmappage() returned OK, verifying contents... "); if (farmemcheck(frameptr[0], 16384, 0) != 0) { printf("Verify failed!\n"); test_EMMfree(handle1); test_EMMfree(handle2); exit(3); } printf("OK.\n"); printf("EMMmappage() looks like it's doing something.\n"); TESTTAILER(); TESTHEADER(); printf("Testing mapping of all frames...\n"); printf("Filling rest of allocated pages with unique patterns... "); for (loop = 2; loop < 6; loop++) { test_EMMmappage(0, handle1, loop); FMEMSET(frameptr[0], loop, 16384); if (farmemcheck(frameptr[0], 16384, (unsigned char) loop) != 0) { printf("Verify failed on handle 1, page %d.\n", loop); test_EMMfree(handle1); test_EMMfree(handle2); exit(3); } } test_EMMmappage(0, handle2, 0); FMEMSET(frameptr[0], 0x10, 16384); if (farmemcheck(frameptr[0], 16384, 0x10) != 0) { printf("Verify failed on handle 2, page 0!\n"); test_EMMfree(handle1); test_EMMfree(handle2); exit(3); } test_EMMmappage(0, handle2, 1); FMEMSET(frameptr[0], 0x11, 16384); if (farmemcheck(frameptr[0], 16384, 0x11) != 0) { printf("Verify failed on handle 2, page 1!\n"); test_EMMfree(handle1); test_EMMfree(handle2); exit(3); } printf("Done.\n"); printf("Mapping handle 1 pages 0-3 in frames 0-3 respectively... "); for (loop = 0; loop < 4; loop++) { test_EMMmappage(loop, handle1, loop); } printf("Done.\n"); printf("Verifying contents... "); for (loop = 0; loop < 4; loop++) { if (farmemcheck(frameptr[loop], 16384, (unsigned char) loop) != 0) { printf("Verify failed for frame %d.\n", loop); test_EMMfree(handle1); test_EMMfree(handle2); exit(3); } } printf("OK.\n"); printf("Mapping handle 1 pages 0-3 in frames 0-3 in reverse... "); for (loop = 0; loop < 4; loop++) { test_EMMmappage(loop, handle1, (3 - loop)); } printf("Done.\n"); printf("Verifying contents... "); for (loop = 0; loop < 4; loop++) { if (farmemcheck(frameptr[loop], 16384, (unsigned char)(3 - loop)) != 0) { printf("Verify failed for frame %d.\n", loop); test_EMMfree(handle1); test_EMMfree(handle2); exit(3); } } printf("OK.\n"); printf( "Mapping handle 1 pages 0-3 in frames 0-3 except page 5 in frame 2... "); for (loop = 0; loop < 4; loop++) { test_EMMmappage(loop, handle1, loop); } test_EMMmappage(2, handle1, 5); printf("Done.\n"); printf("Verifying contents... "); for (loop = 0; loop < 4; loop++) { if (farmemcheck(frameptr[loop], 16384, (unsigned char)((loop != 2) ? loop : 5)) != 0) { printf("Verify failed for frame %d.\n", loop); test_EMMfree(handle1); test_EMMfree(handle2); exit(3); } } printf("OK.\n"); TESTTAILER(); TESTHEADER(); printf("Final mapping test... two handles at once!\n"); printf("Mapping handle2 page 1 in frame 0.\n"); printf(" handle1 page 4 in frame 1.\n"); printf(" handle1 page 0 in frame 2.\n"); printf(" handle2 page 0 in frame 3.\n"); test_EMMmappage(0, handle2, 1); test_EMMmappage(1, handle1, 4); test_EMMmappage(2, handle1, 0); test_EMMmappage(3, handle2, 0); printf("Mapping done. Verifying... "); if (farmemcheck(frameptr[0], 16384, 0x11) != 0) { printf("Verify failed for frame 0.\n"); test_EMMfree(handle1); test_EMMfree(handle2); exit(3); } if (farmemcheck(frameptr[1], 16384, 4) != 0) { printf("Verify failed for frame 1.\n"); test_EMMfree(handle1); test_EMMfree(handle2); exit(3); } if (farmemcheck(frameptr[2], 16384, 0) != 0) { printf("Verify failed for frame 2.\n"); test_EMMfree(handle1); test_EMMfree(handle2); exit(3); } if (farmemcheck(frameptr[3], 16384, 0x10) != 0) { printf("Verify failed for frame 3.\n"); test_EMMfree(handle1); test_EMMfree(handle2); exit(3); } printf("OK.\n"); TESTTAILER(); /* clean up */ test_EMMfree(handle1); test_EMMfree(handle2); gblmsg = ""; return; } /* end of do_map_tests() */ /*************************************************************************** * FUNCTION: DO_REALLOC_TESTS * * * * DESCRIPTION: * * * * This function tests EMSIF calls EMMrealloc() and EMMreallocpages().* * Note that EMMreallocpages() is not tested directly; if EMMrealloc()* * works, it is only because EMMreallocpages() (which it uses * * internally) is working. * * * * ENTRY: * * * * Void. * * * * EXIT: * * * * Void. * * * * CONSTRAINTS/SIDE EFFECTS: * * * ***************************************************************************/ void do_realloc_tests(void) { unsigned long emsfree, emsfree2; int handle; /* set header */ gblmsg = " REALLOC TESTS"; TESTHEADER(); /* allocate original block */ handle = test_EMMalloc(55555); /* map and fill */ test_EMMmappage(0, handle, 0); test_EMMmappage(1, handle, 1); test_EMMmappage(2, handle, 2); test_EMMmappage(3, handle, 3); FMEMSET(frameptr[0], 0, 16384); FMEMSET(frameptr[1], 1, 16384); FMEMSET(frameptr[2], 2, 16384); FMEMSET(frameptr[3], 3, 16384); /* get current value for free EMS */ emsfree = test_EMMcoreleft(); /* realloc */ printf("Testing EMMrealloc() to make block shorter.\n"); handle = test_EMMrealloc(handle, 48000); /* check free -- should be 16K higher */ emsfree2 = test_EMMcoreleft(); if ((emsfree + 16384L) != emsfree2) { printf("EMMrealloc() should have freed up one page. Old: %lu, new: %lu\n", emsfree, emsfree2); EMMfree(handle); exit(3); } /* check page contents */ test_EMMmappage(0, handle, 0); test_EMMmappage(1, handle, 1); test_EMMmappage(2, handle, 2); if ((farmemcheck(frameptr[0], 16384, 0) != 0) || (farmemcheck(frameptr[1], 16384, 1) != 0) || (farmemcheck(frameptr[2], 16384, 2) != 0)) { printf("EMMrealloc() did not preserve contents.\n"); EMMfree(handle); exit(3); } TESTTAILER(); TESTHEADER(); printf("Testing EMMrealloc() to make block longer.\n"); handle = test_EMMrealloc(handle, 55555); /* check free -- should be same as original */ emsfree2 = test_EMMcoreleft(); if (emsfree != emsfree2) { printf("EMMrealloc() did not allocate as expected.\n"); EMMfree(handle); exit(3); } /* ** check page contents -- contents of new page are undefined so ** don't bother checking it. */ test_EMMmappage(0, handle, 0); test_EMMmappage(1, handle, 1); test_EMMmappage(2, handle, 2); if ((farmemcheck(frameptr[0], 16384, 0) != 0) || (farmemcheck(frameptr[1], 16384, 1) != 0) || (farmemcheck(frameptr[2], 16384, 2) != 0)) { printf("EMMrealloc() did not preserve contents.\n"); EMMfree(handle); exit(3); } TESTTAILER(); /* clean up */ test_EMMfree(handle); gblmsg = ""; return; } /* end of do_realloc_tests() */ /*************************************************************************** * FUNCTION: DO_SR_TESTS * * * * DESCRIPTION: * * * * This function tests the EMSIF mapping save/restore functions: * * EMMsrinit(), EMMsave(), EMMrestore(). * * * * ENTRY: * * * * Void. * * * * EXIT: * * * * Void. * * * * CONSTRAINTS/SIDE EFFECTS: * * * ***************************************************************************/ void do_sr_tests(void) { void *savehandle; int handle1, handle2; int status; int loop; /* set header */ gblmsg = " SAVE/RESTORE TESTS"; /* first, allocate some EMS and fill with unique patterns */ handle1 = test_EMMallocpages(6); handle2 = test_EMMallocpages(2); for (loop = 0; loop < 6; loop++) { test_EMMmappage(0, handle1, loop); FMEMSET(frameptr[0], loop, 16384); if (farmemcheck(frameptr[0], 16384, (unsigned char) loop) != 0) { printf("Verify failed on handle 1, page %d.\n", loop); test_EMMfree(handle1); test_EMMfree(handle2); exit(3); } } test_EMMmappage(0, handle2, 0); FMEMSET(frameptr[0], 0x10, 16384); if (farmemcheck(frameptr[0], 16384, 0x10) != 0) { printf("Verify failed on handle 2, page 0!\n"); test_EMMfree(handle1); test_EMMfree(handle2); exit(3); } test_EMMmappage(0, handle2, 1); FMEMSET(frameptr[0], 0x11, 16384); if (farmemcheck(frameptr[0], 16384, 0x11) != 0) { printf("Verify failed on handle 2, page 1!\n"); test_EMMfree(handle1); test_EMMfree(handle2); exit(3); } TESTHEADER(); printf( "Testing save/restore facility. Calling EMMsave() before EMMsrinit().\n"); printf("Should fail.\n"); savehandle = EMMsave(); nofailcheck("EMMsave()", (int) _EMMerror, NULL, handle1, handle2); weirdcodechk("EMMsave()", EMM_NOSR, NULL, handle1, handle2); printf("EMMsave() failed OK.\n"); TESTTAILER(); TESTHEADER(); printf("Calling EMMsrinit().\nShould %s.\n", ((_EMMversion >= 0x32) ? "succeed" : "fail")); status = EMMsrinit(malloc); if (_EMMversion >= 0x32) { TRIPLECHECK("EMMsrinit()", status, 0, NULL, handle1, handle2); printf("EMMsrinit() succeeded; save/restore facility initialized.\n"); } else { weirdretchk("EMMsrinit()", status, NULL, handle1, handle2); nofailcheck("EMMsrinit()", status, NULL, handle1, handle2); weirdcodechk("EMMsrinit()", EMM_BADVERS, NULL, handle1, handle2); printf("EMMsrinit() failed OK. Skipping other save/restore tests.\n"); } TESTTAILER(); if (_EMMversion >= 0x32) { TESTHEADER(); printf("Testing EMMsave().\n"); printf("Mapping handle 1 pages 0-3 in frames 0-3 respectively.\n"); for (loop = 0; loop < 4; loop++) { test_EMMmappage(loop, handle1, loop); } printf("Calling EMMsave() to save current configuration.\n"); printf("Should succeed.\n"); savehandle = (void *) NULL; savehandle = EMMsave(); if (savehandle == (void *) NULL) { printf("EMMsave() did not return anything, code 0x%X.\n", (unsigned int) _EMMerror); test_EMMfree(handle1); test_EMMfree(handle2); exit(3); } weirdcodechk("EMMsave()", 0, NULL, handle1, handle2); printf("EMMsave() succeeded.\n"); TESTTAILER(); printf("Changing configuration.\n"); test_EMMmappage(0, handle2, 1); test_EMMmappage(1, handle1, 4); test_EMMmappage(2, handle1, 0); test_EMMmappage(3, handle2, 0); TESTHEADER(); printf("Calling EMMrestore() to restore previous configuration.\n"); printf("Should succeed.\n"); status = EMMrestore(savehandle); TRIPLECHECK("EMMrestore()", status, 0, NULL, handle1, handle2); printf("EMMrestore() returned OK, verifying contents... "); for (loop = 0; loop < 4; loop++) { if (farmemcheck(frameptr[loop], 16384, (unsigned char) loop) != 0) { printf("Verify failed for frame %d.\n", loop); test_EMMfree(handle1); test_EMMfree(handle2); exit(3); } } printf("OK.\n"); TESTTAILER(); } printf("Cleaning up.\n"); test_EMMfree(handle1); test_EMMfree(handle2); if (_EMMversion >= 0x32) { free(savehandle); } gblmsg = ""; return; } /* end of do_sr_tests() */ #endif /* !PASS3 */ #endif /* !PASS2 */ /* ** The following group of functions {test_EMM*()} are wrapper functions ** that call the EMSIF function named and perform preliminary checks on ** the return values. This keeps code size down since the check only has ** to be coded in one place. */ /*************************************************************************** * FUNCTION: TEST_EMMCORELEFT * * * * DESCRIPTION: * * * * This function calls EMSIF function EMMcoreleft() and checks the * * return value to see if it is a multiple of 16384 (the EMS page * * size). * * * * ENTRY: * * * * Void. * * * * EXIT: * * * * Returns the value returned by EMMcoreleft(). * * * * CONSTRAINTS/SIDE EFFECTS: * * * ***************************************************************************/ unsigned long test_EMMcoreleft(void) { unsigned long emsfree; /* call EMMcoreleft and check error code */ emsfree = EMMcoreleft(); weirdcodechk("EMMcoreleft()", 0, NULL, 0, 0); /* check if free byte count is multiple of 16384 */ if ((emsfree % 16384L) != 0) { printf("EMMcoreleft() returned strange number %lu.\n", emsfree); exit(3); } return emsfree; } /* end of test_EMMcoreleft() */ /*************************************************************************** * FUNCTION: TEST_EMMALLOC * * * * DESCRIPTION: * * * * This function calls EMSIF function EMMalloc() and checks the * * return codes. * * * * ENTRY: * * * * bytes - bytes of EMS to allocate * * * * EXIT: * * * * Returns the handle returned by EMMalloc(). * * * * CONSTRAINTS/SIDE EFFECTS: * * * ***************************************************************************/ int test_EMMalloc(unsigned long bytes) { int handle; /* call EMMalloc() and check the return */ handle = EMMalloc(bytes); weirdcodechk("EMMalloc()", 0, NULL, 0, 0); return handle; } /* end of test_EMMalloc() */ /*************************************************************************** * FUNCTION: TEST_EMMALLOCPAGES * * * * DESCRIPTION: * * * * This function calls EMSIF function EMMallocpages() and checks the * * return codes. * * * * ENTRY: * * * * pages - pages of EMS to allocate * * * * EXIT: * * * * Returns the handle returned by EMMallocpages(). * * * * CONSTRAINTS/SIDE EFFECTS: * * * ***************************************************************************/ int test_EMMallocpages(int pages) { int handle; /* call EMMallocpages() and check the return */ handle = EMMallocpages(pages); weirdcodechk("EMMallocpages()", 0, NULL, 0, 0); return handle; } /* end of test_EMMallocpages() */ /*************************************************************************** * FUNCTION: TEST_EMMREALLOC * * * * DESCRIPTION: * * * * This function calls EMSIF function EMMrealloc() and checks the * * return codes. * * * * ENTRY: * * * * handle - EMS handle to be resized * * bytes - new size for handle * * * * EXIT: * * * * Returns the handle returned by EMMrealloc(). * * * * CONSTRAINTS/SIDE EFFECTS: * * * ***************************************************************************/ int test_EMMrealloc(int handle, unsigned long bytes) { int newhan; /* call EMMrealloc() and check the return */ newhan = EMMrealloc(handle, bytes); weirdcodechk("EMMrealloc()", 0, NULL, handle, newhan); if (((_EMMversion >= 0x40) && (newhan != handle)) || ((_EMMversion < 0x40) && (newhan == handle))) { printf("Handle problem in EMMrealloc(). New: %d, old: %d\n", newhan, handle); EMMfree(handle); EMMfree(newhan); } return newhan; } /* end of test_EMMrealloc() */ /*************************************************************************** * FUNCTION: TEST_EMMFREE * * * * DESCRIPTION: * * * * This function calls EMSIF function EMMfree() and checks the * * return codes. * * * * ENTRY: * * * * handle - EMS handle to be freed * * * * EXIT: * * * * Void. * * * * CONSTRAINTS/SIDE EFFECTS: * * * ***************************************************************************/ void test_EMMfree(int handle) { int status; /* call EMMfree() and check the return */ status = EMMfree(handle); TRIPLECHECK("EMMfree()", status, 0, NULL, 0, 0); return; } /* end of test_EMMfree() */ /*************************************************************************** * FUNCTION: TEST_EMMMAPPAGE * * * * DESCRIPTION: * * * * This function calls EMSIF function EMMmappage() and checks the * * return codes. * * * * ENTRY: * * * * frameno - frame number to map page into * * handle - handle of page to be mapped * * logpage - page number to map * * * * EXIT: * * * * Void. * * * * CONSTRAINTS/SIDE EFFECTS: * * * ***************************************************************************/ void test_EMMmappage(int frameno, int handle, int logpage) { int status; /* ** do sanity check on frame number, just in case -- we shouldn't be ** trying to map into frames other than standard 0 through 3. */ if ((frameno < 0) || (frameno > 3)) { printf("Sanity check failed, trying to map to frame %d, aborting.\n", frameno); EMMfree(handle); exit(3); } /* call EMMmappage() and check return */ status = EMMmappage(frameno, handle, logpage); TRIPLECHECK("EMMmappage()", status, 0, NULL, handle, 0); return; } /* end of test_EMMmappage() */ /* ** The following group of functions are used to speed up return checking ** and keep code size down, since the return check only has to be coded ** in one place. They are used in various macros to further compact and ** clarify the code. */ /*************************************************************************** * FUNCTION: WEIRDRETCHK * * * * DESCRIPTION: * * * * This function checks to see if the status value passed to it is * * either 0 or EMMOOPS, and assumes something has gone wrong if it * * is not. If something has gone wrong, does some clean up before * * exiting. * * * * ENTRY: * * * * function - name of function which may have goofed * * status - status value to check * * tofree1 - conventional memory block to be freed on exit. Not * * freed if NULL. * * tofree2 - EMS handle to be freed on exit. Not freed if 0. * * tofree2 - another EMS handle to be freed on exit. Not freed if 0. * * * * EXIT: * * * * Void, or may not return. * * * * CONSTRAINTS/SIDE EFFECTS: * * * ***************************************************************************/ void weirdretchk(char *function, int status, void *tofree1, int tofree2, int tofree3) { if ((status != EMMOOPS) && (status != 0)) { printf("%s returned weird value %d, code 0x%X.\n", function, status, (unsigned int) _EMMerror); if (tofree1 != (void *) NULL) { free(tofree1); } if (tofree2 != 0) { EMMfree(tofree2); } if (tofree3 != 0) { EMMfree(tofree3); } exit(3); } return; } /* end of weirdretchk() */ /*************************************************************************** * FUNCTION: WEIRDCODECHK * * * * DESCRIPTION: * * * * This function checks to see if the EMSIF error code value matches * * the expected value, and assumes something has gone wrong if it * * does not. If something has gone wrong, does some clean up before * * exiting. * * * * ENTRY: * * * * function - name of function which may have goofed * * expected - expected value of _EMMerror * * tofree1 - conventional memory block to be freed on exit. Not * * freed if NULL. * * tofree2 - EMS handle to be freed on exit. Not freed if 0. * * tofree2 - another EMS handle to be freed on exit. Not freed if 0. * * * * EXIT: * * * * Void, or may not return. * * * * CONSTRAINTS/SIDE EFFECTS: * * * ***************************************************************************/ void weirdcodechk(char *function, int expected, void *tofree1, int tofree2, int tofree3) { if ((int) _EMMerror != expected) { printf("%s returned unexpected code 0x%X.\n", function, (unsigned int) _EMMerror); if (tofree1 != (void *) NULL) { free(tofree1); } if (tofree2 != 0) { EMMfree(tofree2); } if (tofree3 != 0) { EMMfree(tofree3); } exit(3); } return; } /* end of weirdcodechk() */ /*************************************************************************** * FUNCTION: FAILCHECK * * * * DESCRIPTION: * * * * This function checks to see if the status value passed to it is * * EMMOOPS and exits if it is. failcheck() is used when a function * * is expected to succeed. Does some clean up before exiting. * * * * ENTRY: * * * * function - name of function which may have goofed * * status - status value to be checked * * tofree1 - conventional memory block to be freed on exit. Not * * freed if NULL. * * tofree2 - EMS handle to be freed on exit. Not freed if 0. * * tofree2 - another EMS handle to be freed on exit. Not freed if 0. * * * * EXIT: * * * * Void, or may not return. * * * * CONSTRAINTS/SIDE EFFECTS: * * * ***************************************************************************/ void failcheck(char *function, int status, void *tofree1, int tofree2, int tofree3) { if (status == EMMOOPS) { printf("%s failed, code 0x%X.\n", function, (unsigned int) _EMMerror); if (tofree1 != (void *) NULL) { free(tofree1); } if (tofree2 != 0) { EMMfree(tofree2); } if (tofree3 != 0) { EMMfree(tofree3); } exit(3); } return; } /* end of failcheck() */ /*************************************************************************** * FUNCTION: NOFAILCHECK * * * * DESCRIPTION: * * * * This function checks to see if the status value passed to it is * * 0 and exits if it is. nofailcheck() is used when a function is * * expected to fail. Does some clean up before exiting. * * * * ENTRY: * * * * function - name of function which may have goofed * * status - status value to be checked * * tofree1 - conventional memory block to be freed on exit. Not * * freed if NULL. * * tofree2 - EMS handle to be freed on exit. Not freed if 0. * * tofree2 - another EMS handle to be freed on exit. Not freed if 0. * * * * EXIT: * * * * Void, or may not return. * * * * CONSTRAINTS/SIDE EFFECTS: * * * ***************************************************************************/ void nofailcheck(char *function, int status, void *tofree1, int tofree2, int tofree3) { if (status == 0) { printf("%s did not fail.\n", function); if (tofree1 != (void *) NULL) { free(tofree1); } if (tofree2 != 0) { EMMfree(tofree2); } if (tofree3 != 0) { EMMfree(tofree3); } exit(3); } return; } /* end of nofailcheck() */