#2 Upload UnitTest of ObjectC

Author: LingjieFan

test/UnitTest_Basic.c

@@ -0,0 +1,92 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include "Class.h"
+#include "IUnitTest.h"
+#include "Basic.h"
+#include "IObject.h"
+#include "UnitTest_Basic.h"
+
+Class UnitTest_Basic_Class = {CLASS};
+
+struct _UnitTest_Basic
+{
+    Class* class;
+    IUnitTest* iUnitTest;
+};
+
+void _UnitTest_Basic_TestAll(void* implementor);
+
+void Test_Short_IObject()
+{
+    int size, result;
+    short num;
+    short* new_object;
+
+    num = 0;
+    new_object = (short*)IObject_New(Short);
+    assert(new_object != NULL);
+    Short->implementor = new_object;
+    size = sizeof(*new_object);
+    assert(size == sizeof(short));
+    num = 4;
+    IObject_Copy(Short, &num);
+    assert(*(new_object) == 4);
+    result = IObject_Equal(Short, &num);
+    assert(result == 1);
+    num = 0;
+    result = IObject_Equal(Short, &num);
+    assert(result == 0);
+    Short->implementor = NULL;
+    new_object = (short*)IObject_Del(Short);
+    assert(new_object == NULL);
+    printf("Test_Short_IObject Success.\n");
+}
+
+void Test_Basic_Pointer_New()
+{
+    void** pointer;
+    
+    pointer = (void**)IObject_New(Pointer);
+    assert(pointer != NULL);
+    printf("Test_Basic_Pointer_New Success.\n");
+}
+
+UnitTest_Basic* UnitTest_Basic_New()
+{
+    UnitTest_Basic* unit_test;
+    
+    unit_test = (UnitTest_Basic*)malloc(sizeof(UnitTest_Basic)+sizeof(IUnitTest));
+    unit_test->class = UNITTEST_BASIC;
+    unit_test->iUnitTest = (IUnitTest*)(unit_test+1);
+    unit_test->iUnitTest->implementor = unit_test;
+    unit_test->iUnitTest->TestAll = _UnitTest_Basic_TestAll;
+    
+    return unit_test;
+}
+
+UnitTest_Basic* UnitTest_Basic_Del(UnitTest_Basic* this)
+{
+    free(this);
+    
+    return NULL;
+}
+
+IUnitTest* UnitTest_Basic_GetIUnitTest(UnitTest_Basic* this)
+{
+    return this->iUnitTest;
+}
+
+void UnitTest_Basic_TestAll(UnitTest_Basic* this)
+{
+    Test_Short_IObject();
+    Test_Basic_Pointer_New();
+}
+
+void _UnitTest_Basic_TestAll(void* implementor)
+{
+    UnitTest_Basic* unit_test;
+    
+    unit_test = (UnitTest_Basic*)implementor;
+    UnitTest_Basic_TestAll(unit_test);
+}

test/UnitTest_Basic.h

@@ -0,0 +1,20 @@
+#ifndef _UNITTEST_BASIC_H_
+#define _UNITTEST_BASIC_H_
+
+#define UNITTEST_BASIC &UnitTest_Basic_Class
+
+typedef struct _Class Class;
+typedef struct _IUnitTest IUnitTest;
+typedef struct _UnitTest_Basic UnitTest_Basic;
+
+extern Class UnitTest_Basic_Class;
+
+extern UnitTest_Basic* UnitTest_Basic_New();
+
+extern UnitTest_Basic* UnitTest_Basic_Del(UnitTest_Basic* this);
+
+extern IUnitTest* UnitTest_Basic_GetIUnitTest(UnitTest_Basic* this);
+
+extern void UnitTest_Basic_TestAll(UnitTest_Basic* this);
+
+#endif /*_UNITTEST_BASIC_H_*/

test/UnitTest_Class.c

