TestCase * Grader07::grade(int index){
switch(index){
case 0:
return testStringSearch("string_search_1.bin", "sequence_small.txt");
case 1:
return testStringSearch("string_search_2.bin", "sequence_large.txt");
case 2:
return testStringSort("string_sort_input_1.txt");
case 3:
return testStringSort("string_sort_input_2.txt");
case 4:
return testSpellCheck("spell_check_1.bin");
case 5:
return testSpellCheck("spell_check_2.bin");
case 6:
return testCompress("sequence_small.txt", "compress_output.bin");
case 7:
return testDecompress("compress_output.bin", "sequence_small.txt");
case 8:
return testCompress("sequence_medium.txt", "compress_output.bin");
case 9:
return testDecompress("compress_output.bin", "sequence_medium.txt");
default:
return NULL;
}
}
int PCFS_compress(int fd, const char* buf, size_t size, uLong offset)
{
wrBuf = (unsigned char *) calloc (size, sizeof(unsigned char));
mark=(unsigned char *) calloc(PAGE_SIZE, sizeof(unsigned char));
return testCompress(fd, buf, size);
}
/***********************************************************************************************************************************
Test Run
***********************************************************************************************************************************/
void
testRun(void)
{
FUNCTION_HARNESS_VOID();
// *****************************************************************************************************************************
if (testBegin("gzipError"))
{
TEST_RESULT_INT(gzipError(Z_OK), Z_OK, "check ok");
TEST_RESULT_INT(gzipError(Z_STREAM_END), Z_STREAM_END, "check stream end");
TEST_ERROR(gzipError(Z_NEED_DICT), AssertError, "zlib threw error: [2] need dictionary");
TEST_ERROR(gzipError(Z_ERRNO), AssertError, "zlib threw error: [-1] file error");
TEST_ERROR(gzipError(Z_STREAM_ERROR), FormatError, "zlib threw error: [-2] stream error");
TEST_ERROR(gzipError(Z_DATA_ERROR), FormatError, "zlib threw error: [-3] data error");
TEST_ERROR(gzipError(Z_MEM_ERROR), MemoryError, "zlib threw error: [-4] insufficient memory");
TEST_ERROR(gzipError(Z_BUF_ERROR), AssertError, "zlib threw error: [-5] no space in buffer");
TEST_ERROR(gzipError(Z_VERSION_ERROR), FormatError, "zlib threw error: [-6] incompatible version");
TEST_ERROR(gzipError(999), AssertError, "zlib threw error: [999] unknown error");
}
// *****************************************************************************************************************************
if (testBegin("gzipWindowBits"))
{
TEST_RESULT_INT(gzipWindowBits(true), -15, "raw window bits");
TEST_RESULT_INT(gzipWindowBits(false), 31, "gzip window bits");
}
// *****************************************************************************************************************************
if (testBegin("GzipCompress and GzipDecompress"))
{
const char *simpleData = "A simple string";
Buffer *compressed = NULL;
Buffer *decompressed = bufNewC(simpleData, strlen(simpleData));
TEST_ASSIGN(
compressed, testCompress(gzipCompressNew(3, false), decompressed, 1024, 1024),
"simple data - compress large in/large out buffer");
TEST_RESULT_BOOL(
bufEq(compressed, testCompress(gzipCompressNew(3, false), decompressed, 1024, 1)), true,
"simple data - compress large in/small out buffer");
TEST_RESULT_BOOL(
bufEq(compressed, testCompress(gzipCompressNew(3, false), decompressed, 1, 1024)), true,
"simple data - compress small in/large out buffer");
TEST_RESULT_BOOL(
bufEq(compressed, testCompress(gzipCompressNew(3, false), decompressed, 1, 1)), true,
"simple data - compress small in/small out buffer");
TEST_RESULT_BOOL(
bufEq(decompressed, testDecompress(gzipDecompressNew(false), compressed, 1024, 1024)), true,
"simple data - decompress large in/large out buffer");
TEST_RESULT_BOOL(
bufEq(decompressed, testDecompress(gzipDecompressNew(false), compressed, 1024, 1)), true,
"simple data - decompress large in/small out buffer");
TEST_RESULT_BOOL(
bufEq(decompressed, testDecompress(gzipDecompressNew(false), compressed, 1, 1024)), true,
"simple data - decompress small in/large out buffer");
TEST_RESULT_BOOL(
bufEq(decompressed, testDecompress(gzipDecompressNew(false), compressed, 1, 1)), true,
"simple data - decompress small in/small out buffer");
// Compress a large zero input buffer into small output buffer
// -------------------------------------------------------------------------------------------------------------------------
decompressed = bufNew(1024 * 1024 - 1);
memset(bufPtr(decompressed), 0, bufSize(decompressed));
bufUsedSet(decompressed, bufSize(decompressed));
TEST_ASSIGN(
compressed, testCompress(gzipCompressNew(3, true), decompressed, bufSize(decompressed), 1024),
"zero data - compress large in/small out buffer");
TEST_RESULT_BOOL(
bufEq(decompressed, testDecompress(gzipDecompressNew(true), compressed, bufSize(compressed), 1024 * 256)), true,
"zero data - decompress large in/small out buffer");
}
// *****************************************************************************************************************************
if (testBegin("gzipDecompressToLog() and gzipCompressToLog()"))
{
GzipDecompress *decompress = (GzipDecompress *)ioFilterDriver(gzipDecompressNew(false));
TEST_RESULT_STR(strPtr(gzipDecompressToLog(decompress)), "{inputSame: false, done: false, availIn: 0}", "format object");
decompress->inputSame = true;
decompress->done = true;
TEST_RESULT_STR(strPtr(gzipDecompressToLog(decompress)), "{inputSame: true, done: true, availIn: 0}", "format object");
}
FUNCTION_HARNESS_RESULT_VOID();
}
void run() override
{
testSpecial();
testCompress();
}
/* if don't have any envorin variable at all */
int main(int argc, char **argv, char **envp)
#endif
#endif
{
rlim_t memlock_limit = -2;
int error = 0,
max_mem_lock = 0,
memory_safe = 0,
ptrace_safe = 0;
#ifdef TEST_OPTION
int testrun = 0;
#endif
char* binaryname;
savetermios();
TRACE(99, "main()", NULL);
#ifndef HAVE_EXTERN_ENVIRON
#ifndef MANUAL_EXTERN_ENVIRON
/* since in solaris environ does not exist, we manually pass it along */
environ = envp;
#endif
#endif
if (initSecurity(&max_mem_lock, &memory_safe, &ptrace_safe, &memlock_limit))
{ exit(1); }
/* we initialize gettext */
setlocale(LC_ALL, "");
#ifdef TEST_OPTION
bindtextdomain(PACKAGE_NAME, "./po/");
#else
bindtextdomain(PACKAGE_NAME, LOCALEDIR);
#endif
textdomain(PACKAGE_NAME);
#ifndef LIBXML_TREE_ENABLED
fprintf(stderr, _("Tree support not compiled in to libxml2 %s\n"),
LIBXML_DOTTED_VERSION);
exit(1);
#endif
/*
* This function installs "sighandler" to handle the SIGINT and returns a
* pointer to the previously installed handler for this signal (which is
* the default handler SIG_DFL initially). If we try to install another
* handler to handle SIGINT at some other time... Then the new handler
* replaces this current one and returns a pointer to this handler.
*/
signal(SIGINT, sighandler);
signal(SIGTERM, sighandler);
/* the SIGWINCH handler is set in userInterface() */
initConfiguration();
runtime -> memlock_limit = memlock_limit;
runtime -> max_mem_lock = max_mem_lock;
runtime -> memory_safe = memory_safe;
runtime -> ptrace_safe = ptrace_safe;
initKeys();
initPatternparser();
initXML();
initXMLInterface();
if (getOptions(argc, argv))
{
fprintf(stderr, _("Try `%s --help' for more information.\n"), argv[0]);
error = 1;
}
if (!error && config -> help)
{ showHelp(); }
else if (!error && config -> version)
{ showVersion(); }
else if (!error)
{
getDefaultOptions();
if (readResources())
return 1;
if (config -> dbfilecmd)
{ /* the --file option must overwrite the resource file */
runtime -> dbfile = resolveFilelink(config -> dbfilecmd);
}
else
{ /* we use the resource file configuration or the compiletime
* default
*/
runtime -> dbfile = resolveFilelink(config -> dbfilerc);
}
}
/* we switch to read-only mode on request */
if (config -> readonly)
{ runtime -> readonly = 1; }
/* in case our basename is cpmv, we switch to read-only mode */
binaryname = basename(argv[0]);
if (!strcmp(binaryname, "cpmv"))
{ runtime -> readonly = 1; }
initGPG();
if (!error && config -> security)
{ checkSecurity(0); }
#ifdef TEST_OPTION
if (!error &&
config -> testrun &&
!strncmp(config -> testrun, "compress", 8))
{
testCompress();
testrun = 1;
}
if (!error &&
config -> testrun &&
!strcmp(config -> testrun, "environment"))
{
testEnvironment();
testrun = 1;
}
if (!error &&
config -> testrun && (
!strcmp(config -> testrun, "backup") ||
!strcmp(config -> testrun, "garbage") ||
!strcmp(config -> testrun, "searchpattern")))
{ testrun = 1; }
#endif
if (config -> configtest &&
!error)
{ fprintf(stderr, _("configuration ok.\n")); }
if (config -> environtmentlist &&
!error)
{ listEnvironment(); }
if (!error &&
!config -> configtest &&
!config -> environtmentlist &&
!config -> help &&
!config -> security &&
!config -> version)
{
#ifdef TEST_OPTION
if (checkSecurity(1) != MAX_SECURITY_LEVEL &&
!config -> testrun)
#else
if (checkSecurity(1) != MAX_SECURITY_LEVEL)
#endif
{
checkSecurity(0);
printf("\n%s %s\n%s\n",
_("Maximum security level not reached."),
_("Your database will be less protected while CPM is running."),
_("Are you sure you want to continue?"),
_("Press CTRL+C to stop now or ENTER to continue."));
fgetc(stdin);
}
if (runtime -> guimode)
{ /* we run in interactive mode */
userInterface();
}
else
{ /* we run in CLI mode */
error = cliInterface();
#ifdef TEST_OPTION
if (error == 2)
{ /* for testruns, we must modify the stuff a little */
error = 0;
testrun = 1;
}
#endif
}
}
freeGPG();
freeXMLInterface();
freeUTF8Interface();
freeXML();
freePatternparser();
freeKeys();
freeConfiguration();
if (memCheck())
{ /* we validate our memory consumption */
fprintf(stderr, _("error: memory leak detected.\n"));
if (memCheck() > 0)
{
fprintf(stderr, _("%ld byte of memory were not freed.\n"),
memCheck());
}
else
{
fprintf(stderr,
_("%ld byte of memory were freed without being allocated.\n"),
memCheck());
}
fprintf(stderr, _("Please send a report about this problem to Harry Brueckner <*****@*****.**>.\n"));
error = 1;
}
#ifdef TEST_OPTION
if (testrun)
{ return 0; }
else
{ return error; }
#else
return error;
#endif
}
