mkrf 0.1.0

data/test/sample_files/syck-0.55/tests/CuTest.c

@@ -0,0 +1,294 @@
+#include <assert.h>
+#include <setjmp.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "CuTest.h"
+
+/*-------------------------------------------------------------------------*
+ * CuStr
+ *-------------------------------------------------------------------------*/
+
+char* CuStrAlloc(int size)
+{
+	char* new = (char*) malloc( sizeof(char) * (size) );
+	return new;
+}
+
+char* CuStrCopy(char* old)
+{
+	int len = strlen(old);
+	char* new = CuStrAlloc(len + 1);
+	strcpy(new, old);
+	return new;
+}
+
+/*-------------------------------------------------------------------------*
+ * CuString
+ *-------------------------------------------------------------------------*/
+
+void CuStringInit(CuString* str)
+{
+	str->length = 0;
+	str->size = STRING_MAX;
+	str->buffer = (char*) malloc(sizeof(char) * str->size);
+	str->buffer[0] = '\0';
+}
+
+CuString* CuStringNew(void)
+{
+	CuString* str = (CuString*) malloc(sizeof(CuString));
+	str->length = 0;
+	str->size = STRING_MAX;
+	str->buffer = (char*) malloc(sizeof(char) * str->size);
+	str->buffer[0] = '\0';
+	return str;
+}
+
+void CuStringResize(CuString* str, int newSize)
+{
+	str->buffer = (char*) realloc(str->buffer, sizeof(char) * newSize);
+	str->size = newSize;
+}
+
+void CuStringAppend(CuString* str, char* text)
+{
+	int length = strlen(text);
+    CuStringAppendLen(str, text, length);
+}
+
+void CuStringAppendLen(CuString* str, char* text, long length)
+{
+	if (str->length + length + 1 >= str->size)
+		CuStringResize(str, str->length + length + 1 + STRING_INC);
+	str->length += length;
+	strcat(str->buffer, text);
+}
+
+void CuStringAppendChar(CuString* str, char ch)
+{
+	char text[2];
+	text[0] = ch;
+	text[1] = '\0';
+	CuStringAppend(str, text);
+}
+
+void CuStringAppendFormat(CuString* str, char* format, ...)
+{
+	va_list argp;
+	char buf[HUGE_STRING_LEN];
+	va_start(argp, format);
+	vsprintf(buf, format, argp);
+	va_end(argp);
+	CuStringAppend(str, buf);
+}
+
+void CuStringFree(CuString* str)
+{
+    if ( str != NULL )
+    {
+        free( str->buffer );
+        free( str );
+    }
+}
+
+/*-------------------------------------------------------------------------*
+ * CuTest
+ *-------------------------------------------------------------------------*/
+
+void CuTestInit(CuTest* t, char* name, TestFunction function)
+{
+	t->name = CuStrCopy(name);
+	t->failed = 0;
+	t->ran = 0;
+	t->message = NULL;
+	t->function = function;
+	t->jumpBuf = NULL;
+}
+
+CuTest* CuTestNew(char* name, TestFunction function)
+{
+	CuTest* tc = CU_ALLOC(CuTest);
+	CuTestInit(tc, name, function);
+	return tc;
+}
+
+void CuTestFree(CuTest* t)
+{
+    if ( t != NULL )
+    {
+        free( t->name );
+        free( t );
+    }
+}
+
+void CuFail(CuTest* tc, char* message)
+{
+	tc->failed = 1;
+	tc->message = CuStrCopy(message);
+	if (tc->jumpBuf != 0) longjmp(*(tc->jumpBuf), 0);
+}
+
+void CuAssert(CuTest* tc, char* message, int condition)
+{
+	if (condition) return;
+	CuFail(tc, message);
+}
+
+void CuAssertTrue(CuTest* tc, int condition)
+{
+	if (condition) return;
+	CuFail(tc, "assert failed");
+}
+
+void CuAssertStrEquals(CuTest* tc, char* expected, char* actual)
+{
+	CuString* message;
+	if (strcmp(expected, actual) == 0) return;
+	message = CuStringNew();
+	CuStringAppend(message, "expected <");
+	CuStringAppend(message, expected);
+	CuStringAppend(message, "> but was <");
+	CuStringAppend(message, actual);
+	CuStringAppend(message, ">");
+	CuFail(tc, message->buffer);
+}
+
+void CuAssertIntEquals(CuTest* tc, int expected, int actual)
+{
+	char buf[STRING_MAX];
+	if (expected == actual) return;
+	sprintf(buf, "expected <%d> but was <%d>", expected, actual);
+	CuFail(tc, buf);
+}
+
+void CuAssertPtrEquals(CuTest* tc, void* expected, void* actual)
+{
+	char buf[STRING_MAX];
+	if (expected == actual) return;
+	sprintf(buf, "expected pointer <0x%p> but was <0x%p>", expected, actual);
+	CuFail(tc, buf);
+}
+
+void CuAssertPtrNotNull(CuTest* tc, void* pointer)
+{
+	char buf[STRING_MAX];
+	if (pointer != NULL ) return;
+	sprintf(buf, "null pointer unexpected");
+	CuFail(tc, buf);
+}
+
+void CuTestRun(CuTest* tc)
+{
+	jmp_buf buf;
+	tc->jumpBuf = &buf;
+	if (setjmp(buf) == 0)
+	{
+		tc->ran = 1;
+		(tc->function)(tc);
+	}
+	tc->jumpBuf = 0;
+}
+
+/*-------------------------------------------------------------------------*
+ * CuSuite
+ *-------------------------------------------------------------------------*/
+
+void CuSuiteInit(CuSuite* testSuite)
+{
+	testSuite->count = 0;
+	testSuite->failCount = 0;
+}
+
+CuSuite* CuSuiteNew()
+{
+	CuSuite* testSuite = CU_ALLOC(CuSuite);
+	CuSuiteInit(testSuite);
+	return testSuite;
+}
+
+void CuSuiteFree(CuSuite* testSuite)
+{
+	int i;
+	for (i = 0 ; i < testSuite->count ; ++i)
+	{
+		CuTestFree( testSuite->list[i] );
+	}
+    free( testSuite );
+}
+
+void CuSuiteAdd(CuSuite* testSuite, CuTest *testCase)
+{
+	assert(testSuite->count < MAX_TEST_CASES);
+	testSuite->list[testSuite->count] = testCase;
+	testSuite->count++;
+}
+
+void CuSuiteAddSuite(CuSuite* testSuite, CuSuite* testSuite2)
+{
+	int i;
+	for (i = 0 ; i < testSuite2->count ; ++i)
+	{
+		CuTest* testCase = testSuite2->list[i];
+		CuSuiteAdd(testSuite, testCase);
+	}
+}
+
+void CuSuiteRun(CuSuite* testSuite)
+{
+	int i;
+	for (i = 0 ; i < testSuite->count ; ++i)
+	{
+		CuTest* testCase = testSuite->list[i];
+		CuTestRun(testCase);
+		if (testCase->failed) { testSuite->failCount += 1; }
+	}
+}
+
+void CuSuiteSummary(CuSuite* testSuite, CuString* summary)
+{
+	int i;
+	for (i = 0 ; i < testSuite->count ; ++i)
+	{
+		CuTest* testCase = testSuite->list[i];
+		CuStringAppend(summary, testCase->failed ? "F" : ".");
+	}
+	CuStringAppend(summary, "\n\n");
+}
+
+void CuSuiteDetails(CuSuite* testSuite, CuString* details)
+{
+	int i;
+	int failCount = 0;
+
+	if (testSuite->failCount == 0)
+	{
+		int passCount = testSuite->count - testSuite->failCount;
+		char* testWord = passCount == 1 ? "test" : "tests";
+		CuStringAppendFormat(details, "OK (%d %s)\n", passCount, testWord);
+	}
+	else
+	{
+		if (testSuite->failCount == 1)
+			CuStringAppend(details, "There was 1 failure:\n");
+		else
+			CuStringAppendFormat(details, "There were %d failures:\n", testSuite->failCount);
+
+		for (i = 0 ; i < testSuite->count ; ++i)
+		{
+			CuTest* testCase = testSuite->list[i];
+			if (testCase->failed)
+			{
+				failCount++;
+				CuStringAppendFormat(details, "%d) %s: %s\n", 
+					failCount, testCase->name, testCase->message);
+			}
+		}
+		CuStringAppend(details, "\n!!!FAILURES!!!\n");
+
+		CuStringAppendFormat(details, "Runs: %d ",   testSuite->count);
+		CuStringAppendFormat(details, "Passes: %d ", testSuite->count - testSuite->failCount);
+		CuStringAppendFormat(details, "Fails: %d\n",  testSuite->failCount);
+	}
+}