@@ -0,0 +1,103 @@
+#include <stdio.h>
+#include <assert.h>
+#include <stdlib.h>
+#include "Class.h"
+#include "IUnitTest.h"
+#include "UnitTest_Class.h"
+
+Class UnitTest_Class_Class = {CLASS};
+
+struct _UnitTest_Class
+{
+    Class* class;
+    IUnitTest* iUnitTest;
+};
+
+void _UnitTest_Class_TestAll(void* implementor);
+
+void Test_InstanceOf_Chain()
+{
+    int result;
+    Class class1 = {CLASS};
+    Class class2 = {&class1};
+    Class class3 = {&class2};
+    Class class4 = {&class3};
+    
+    result = InstanceOf(&class4, &class3);
+    assert(result == 1);
+    result = InstanceOf(&class4, &class2);
+    assert(result == 1);
+    result = InstanceOf(&class4, &class1);
+    assert(result == 1);
+    result = InstanceOf(&class4, CLASS);
+    assert(result == 1);
+    result = InstanceOf(&class4, NULL);
+    assert(result == 1);
+    result = InstanceOf(CLASS, CLASS);
+    assert(result == 0);
+    result = InstanceOf(CLASS, &class1);
+    assert(result == 0);
+    result = InstanceOf(CLASS, &class2);
+    assert(result == 0);
+    result = InstanceOf(CLASS, &class3);
+    assert(result == 0);
+    result = InstanceOf(CLASS, &class4);
+    assert(result == 0);
+    printf("Test_InstanceOf_Chain Success.\n");
+}
+
+void Test_InstanceOf_Tree()
+{
+    int result;
+    Class class1 = {CLASS};
+    Class class2 = {CLASS};
+    Class class3 = {&class1};
+    Class class4 = {&class2};
+    
+    result = InstanceOf(&class4, &class1);
+    assert(result == 0);
+    result = InstanceOf(&class4, &class3);
+    assert(result == 0);
+    result = InstanceOf(&class2, &class1);
+    assert(result == 0);
+    printf("Test_InstanceOf_Tree Success.\n");    
+}
+
+UnitTest_Class* UnitTest_Class_New()
+{
+    UnitTest_Class* unit_test;
+    
+    unit_test = (UnitTest_Class*)malloc(sizeof(UnitTest_Class)+sizeof(IUnitTest));
+    unit_test->class = UNITTEST_CLASS;
+    unit_test->iUnitTest = (IUnitTest*)(unit_test+1);
+    unit_test->iUnitTest->implementor = unit_test;
+    unit_test->iUnitTest->TestAll = _UnitTest_Class_TestAll;
+    
+    return unit_test;
+}
+
+UnitTest_Class* UnitTest_Class_Del(UnitTest_Class* this)
+{
+    free(this);
+    
+    return NULL;
+}
+
+IUnitTest* UnitTest_Class_GetIUnitTest(UnitTest_Class* this)
+{
+    return this->iUnitTest;
+}
+
+void UnitTest_Class_TestAll(UnitTest_Class* this)
+{
+    Test_InstanceOf_Chain();
+    Test_InstanceOf_Tree();
+}
+
+void _UnitTest_Class_TestAll(void* implementor)
+{
+    UnitTest_Class* unit_test;
+    
+    unit_test = (UnitTest_Class*)implementor;
+    UnitTest_Class_TestAll(unit_test);
+}

test/UnitTest_Class.h

@@ -0,0 +1,20 @@
+#ifndef _UNITTEST_CLASS_H_
+#define _UNITTEST_CLASS_H_
+
+#define UNITTEST_CLASS &UnitTest_Class_Class
+
+typedef struct _Class Class;
+typedef struct _IUnitTest IUnitTest;
+typedef struct _UnitTest_Class UnitTest_Class;
+
+extern Class UnitTest_Class_Class;
+
+extern UnitTest_Class* UnitTest_Class_New();
+
+extern UnitTest_Class* UnitTest_Class_Del(UnitTest_Class* this);
+
+extern IUnitTest* UnitTest_Class_GetIUnitTest(UnitTest_Class* this);
+
+extern void UnitTest_Class_TestAll(UnitTest_Class* this);
+
+#endif /*_UNITTEST_CLASS_H_*/

