Luca Baldesi

			

struct my_obj {
        double num;
        int id; 
};

int my_obj_init(struct my_obj *o)
{
	int res = -1;  // default return value (error)

	if (o) {  // robust code here!
		o->num = 0;
		o->id = 42;
		res = 0;  // everything went good (success to be return)
	}

	return res;
}

struct my_obj * my_obj_new()
{
	struct my_obj * o;

	o = malloc(sizeof(struct my_obj));

	if (o && my_obj_init(o) == 0)
		return o;
	else
		return NULL;
}

void  my_obj_destroy(struct my_obj ** o)  // everything malloc'd must be deallocated!!
{
	if (o && *o) {
		free(*o);
		*o = NULL; // this avoids double free
	}
}

int my_obj_id(struct my_obj *o)
{
	if (o)
		return o->id;
	return -1;
}

int my_obj_inc(struct my_obj * o)
{
	int res = -1;

	if (o) {
		o->num++;
		res = 0;
	}

	return res;
}
			
		

			

#ifndef __MY_OBJ_H__

#define __MY_OBJ_H__

struct my_obj;

struct my_obj * my_obj_new();

void  my_obj_destroy(struct my_obj ** o);

int my_obj_id(struct my_obj * o);

int my_obj_inc(struct my_obj * o);

#endif
			
		

			

struct my_derived_obj {
	struct my_obj o;  // we include the base object as the first attribute
	int foo;
}

struct my_derived_obj * my_derived_obj_new()
{
	struct my_derived_obj * do;
	struct my_obj * o;

	do = malloc(sizeof(struct my_obj));
	do->foo = -1;
	o = (struct my_obj *) do;  // cast of the pointer to the base object

	my_obj_init(o);

	return do;
}

int my_derived_obj_id(struct my_derived_obj * do)
{
	return my_obj_id((struct my_obj *) do);	 // Inheritence magic
}

			
		

			

typedef int (*my_fun_t)(struct my_obj * o);  // we save space defining the function prototype here

int my_obj_fun(struct my_obj * o)
{
	int res = -1;

	if (o) {
		printf("I am base fun\n");
		res = 0;
	}
	
	return res;
}

int my_derived_obj_fun(struct my_obj * o)
{
	struct my_derived_obj * do;
	int res = -1;

	if (o) {
		do = (struct my_derived_obj *) o;
		printf("I am derived fun, bar: %d\n", do->bar);  // this functions relies on ancillary data specific of the derived object case
		res = 0;
	}
	
	return res;
}

struct my_obj {
	my_fun_t foo;
};

struct my_obj * my_obj_new()
{
	struct my_obj * o;

	o = malloc(sizeof(struct my_obj));
	o->foo = my_obj_fun;

	return o;
}

struct my_derived_obj {
	struct my_obj o;
	int bar;  // this is the ancillary data I was mentioning previously
};

struct my_derived_obj * my_derived_obj_new()
{
	struct my_derived_obj * do;

	o = malloc(sizeof(struct my_derived_obj));
	((struct my_obj *)o)->foo = my_derived_obj_fun;
	o->bar = 42;

	return o;
}

// Sample use code

int main(int argv, char** argc)
{
	int i;
	struct my_obj *objs[2];  // array of all objects

	objs[0] = my_obj_new();  // I can put base objects...
	objs[1] = (struct my_obj*) my_derived_obj_new();  // ..as well as derived ones

	for(i=0; i<2; i++)
		(objs[i])->foo(objs[i]);  // polymorphic code behaviour depends on data initialization

	return 0;
}
			
		

			

typedef void (*my_fun_t)(void);  // we save space defining the function prototype here

struct my_obj {
	my_obj_itx * itx;
};

struct my_obj_itx {  // our interface definition
	my_fun_t print_something;
};

struct my_obj_itx itx_num1 = {  // our interface implementation number 1
	.print_something = print1;
};

struct my_obj_itx itx_num2 = {  // our interface implementation number 2
	.print_something = print2;
};

void print1()
{
	printf("I'm NUMBER ONE :)\n");
}

void print2()
{
	printf("I'm number two :(\n");
}

struct my_obj * my_obj_new(int num)
{
	struct my_obj * o;

	o = malloc(sizeof(struct my_obj));
	swtich(num) {
		case 1:
			o->itx = &itx_num1;
			break;
		case 2:
			o->itx = &itx_num2;
			break;
		default:
			o->itx = NULL;
	}
	return o;
}

void my_obj_print_something(struct my_obj *o) 
{
	if (o) 
		o->itx->print_something();  
}

// Sample use code

int main(int argv, char** argc)
{
	int i;
	struct my_obj *objs[2];  // array of all objects

	objs[0] = my_obj_new(1);  // object with interface 1
	objs[1] = my_obj_new(2);  // object with interface 2

	for(i=0; i<2; i++)
		my_obj_print_something(&objs[i]);  // polymorphic code behaviour depends on data initialization

	return 0;
}
			
		

			


#include <assert.h>
#include <stdio.h>

#include <my_obj.h>  // we test against the public API of my_obj module

void my_obj_new_test()  // this function is a test case for my_obj_new()
{
	struct my_obj * o = NULL;

	o = my_obj_new(1);  // common case 1
	assert(o);  // if "o" is NULL this fails and the test crashes
	my_obj_destroy(&o);  // we cleanup 

	o = my_obj_new(2);  // common case 2
	assert(o);  // if "o" is NULL this fails and the test crashes
	my_obj_destroy(&o);  // we cleanup 

	o = my_obj_new(3);  // WRONG parameter value
	assert(o == NULL);  // This should in principle not being a valid object

	fprintf(stderr,"%s successfully passed!\n",__func__); // this line confirms this function worked
}

int main(int argv, char ** argc)
{
	my_obj_new_test();  
	my_obj_destroy_test();  
	my_obj_inc_test();  
	return 0;
}

			
		

			


SRC=$(wildcard *.c)
OBJS=$(SRC:.c=.test)

TARGET_SRC += $(wildcard ../src/*.c) 
TARGET_OBJS=$(TARGET_SRC:.c=.o)

CFLAGS += -g -W -Wall -Wno-unused-function -Wno-unused-parameter -O0 

all: $(TARGET_SRC) $(TARGET_OBJS) $(OBJS)

%.test: %.c $(TARGET_OBJS) 
	$(CC) -o $@ $< $(CFLAGS) $(TARGET_OBJS) $(LDFLAGS)

clean:
	rm -f *.test 

.PHONY: all clean

			
		

			


#!/bin/bash

info() {
	echo -e "\E[33m$@\033[0m"
}

error() {
	echo -e "\E[31m$@\033[0m"
}

success() {
	echo -e "\E[32m$@\033[0m"
}

TDIR="$(dirname $0)"
FILES=(`ls $TDIR/*.test`)
i=0
while [ $i -lt ${#FILES[@]} ]; do
	info "Running ${FILES[$i]}"
	res=$(${FILES[$i]} 2>&1)
	if [ $? -ne 0 ]; then
		error "$res"
		exit 1
	fi
	info "Valgrind on ${FILES[$i]}"
	res=$(valgrind --leak-check=full ${FILES[$i]} 2>&1 | awk '/ERROR SUMMARY/ {print $4}')
	if [ $res -gt 0 ]; then
		error "Memory error on ${FILES[$i]}"
		error $(valgrind --leak-check=full ${FILES[$i]})
		exit 1
	fi
	success "Test Passed"
	i=$((i+1))
done