data/test/sample_files/syck-0.55/tests/CuTest.h

@@ -0,0 +1,84 @@
+#ifndef CU_TEST_H
+#define CU_TEST_H
+
+#include <setjmp.h>
+#include <stdarg.h>
+
+/* CuString */
+
+char* CuStrAlloc(int size);
+char* CuStrCopy(char* old);
+
+#define CU_ALLOC(TYPE)		((TYPE*) malloc(sizeof(TYPE)))
+
+#define HUGE_STRING_LEN	8192
+#define STRING_MAX		256
+#define STRING_INC		256
+
+typedef struct
+{
+	int length;
+	int size;
+	char* buffer;
+} CuString;
+
+void CuStringInit(CuString* str);
+CuString* CuStringNew(void);
+void CuStringRead(CuString* str, char* path);
+void CuStringAppend(CuString* str, char* text);
+void CuStringAppendLen(CuString* str, char* text, long length);
+void CuStringAppendChar(CuString* str, char ch);
+void CuStringAppendFormat(CuString* str, char* format, ...);
+void CuStringResize(CuString* str, int newSize);
+
+/* CuTest */
+
+typedef struct CuTest CuTest;
+
+typedef void (*TestFunction)(CuTest *);
+
+struct CuTest
+{
+	char* name;
+	TestFunction function;
+	int failed;
+	int ran;
+	char* message;
+	jmp_buf *jumpBuf;
+};
+
+void CuTestInit(CuTest* t, char* name, TestFunction function);
+CuTest* CuTestNew(char* name, TestFunction function);
+void CuFail(CuTest* tc, char* message);
+void CuAssert(CuTest* tc, char* message, int condition);
+void CuAssertTrue(CuTest* tc, int condition);
+void CuAssertStrEquals(CuTest* tc, char* expected, char* actual);
+void CuAssertIntEquals(CuTest* tc, int expected, int actual);
+void CuAssertPtrEquals(CuTest* tc, void* expected, void* actual);
+void CuAssertPtrNotNull(CuTest* tc, void* pointer);
+void CuTestRun(CuTest* tc);
+
+/* CuSuite */
+
+#define MAX_TEST_CASES	1024	
+
+#define SUITE_ADD_TEST(SUITE,TEST)	CuSuiteAdd(SUITE, CuTestNew(#TEST, TEST))
+
+typedef struct
+{
+	int count;
+	CuTest* list[MAX_TEST_CASES]; 
+	int failCount;
+
+} CuSuite;
+
+
+void CuSuiteInit(CuSuite* testSuite);
+CuSuite* CuSuiteNew();
+void CuSuiteAdd(CuSuite* testSuite, CuTest *testCase);
+void CuSuiteAddSuite(CuSuite* testSuite, CuSuite* testSuite2);
+void CuSuiteRun(CuSuite* testSuite);
+void CuSuiteSummary(CuSuite* testSuite, CuString* summary);
+void CuSuiteDetails(CuSuite* testSuite, CuString* details);
+
+#endif /* CU_TEST_H */