test/UnitTest_IObject.c

@@ -0,0 +1,91 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include "Class.h"
+#include "IUnitTest.h"
+#include "IObject.h"
+#include "UnitTest_IObject.h"
+
+Class UnitTest_IObject_Class = {CLASS};
+
+struct _UnitTest_IObject
+{
+    Class* class;
+    IUnitTest* iUnitTest;
+};
+
+void _UnitTest_IObject_TestAll(void* implementor);
+
+void* _Stub_IObject_New(void* implementor)
+{
+    return (void*)0;
+}
+
+void* _Stub_IObject_Del(void* implementor)
+{
+    return (void*)1;
+}
+
+int _Stub_IObject_Copy(void* implementor, void* object)
+{
+    return 2;
+}
+
+int _Stub_IObject_Equal(void* implementor, void* object)
+{
+    return 3;
+}
+
+void Test_IObject_Correct_Function_Pointer()
+{
+    int result;
+    IObject stub_iObject = {NULL, _Stub_IObject_New, _Stub_IObject_Del, _Stub_IObject_Copy, _Stub_IObject_Equal};
+    
+    result = (int)IObject_New(&stub_iObject);
+    assert(result == 0);
+    result = (int)IObject_Del(&stub_iObject);
+    assert(result == 1);
+    result = IObject_Copy(&stub_iObject, NULL);
+    assert(result == 2);
+    result = IObject_Equal(&stub_iObject, NULL);
+    assert(result == 3);
+    printf("Test_IObject_Correct_Function_Pointer Success.\n");
+}
+
+UnitTest_IObject* UnitTest_IObject_New()
+{
+    UnitTest_IObject* unit_test;
+    
+    unit_test = (UnitTest_IObject*)malloc(sizeof(UnitTest_IObject)+sizeof(IUnitTest));
+    unit_test->class = UNITTEST_IOBJECT;
+    unit_test->iUnitTest = (IUnitTest*)(unit_test+1);
+    unit_test->iUnitTest->implementor = unit_test;
+    unit_test->iUnitTest->TestAll = _UnitTest_IObject_TestAll;
+
+    return unit_test;
+}
+
+UnitTest_IObject* UnitTest_IObject_Del(UnitTest_IObject* this)
+{
+    free(this);
+    
+    return NULL;
+}
+
+IUnitTest* UnitTest_IObject_GetIUnitTest(UnitTest_IObject* this)
+{
+    return this->iUnitTest;
+}
+
+void UnitTest_IObject_TestAll(UnitTest_IObject* this)
+{
+    Test_IObject_Correct_Function_Pointer();
+}
+
+void _UnitTest_IObject_TestAll(void* implementor)
+{
+    UnitTest_IObject* unit_test;
+    
+    unit_test = (UnitTest_IObject*)implementor;
+    UnitTest_IObject_TestAll(unit_test);
+}

test/UnitTest_IObject.h

@@ -0,0 +1,20 @@
+#ifndef _UNITTEST_IOBJECT_H_
+#define _UNITTEST_IOBJECT_H_
+
+#define UNITTEST_IOBJECT &UnitTest_IObject_Class
+
+typedef struct _Class Class;
+typedef struct _IUnitTest IUnitTest;
+typedef struct _UnitTest_IObject UnitTest_IObject;
+
+extern Class UnitTest_IObject_Class;
+
+extern UnitTest_IObject* UnitTest_IObject_New();
+
+extern UnitTest_IObject* UnitTest_IObject_Del(UnitTest_IObject* this);
+
+extern IUnitTest* UnitTest_IObject_GetIUnitTest(UnitTest_IObject* this);
+
+extern void UnitTest_IObject_TestAll(UnitTest_IObject* this);
+
+#endif /*_UNITTEST_IOBJECT_H_*/