consumers/dftest/src/main.c - incubator-retired-corinthia - Git at Google

 // Licensed to the Apache Software Foundation (ASF) under one
 // or more contributor license agreements.  See the NOTICE file
 // distributed with this work for additional information
 // regarding copyright ownership.  The ASF licenses this file
 // to you under the Apache License, Version 2.0 (the
 // "License"); you may not use this file except in compliance
 // with the License.  You may obtain a copy of the License at
 //
 //   http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing,
 // software distributed under the License is distributed on an
 // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 // KIND, either express or implied.  See the License for the
 // specific language governing permissions and limitations
 // under the License.

 #include "DFPlatform.h"
 #include "DFUnitTest.h"
 #include "TextPackage.h"
 #include "DFString.h"
 #include "DFFilesystem.h"
 #include "DFCommon.h"
 #include "DFUnitTest.h"
 #include "DFArray.h"
 #include "DFBuffer.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <errno.h>

 extern TestGroup APITests;
 extern TestGroup CSSTests;
 extern TestGroup HTMLTests;
 extern TestGroup LibTests;
 extern TestGroup XMLTests;
 extern TestGroup LaTeXTests;
 extern TestGroup ODFTests;
 extern TestGroup WordTests;
 extern TestGroup PlatformOSTests;
 extern TestGroup PlatformWrapperTests;
 extern TestGroup BDTTests;

 TestGroup *allGroups[] = {
     &APITests,
     &BDTTests,
     &CSSTests,
     &HTMLTests,
     &LibTests,
     &XMLTests,
     &LaTeXTests,
     &ODFTests,
     &WordTests,
     &PlatformOSTests,
     &PlatformWrapperTests,
     NULL
 };

 typedef struct {
     int showResults;
     int showDiffs;
     int passed;
     int failed;
 } TestHarness;

 static int diffResults(const char *from, const char *to, DFError **error)
 {
     const char *fromFilename = "dftest-diff-from.tmp";
     const char *toFilename = "dftest-diff-to.tmp";
     int result = 0;
     if (!DFStringWriteToFile(from,fromFilename,error)) {
         DFErrorFormat(error,"%s: %s",fromFilename,DFErrorMessage(error));
     }
     else if (!DFStringWriteToFile(to,toFilename,error)) {
         DFErrorFormat(error,"%s: %s",toFilename,DFErrorMessage(error));
     }
     else {
         char *cmd = DFFormatString("diff -u %s %s",fromFilename,toFilename);
         system(cmd);
         free(cmd);
         result = 1;
     }
     DFDeleteFile(fromFilename,NULL);
     DFDeleteFile(toFilename,NULL);
     return result;
 }

 static char *getCommandFromCode(const char *code, DFError **error)
 {
     char *command = NULL;
     const char **lines = DFStringSplit(code,"\n",0);
     int count = 0;
     for (int i = 0; lines[i]; i++) {
         if (!DFStringIsWhitespace(lines[i]) && strncmp(lines[i],"//",2)) {
             if (command == NULL)
                 command = xstrdup(lines[i]);
             count++;
         }
     }
     free(lines);

     if (count != 1) {
         DFErrorFormat(error,"%d commands found",count);
         free(command);
         return NULL;
     }
     else {
         return command;
     }
 }

 static const char **parseCommand(const char *command, DFError **error)
 {
     const char *openbr = strchr(command,'(');
     const char *closebr = strrchr(command,')');

     if ((openbr == NULL) && (closebr == NULL)) {
         DFArray *array = DFArrayNew((DFCopyFunction)xstrdup,free);
         DFArrayAppend(array,(void *)command);
         const char **result = DFStringArrayFlatten(array);
         DFArrayRelease(array);
         return result;
     }

     if ((openbr == NULL) || (closebr == NULL)) {
         DFErrorFormat(error,"Malformed command: %s\n",command);
         return NULL;
     }

     size_t openpos = openbr - command;
     size_t closepos = closebr - command;
     size_t nameend = openpos;

     if ((openpos+2 <= closepos) && (command[openpos+1] == '{') && (command[closepos-1] == '}')) {
         openpos++;
         closepos--;
     }

     char *name = DFSubstring(command,0,nameend);
     char *arguments = DFSubstring(command,openpos+1,closepos);

     const char **components = DFStringSplit(arguments,",",0);
     DFArray *array = DFArrayNew((DFCopyFunction)xstrdup,free);
     DFArrayAppend(array,name);
     for (int i = 0; components[i]; i++) {
         char *trimmed = DFStringTrimWhitespace(components[i]);
         DFArrayAppend(array,trimmed);
         free(trimmed);
     }

     const char **result = DFStringArrayFlatten(array);

     free(components);
     free(name);
     free(arguments);
     DFArrayRelease(array);
     return result;
 }

 static void TestRun(TestHarness *harness, const char *path)
 {
     DFError *error = NULL;
     TextPackage *package = TextPackageNewWithFile(path,&error);
     int pass = 0;
     if (package != NULL) {
         DFHashTable *dict = DFHashTableCopy(package->items);

         char *code = DFStrDup(DFHashTableLookup(dict,""));
         DFHashTableRemove(dict,"");

         char *command = getCommandFromCode(code,&error);
         if (command == NULL) {
             printf("%s: %s\n",path,DFErrorMessage(&error));
             exit(1);
         }

         const char **arguments = parseCommand(command,&error);
         if (arguments == NULL) {
             printf("%s: %s\n",path,DFErrorMessage(&error));
             exit(1);
         }

         char *expectedRaw = DFStrDup(DFHashTableLookup(dict,"expected"));
         if (expectedRaw == NULL) {
             printf("%s: no expected output given\n",path);
             exit(1);
         }
         DFHashTableRemove(dict,"expected");

         char *parentPath = DFPathDirName(path);
         DFBuffer *outputBuf = DFBufferNew();
         utsetup(parentPath,dict,(int)(DFStringArrayCount(arguments)-1),&arguments[1],
                 outputBuf);

         TestCase *tc = utlookup(allGroups,arguments[0]);
         if (tc != NULL) {
             tc->fun();
         }
         else {
             DFBufferFormat(utgetoutput(),"Unknown test: %s\n",arguments[0]);
         }

         char *output = DFStringTrimWhitespace(outputBuf->data);
         char *expected = DFStringTrimWhitespace(expectedRaw);

         if (harness->showResults && !harness->showDiffs) {
             printf("%s",outputBuf->data);
         }
         else {
             pass = ((expected != NULL) && DFStringEquals(expected,output));
         }

         if (!pass && harness->showDiffs) {
             if (!diffResults(expected,output,&error))
                 printf("%s\n",DFErrorMessage(&error));
         }

         free(output);
         free(code);
         free(command);
         free(arguments);
         free(expectedRaw);
         free(parentPath);
         free(expected);
         utteardown();
         DFBufferRelease(outputBuf);
         DFHashTableRelease(dict);
     }
     else {
         if (harness->showResults || harness->showDiffs)
             printf("%s\n",DFErrorMessage(&error));
     }

     if (!harness->showResults) {
         if (pass) {
             printf("%-80s PASS\n",path);
             harness->passed++;
         }
         else {
             printf("%-80s FAIL\n",path);
             harness->failed++;
         }
     }
     TextPackageRelease(package);
 }

 static void TestGetFilenamesRecursive(const char *path, DFArray *result)
 {
     if (!DFFileExists(path))
         return;
     int isDirectory = DFIsDirectory(path);
     if (isDirectory) {
         DFError *error = NULL;
         const char **contents = DFContentsOfDirectory(path,0,&error);
         if (contents == NULL) {
             printf("%s: %s\n",path,DFErrorMessage(&error));
             DFErrorRelease(error);
             return;
         }

         DFSortStringsCaseInsensitive(contents);

         for (int i = 0; contents[i]; i++) {
             const char *filename = contents[i];
             char *childPath = DFAppendPathComponent(path,filename);
             TestGetFilenamesRecursive(childPath,result);
             free(childPath);
         }
         free(contents);
     }
     else {
         char *extension = DFPathExtension(path);
         if (DFStringEqualsCI(extension,"test"))
             DFArrayAppend(result,(void *)path);
         free(extension);
     }
 }

 void runTests(int argc, const char **argv, int diff)
 {
     DFArray *tests = DFArrayNew((DFCopyFunction)xstrdup,(DFFreeFunction)free);
     for (int i = 0; i < argc; i++) {
         const char *path = argv[i];
         if (!DFFileExists(path)) {
             fprintf(stderr,"%s: No such file or directory\n",path);
             exit(1);
         }
         TestGetFilenamesRecursive(path,tests);
     }

     TestHarness harness;
     bzero(&harness,sizeof(TestHarness));
     harness.showResults = (DFArrayCount(tests) == 1);
     harness.showDiffs = diff;

     if (DFArrayCount(tests) == 1) {
         TestRun(&harness,(const char *)DFArrayItemAt(tests,0));
     }
     else {
         for (size_t i = 0; i < DFArrayCount(tests); i++) {
             const char *test = DFArrayItemAt(tests,i);
             TestRun(&harness,test);
         }
         printf("Passed: %d\n",harness.passed);
         printf("Failed: %d\n",harness.failed);
     }
     DFArrayRelease(tests);
 }

 int main(int argc, const char **argv)
 {
     // Ensure that if a segfault occurs half-way through printing a line,
     // we still get the partial output.
     setbuf(stdout,NULL);

     if ((argc >= 2) && !strcmp(argv[1],"-plain")) {
       if (argc == 2)
         utrun(allGroups, 1, 0, NULL);
       else {
         // Arg[2] == testgroup to run
         TestGroup *singleGroup[] = { NULL, NULL };
         int        i = 0;

         for (; allGroups[i] && strcmp(argv[2], allGroups[i]->name); i++) ;
         if (allGroups[i]) {
           singleGroup[0] = allGroups[i];
           utrun(singleGroup, 1, 0, NULL);
         }
         else
           printf("\n function group \"%s\" does not exist!\n\n", argv[2]);
       }
     }
     else if ((argc >= 3) && !strcmp(argv[1],"-diff")) {
         runTests(argc-2,&argv[2],1);
     }
     else if (argc >= 2) {
         runTests(argc-1,&argv[1],0);
     }
     else {
         // Usage
         printf("Usage:\n"
                "\n"
                "dftest path1 path2 ...\n"
                "\n"
                "    Run a series of automated tests, consisting of all the .test files in the\n"
                "    specified path(s). If only one file is found, the test is run and the\n"
                "    result is printed to standard output. If multiple files are found, they are\n"
                "    all run, and their pass/fail status is printed.\n"
                "\n"
                "dftest -diff path1 path2 ...\n"
                "\n"
                "    As above, but for each test that fails, print out a diff between the expected\n"
                "    and actual results.\n"
                "\n"
                "dftest -plain\n"
                "\n"
                "    Run all tests functions of type PlainTest, which don't use any data files\n"
                "\n");
     }
     return 0;
 }
	// Licensed to the Apache Software Foundation (ASF) under one
	// or more contributor license agreements. See the NOTICE file
	// distributed with this work for additional information
	// regarding copyright ownership. The ASF licenses this file
	// to you under the Apache License, Version 2.0 (the
	// "License"); you may not use this file except in compliance
	// with the License. You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing,
	// software distributed under the License is distributed on an
	// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	// KIND, either express or implied. See the License for the
	// specific language governing permissions and limitations
	// under the License.

	#include "DFPlatform.h"
	#include "DFUnitTest.h"
	#include "TextPackage.h"
	#include "DFString.h"
	#include "DFFilesystem.h"
	#include "DFCommon.h"
	#include "DFUnitTest.h"
	#include "DFArray.h"
	#include "DFBuffer.h"
	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>
	#include <errno.h>

	extern TestGroup APITests;
	extern TestGroup CSSTests;
	extern TestGroup HTMLTests;
	extern TestGroup LibTests;
	extern TestGroup XMLTests;
	extern TestGroup LaTeXTests;
	extern TestGroup ODFTests;
	extern TestGroup WordTests;
	extern TestGroup PlatformOSTests;
	extern TestGroup PlatformWrapperTests;
	extern TestGroup BDTTests;

	TestGroup *allGroups[] = {
	&APITests,
	&BDTTests,
	&CSSTests,
	&HTMLTests,
	&LibTests,
	&XMLTests,
	&LaTeXTests,
	&ODFTests,
	&WordTests,
	&PlatformOSTests,
	&PlatformWrapperTests,
	NULL
	};

	typedef struct {
	int showResults;
	int showDiffs;
	int passed;
	int failed;
	} TestHarness;

	static int diffResults(const char from, const char to, DFError **error)
	{
	const char *fromFilename = "dftest-diff-from.tmp";
	const char *toFilename = "dftest-diff-to.tmp";
	int result = 0;
	if (!DFStringWriteToFile(from,fromFilename,error)) {
	DFErrorFormat(error,"%s: %s",fromFilename,DFErrorMessage(error));
	}
	else if (!DFStringWriteToFile(to,toFilename,error)) {
	DFErrorFormat(error,"%s: %s",toFilename,DFErrorMessage(error));
	}
	else {
	char *cmd = DFFormatString("diff -u %s %s",fromFilename,toFilename);
	system(cmd);
	free(cmd);
	result = 1;
	}
	DFDeleteFile(fromFilename,NULL);
	DFDeleteFile(toFilename,NULL);
	return result;
	}

	static char getCommandFromCode(const char code, DFError **error)
	{
	char *command = NULL;
	const char **lines = DFStringSplit(code,"\n",0);
	int count = 0;
	for (int i = 0; lines[i]; i++) {
	if (!DFStringIsWhitespace(lines[i]) && strncmp(lines[i],"//",2)) {
	if (command == NULL)
	command = xstrdup(lines[i]);
	count++;
	}
	}
	free(lines);

	if (count != 1) {
	DFErrorFormat(error,"%d commands found",count);
	free(command);
	return NULL;
	}
	else {
	return command;
	}
	}

	static const char *parseCommand(const char command, DFError **error)
	{
	const char *openbr = strchr(command,'(');
	const char *closebr = strrchr(command,')');

	if ((openbr == NULL) && (closebr == NULL)) {
	DFArray *array = DFArrayNew((DFCopyFunction)xstrdup,free);
	DFArrayAppend(array,(void *)command);
	const char **result = DFStringArrayFlatten(array);
	DFArrayRelease(array);
	return result;
	}

	if ((openbr == NULL) \|\| (closebr == NULL)) {
	DFErrorFormat(error,"Malformed command: %s\n",command);
	return NULL;
	}

	size_t openpos = openbr - command;
	size_t closepos = closebr - command;
	size_t nameend = openpos;

	if ((openpos+2 <= closepos) && (command[openpos+1] == '{') && (command[closepos-1] == '}')) {
	openpos++;
	closepos--;
	}

	char *name = DFSubstring(command,0,nameend);
	char *arguments = DFSubstring(command,openpos+1,closepos);

	const char **components = DFStringSplit(arguments,",",0);
	DFArray *array = DFArrayNew((DFCopyFunction)xstrdup,free);
	DFArrayAppend(array,name);
	for (int i = 0; components[i]; i++) {
	char *trimmed = DFStringTrimWhitespace(components[i]);
	DFArrayAppend(array,trimmed);
	free(trimmed);
	}

	const char **result = DFStringArrayFlatten(array);

	free(components);
	free(name);
	free(arguments);
	DFArrayRelease(array);
	return result;
	}

	static void TestRun(TestHarness harness, const char path)
	{
	DFError *error = NULL;
	TextPackage *package = TextPackageNewWithFile(path,&error);
	int pass = 0;
	if (package != NULL) {
	DFHashTable *dict = DFHashTableCopy(package->items);

	char *code = DFStrDup(DFHashTableLookup(dict,""));
	DFHashTableRemove(dict,"");

	char *command = getCommandFromCode(code,&error);
	if (command == NULL) {
	printf("%s: %s\n",path,DFErrorMessage(&error));
	exit(1);
	}

	const char **arguments = parseCommand(command,&error);
	if (arguments == NULL) {
	printf("%s: %s\n",path,DFErrorMessage(&error));
	exit(1);
	}

	char *expectedRaw = DFStrDup(DFHashTableLookup(dict,"expected"));
	if (expectedRaw == NULL) {
	printf("%s: no expected output given\n",path);
	exit(1);
	}
	DFHashTableRemove(dict,"expected");

	char *parentPath = DFPathDirName(path);
	DFBuffer *outputBuf = DFBufferNew();
	utsetup(parentPath,dict,(int)(DFStringArrayCount(arguments)-1),&arguments[1],
	outputBuf);

	TestCase *tc = utlookup(allGroups,arguments[0]);
	if (tc != NULL) {
	tc->fun();
	}
	else {
	DFBufferFormat(utgetoutput(),"Unknown test: %s\n",arguments[0]);
	}

	char *output = DFStringTrimWhitespace(outputBuf->data);
	char *expected = DFStringTrimWhitespace(expectedRaw);

	if (harness->showResults && !harness->showDiffs) {
	printf("%s",outputBuf->data);
	}
	else {
	pass = ((expected != NULL) && DFStringEquals(expected,output));
	}

	if (!pass && harness->showDiffs) {
	if (!diffResults(expected,output,&error))
	printf("%s\n",DFErrorMessage(&error));
	}

	free(output);
	free(code);
	free(command);
	free(arguments);
	free(expectedRaw);
	free(parentPath);
	free(expected);
	utteardown();
	DFBufferRelease(outputBuf);
	DFHashTableRelease(dict);
	}
	else {
	if (harness->showResults \|\| harness->showDiffs)
	printf("%s\n",DFErrorMessage(&error));
	}

	if (!harness->showResults) {
	if (pass) {
	printf("%-80s PASS\n",path);
	harness->passed++;
	}
	else {
	printf("%-80s FAIL\n",path);
	harness->failed++;
	}
	}
	TextPackageRelease(package);
	}

	static void TestGetFilenamesRecursive(const char path, DFArray result)
	{
	if (!DFFileExists(path))
	return;
	int isDirectory = DFIsDirectory(path);
	if (isDirectory) {
	DFError *error = NULL;
	const char **contents = DFContentsOfDirectory(path,0,&error);
	if (contents == NULL) {
	printf("%s: %s\n",path,DFErrorMessage(&error));
	DFErrorRelease(error);
	return;
	}

	DFSortStringsCaseInsensitive(contents);

	for (int i = 0; contents[i]; i++) {
	const char *filename = contents[i];
	char *childPath = DFAppendPathComponent(path,filename);
	TestGetFilenamesRecursive(childPath,result);
	free(childPath);
	}
	free(contents);
	}
	else {
	char *extension = DFPathExtension(path);
	if (DFStringEqualsCI(extension,"test"))
	DFArrayAppend(result,(void *)path);
	free(extension);
	}
	}

	void runTests(int argc, const char **argv, int diff)
	{
	DFArray *tests = DFArrayNew((DFCopyFunction)xstrdup,(DFFreeFunction)free);
	for (int i = 0; i < argc; i++) {
	const char *path = argv[i];
	if (!DFFileExists(path)) {
	fprintf(stderr,"%s: No such file or directory\n",path);
	exit(1);
	}
	TestGetFilenamesRecursive(path,tests);
	}

	TestHarness harness;
	bzero(&harness,sizeof(TestHarness));
	harness.showResults = (DFArrayCount(tests) == 1);
	harness.showDiffs = diff;

	if (DFArrayCount(tests) == 1) {
	TestRun(&harness,(const char *)DFArrayItemAt(tests,0));
	}
	else {
	for (size_t i = 0; i < DFArrayCount(tests); i++) {
	const char *test = DFArrayItemAt(tests,i);
	TestRun(&harness,test);
	}
	printf("Passed: %d\n",harness.passed);
	printf("Failed: %d\n",harness.failed);
	}
	DFArrayRelease(tests);
	}

	int main(int argc, const char **argv)
	{
	// Ensure that if a segfault occurs half-way through printing a line,
	// we still get the partial output.
	setbuf(stdout,NULL);

	if ((argc >= 2) && !strcmp(argv[1],"-plain")) {
	if (argc == 2)
	utrun(allGroups, 1, 0, NULL);
	else {
	// Arg[2] == testgroup to run
	TestGroup *singleGroup[] = { NULL, NULL };
	int i = 0;

	for (; allGroups[i] && strcmp(argv[2], allGroups[i]->name); i++) ;
	if (allGroups[i]) {
	singleGroup[0] = allGroups[i];
	utrun(singleGroup, 1, 0, NULL);
	}
	else
	printf("\n function group \"%s\" does not exist!\n\n", argv[2]);
	}
	}
	else if ((argc >= 3) && !strcmp(argv[1],"-diff")) {
	runTests(argc-2,&argv[2],1);
	}
	else if (argc >= 2) {
	runTests(argc-1,&argv[1],0);
	}
	else {
	// Usage
	printf("Usage:\n"
	"\n"
	"dftest path1 path2 ...\n"
	"\n"
	" Run a series of automated tests, consisting of all the .test files in the\n"
	" specified path(s). If only one file is found, the test is run and the\n"
	" result is printed to standard output. If multiple files are found, they are\n"
	" all run, and their pass/fail status is printed.\n"
	"\n"
	"dftest -diff path1 path2 ...\n"
	"\n"
	" As above, but for each test that fails, print out a diff between the expected\n"
	" and actual results.\n"
	"\n"
	"dftest -plain\n"
	"\n"
	" Run all tests functions of type PlainTest, which don't use any data files\n"
	"\n");
	}
	return 0;
	}