data/test/sample_files/syck-0.55/tests/Emit.c

@@ -0,0 +1,87 @@
+//
+// Emit.c
+//
+// $Author: why $
+// $Date: 2005/01/06 07:23:51 $
+//
+// Copyright (C) 2003 why the lucky stiff
+//
+
+#include <string.h>
+#include "syck.h"
+#include "CuTest.h"
+
+//
+// 1. Test the buffering -- print 10 bytes at a time
+//
+void
+TestSyckEmit_Output( SyckEmitter *e, char *str, long len )
+{
+    // char *tmp = syck_strndup( str, len );
+    // printf( "OUT: %s [%d]\n", tmp, len );
+    // S_FREE( tmp );
+}
+
+void 
+TestSyckEmit( CuTest *tc )
+{
+    SyckEmitter *emitter;
+    char *tmp;
+    int len = 0;
+
+    emitter = syck_new_emitter();
+    emitter->bufsize = 10;
+    emitter->output_handler = TestSyckEmit_Output;
+
+    syck_emitter_write( emitter, "Test [1]", 8 );
+    syck_emitter_write( emitter, ".", 1 );
+    syck_emitter_write( emitter, "Test [2]", 8 );
+    syck_emitter_write( emitter, ".", 1 );
+    syck_emitter_write( emitter, "Test [3]", 8 );
+    syck_emitter_write( emitter, ".", 1 );
+    syck_emitter_write( emitter, "Test [4]", 8 );
+    syck_emitter_write( emitter, ".", 1 );
+    syck_emitter_write( emitter, "END!", 4 );
+
+    syck_free_emitter( emitter );
+}
+
+/*
+ * Ensure that our base64 encoder can do some basic
+ * binary encoding.
+ */
+void TestBase64Encode( CuTest *tc )
+{
+    char gif[] = "GIF89a\f\000\f\000\204\000\000\377\377\367\365\365\356\351\351\345fff\000\000\000\347\347\347^^^\363\363\355\216\216\216\340\340\340\237\237\237\223\223\223\247\247\247\236\236\236iiiccc\243\243\243\204\204\204\377\376\371\377\376\371\377\376\371\377\376\371\377\376\371\377\376\371\377\376\371\377\376\371\377\376\371\377\376\371\377\376\371\377\376\371\377\376\371\377\376\371!\376\016Made with GIMP\000,\000\000\000\000\f\000\f\000\000\005,  \216\2010\236\343@\024\350i\020\304\321\212\010\034\317\200M$z\357\3770\205p\270\2601f\r\e\316\001\303\001\036\020' \202\n\001\000;"; 
+    char *enc = syck_base64enc( gif, 185 );
+    CuAssertStrEquals( tc, enc, "R0lGODlhDAAMAIQAAP//9/X17unp5WZmZgAAAOfn515eXvPz7Y6OjuDg4J+fn5OTk6enp56enmlpaWNjY6Ojo4SEhP/++f/++f/++f/++f/++f/++f/++f/++f/++f/++f/++f/++f/++f/++SH+Dk1hZGUgd2l0aCBHSU1QACwAAAAADAAMAAAFLCAgjoEwnuNAFOhpEMTRiggcz4BNJHrv/zCFcLiwMWYNG84BwwEeECcgggoBADs=\n" );
+    S_FREE( enc );
+}
+
+CuSuite *
+SyckGetSuite()
+{
+    CuSuite *suite = CuSuiteNew();
+    SUITE_ADD_TEST( suite, TestSyckEmit );
+    SUITE_ADD_TEST( suite, TestBase64Encode );
+    return suite;
+}
+
+int main(void)
+{
+	CuString *output = CuStringNew();
+	CuSuite* suite = SyckGetSuite();
+    int count;
+
+	CuSuiteRun(suite);
+	CuSuiteSummary(suite, output);
+	CuSuiteDetails(suite, output);
+
+	printf("%s\n", output->buffer);
+    count = suite->failCount;
+
+    CuStringFree( output );
+    CuSuiteFree( suite );
+
+    return count;
+}