diff --git a/.clang-format b/.clang-format new file mode 100644 index 0000000..e2235cf --- /dev/null +++ b/.clang-format @@ -0,0 +1,18 @@ +--- +BasedOnStyle: LLVM +IndentWidth: 2 +--- +Language: Cpp +UseTab: Never +ColumnLimit: 100 +AlignAfterOpenBracket: true +BreakBeforeBraces: Allman +AllowShortFunctionsOnASingleLine: InlineOnly +ReflowComments: false +BinPackParameters: false +AlignEscapedNewlines: Right +PointerAlignment: Left +AlignConsecutiveDeclarations: true +AlignEscapedNewlines: true +IndentCaseLabels: true +... diff --git a/fixtures/DecisionTableExample.c b/fixtures/DecisionTableExample.c index fcba1a0..c096559 100644 --- a/fixtures/DecisionTableExample.c +++ b/fixtures/DecisionTableExample.c @@ -1,74 +1,76 @@ -#include -#include -#include -#include "SlimList.h" #include "Fixtures.h" +#include "SlimList.h" #include "compatibility.h" - +#include +#include +#include typedef struct Division { - double numerator; - double denominator; - char result[32]; + double numerator; + double denominator; + char result[32]; } Division; void* Division_Create(StatementExecutor* errorHandler, SlimList* args) { - Division* self = (Division*)malloc(sizeof(Division)); - memset(self, 0, sizeof(Division)); - return self; + Division* self = (Division*)malloc(sizeof(Division)); + memset(self, 0, sizeof(Division)); + return self; } void Division_Destroy(void* void_self) { - free(void_self); + free(void_self); } -static const char* setNumerator(void* void_self, SlimList* args) { - Division* self = (Division*)void_self; - self->numerator = atof(SlimList_GetStringAt(args, 0)); - return ""; +static const char* setNumerator(void* void_self, SlimList* args) +{ + Division* self = (Division*)void_self; + self->numerator = atof(SlimList_GetStringAt(args, 0)); + return ""; } -static const char* setDenominator(void* void_self, SlimList* args) { - Division* self = (Division*)void_self; - self->denominator = atof(SlimList_GetStringAt(args, 0)); - if (self->denominator == 0.0) - return SLIM_EXCEPTION("You shouldn't divide by zero now should ya?"); - return ""; +static const char* setDenominator(void* void_self, SlimList* args) +{ + Division* self = (Division*)void_self; + self->denominator = atof(SlimList_GetStringAt(args, 0)); + if (self->denominator == 0.0) + return SLIM_EXCEPTION("You shouldn't divide by zero now should ya?"); + return ""; } -static const char* Quotient(void* void_self, SlimList* args) { - Division* self = (Division*)void_self; - double quotient = self->numerator / self->denominator; - snprintf(self->result, 32, "%g", quotient); - return self->result; +static const char* Quotient(void* void_self, SlimList* args) +{ + Division* self = (Division*)void_self; + double quotient = self->numerator / self->denominator; + snprintf(self->result, 32, "%g", quotient); + return self->result; } //These are optional. If they aren't declared, they are ignored -static const char* execute(void* void_self, SlimList* args) { - return ""; +static const char* execute(void* void_self, SlimList* args) +{ + return ""; } -static const char* reset(void* void_self, SlimList* args) { - Division* self = (Division*)void_self; - self->denominator = 0.0f; - self->numerator = 0.0f; - return ""; +static const char* reset(void* void_self, SlimList* args) +{ + Division* self = (Division*)void_self; + self->denominator = 0.0f; + self->numerator = 0.0f; + return ""; } -static const char* table(void* void_self, SlimList* args) { - return ""; +static const char* table(void* void_self, SlimList* args) +{ + return ""; } - - SLIM_CREATE_FIXTURE(Division) - SLIM_FUNCTION(setNumerator) - SLIM_FUNCTION(setDenominator) - SLIM_FUNCTION(Quotient) - SLIM_FUNCTION(execute) - SLIM_FUNCTION(reset) - SLIM_FUNCTION(table) +SLIM_FUNCTION(setNumerator) +SLIM_FUNCTION(setDenominator) +SLIM_FUNCTION(Quotient) +SLIM_FUNCTION(execute) +SLIM_FUNCTION(reset) +SLIM_FUNCTION(table) SLIM_END - diff --git a/fixtures/ExceptionsExample.c b/fixtures/ExceptionsExample.c index ebfae53..4f05548 100644 --- a/fixtures/ExceptionsExample.c +++ b/fixtures/ExceptionsExample.c @@ -1,33 +1,34 @@ +#include "Fixtures.h" +#include "SlimList.h" +#include #include #include -#include -#include "SlimList.h" -#include "Fixtures.h" typedef void ExceptionsExample; void* ExceptionsExample_Create(StatementExecutor* errorHandler, SlimList* args) { - if (SlimList_GetLength(args) < 1) { - SLIM_CONSTRUCTOR_ERROR(errorHandler, "One arg required"); - return NULL; - } + if (SlimList_GetLength(args) < 1) + { + SLIM_CONSTRUCTOR_ERROR(errorHandler, "One arg required"); + return NULL; + } - ExceptionsExample* self = (ExceptionsExample*)malloc(1); - memset(self, 0, 1); - return self; + ExceptionsExample* self = (ExceptionsExample*)malloc(1); + memset(self, 0, 1); + return self; } void ExceptionsExample_Destroy(void* void_self) { - free(void_self); + free(void_self); } -static const char* setTrouble(void* void_self, SlimList* args) { - return SLIM_EXCEPTION("You stink"); +static const char* setTrouble(void* void_self, SlimList* args) +{ + return SLIM_EXCEPTION("You stink"); } -SLIM_CREATE_FIXTURE(ExceptionsExample) - SLIM_FUNCTION(setTrouble) +SLIM_CREATE_FIXTURE(ExceptionsExample) +SLIM_FUNCTION(setTrouble) SLIM_END - diff --git a/fixtures/FixtureInCpp.cpp b/fixtures/FixtureInCpp.cpp index e5a96c8..7877de1 100644 --- a/fixtures/FixtureInCpp.cpp +++ b/fixtures/FixtureInCpp.cpp @@ -1,22 +1,19 @@ -#include -#include -#include -#include "SlimList.h" #include "Fixtures.h" +#include "SlimList.h" #include "compatibility.h" +#include +#include +#include class cMultiplication { public: - cMultiplication(){}; - ~cMultiplication(){}; - double product() - { - return m1*m2; - } - double m1; - double m2; - char result[32]; + cMultiplication(){}; + ~cMultiplication(){}; + double product() { return m1 * m2; } + double m1; + double m2; + char result[32]; }; #ifndef CPP_COMPILING @@ -24,49 +21,51 @@ extern "C" { #endif typedef struct Multiplication { - cMultiplication multiplication; - char result[32]; + cMultiplication multiplication; + char result[32]; } Multiplication; void* Multiplication_Create(StatementExecutor* errorHandler, SlimList* args) { - Multiplication* self = (Multiplication*)malloc(sizeof(Multiplication)); - self->result[0] = 0; + Multiplication* self = (Multiplication*)malloc(sizeof(Multiplication)); + self->result[0] = 0; // self->multiplication = new cMultiplication(); - return self; + return self; } void Multiplication_Destroy(void* void_self) { - Multiplication* self = (Multiplication*)void_self; + Multiplication* self = (Multiplication*)void_self; // delete self->multiplication; - free(self); + free(self); } -static const char* setMultiplicand1(void* void_self, SlimList* args) { - Multiplication* self = (Multiplication*)void_self; - self->multiplication.m1 = atof(SlimList_GetStringAt(args, 0)); - return self->result; +static const char* setMultiplicand1(void* void_self, SlimList* args) +{ + Multiplication* self = (Multiplication*)void_self; + self->multiplication.m1 = atof(SlimList_GetStringAt(args, 0)); + return self->result; } -static const char* setMultiplicand2(void* void_self, SlimList* args) { - Multiplication* self = (Multiplication*)void_self; - self->multiplication.m2 = atof(SlimList_GetStringAt(args, 0)); - return self->result; +static const char* setMultiplicand2(void* void_self, SlimList* args) +{ + Multiplication* self = (Multiplication*)void_self; + self->multiplication.m2 = atof(SlimList_GetStringAt(args, 0)); + return self->result; } -static const char* Product(void* void_self, SlimList* args) { - Multiplication* self = (Multiplication*)void_self; - double product = self->multiplication.product(); - snprintf(self->result, 32, "%g", product); - return self->result; +static const char* Product(void* void_self, SlimList* args) +{ + Multiplication* self = (Multiplication*)void_self; + double product = self->multiplication.product(); + snprintf(self->result, 32, "%g", product); + return self->result; } - SLIM_CREATE_FIXTURE(Multiplication) - SLIM_FUNCTION(setMultiplicand1) - SLIM_FUNCTION(setMultiplicand2) - SLIM_FUNCTION(Product) +SLIM_FUNCTION(setMultiplicand1) +SLIM_FUNCTION(setMultiplicand2) +SLIM_FUNCTION(Product) SLIM_END #ifndef CPP_COMPILING diff --git a/fixtures/Fixtures.c b/fixtures/Fixtures.c index 6e10a2a..c95d4dd 100644 --- a/fixtures/Fixtures.c +++ b/fixtures/Fixtures.c @@ -1,12 +1,11 @@ #include "Fixtures.h" SLIM_FIXTURES - SLIM_FIXTURE(Division) - SLIM_FIXTURE(Count) - SLIM_FIXTURE(EmployeePayRecordsRow) - SLIM_FIXTURE(ExceptionsExample) - SLIM_FIXTURE(Multiplication) - SLIM_FIXTURE(Echo) - SLIM_FIXTURE(EchoLoudly) +SLIM_FIXTURE(Division) +SLIM_FIXTURE(Count) +SLIM_FIXTURE(EmployeePayRecordsRow) +SLIM_FIXTURE(ExceptionsExample) +SLIM_FIXTURE(Multiplication) +SLIM_FIXTURE(Echo) +SLIM_FIXTURE(EchoLoudly) SLIM_END - diff --git a/fixtures/Main.c b/fixtures/Main.c index 2b80506..7710ea8 100644 --- a/fixtures/Main.c +++ b/fixtures/Main.c @@ -1,34 +1,33 @@ #include "Slim.h" -#include "SocketServer.h" #include "SlimConnectionHandler.h" +#include "SocketServer.h" #include "TcpComLink.h" #include #include -Slim * slim; +Slim* slim; int connection_handler(int socket) { - int result = 0; - TcpComLink * comLink = TcpComLink_Create(socket); + int result = 0; + TcpComLink* comLink = TcpComLink_Create(socket); result = Slim_HandleConnection(slim, (void*)comLink, &TcpComLink_send, &TcpComLink_recv); - TcpComLink_Destroy(comLink); + TcpComLink_Destroy(comLink); - return result; + return result; } int main(int ac, char** av) { slim = Slim_Create(); - SocketServer* server = SocketServer_Create(); - SocketServer_register_handler(server, &connection_handler); + SocketServer* server = SocketServer_Create(); + SocketServer_register_handler(server, &connection_handler); - int result = SocketServer_Run(server, av[1]); + int result = SocketServer_Run(server, av[1]); - SocketServer_Destroy(server); + SocketServer_Destroy(server); Slim_Destroy(slim); - return result; + return result; } - diff --git a/fixtures/QueryTableExample.c b/fixtures/QueryTableExample.c index d8bd81c..9dce5a1 100644 --- a/fixtures/QueryTableExample.c +++ b/fixtures/QueryTableExample.c @@ -1,59 +1,58 @@ -#include -#include -#include #include "Fixtures.h" #include "SlimList.h" #include "SlimListSerializer.h" - +#include +#include +#include typedef struct EmployeePayRecordsRow { - char * result; + char* result; } EmployeePayRecordsRow; void* EmployeePayRecordsRow_Create(StatementExecutor* errorHandler, SlimList* args) { - EmployeePayRecordsRow* self = (EmployeePayRecordsRow*)malloc(sizeof(EmployeePayRecordsRow)); - memset(self, 0, sizeof(EmployeePayRecordsRow)); - return self; + EmployeePayRecordsRow* self = (EmployeePayRecordsRow*)malloc(sizeof(EmployeePayRecordsRow)); + memset(self, 0, sizeof(EmployeePayRecordsRow)); + return self; } void EmployeePayRecordsRow_Destroy(void* void_self) { - EmployeePayRecordsRow* self = (EmployeePayRecordsRow*)void_self; - SlimList_Release(self->result); - free(self); + EmployeePayRecordsRow* self = (EmployeePayRecordsRow*)void_self; + SlimList_Release(self->result); + free(self); } -static const char* query(void* void_self, SlimList* args) { - EmployeePayRecordsRow* self = (EmployeePayRecordsRow*)void_self; +static const char* query(void* void_self, SlimList* args) +{ + EmployeePayRecordsRow* self = (EmployeePayRecordsRow*)void_self; - SlimList* id = SlimList_Create(); - SlimList_AddString(id, "id"); - SlimList_AddString(id, "1"); + SlimList* id = SlimList_Create(); + SlimList_AddString(id, "id"); + SlimList_AddString(id, "1"); - SlimList* pay = SlimList_Create(); - SlimList_AddString(pay, "pay"); - SlimList_AddString(pay, "1000"); + SlimList* pay = SlimList_Create(); + SlimList_AddString(pay, "pay"); + SlimList_AddString(pay, "1000"); - SlimList* record1 = SlimList_Create(); - SlimList_AddList(record1, id); - SlimList_AddList(record1, pay); + SlimList* record1 = SlimList_Create(); + SlimList_AddList(record1, id); + SlimList_AddList(record1, pay); - SlimList* records = SlimList_Create(); - SlimList_AddList(records, record1); + SlimList* records = SlimList_Create(); + SlimList_AddList(records, record1); - SlimList_Release(self->result); - self->result = SlimList_Serialize(records); + SlimList_Release(self->result); + self->result = SlimList_Serialize(records); - SlimList_Destroy(id); - SlimList_Destroy(pay); - SlimList_Destroy(record1); - SlimList_Destroy(records); - return self->result; + SlimList_Destroy(id); + SlimList_Destroy(pay); + SlimList_Destroy(record1); + SlimList_Destroy(records); + return self->result; } SLIM_CREATE_FIXTURE(EmployeePayRecordsRow) - SLIM_FUNCTION(query) +SLIM_FUNCTION(query) SLIM_END - diff --git a/fixtures/ScriptTableExample.c b/fixtures/ScriptTableExample.c index 5408267..2e7312b 100644 --- a/fixtures/ScriptTableExample.c +++ b/fixtures/ScriptTableExample.c @@ -1,6 +1,6 @@ +#include #include #include -#include #include "Fixtures.h" #include "SlimList.h" @@ -8,37 +8,37 @@ typedef struct Count { - int count; - char result[32]; + int count; + char result[32]; } Count; void* Count_Create(StatementExecutor* errorHandler, SlimList* args) { - Count* self = (Count*)malloc(sizeof(Count)); - memset(self, 0, sizeof(Count)); - return self; + Count* self = (Count*)malloc(sizeof(Count)); + memset(self, 0, sizeof(Count)); + return self; } void Count_Destroy(void* self) { - free(self); + free(self); } -static const char* count(void* void_self, SlimList* args) { - Count* self = (Count*)void_self; - self->count++; - return ""; +static const char* count(void* void_self, SlimList* args) +{ + Count* self = (Count*)void_self; + self->count++; + return ""; } -static const char* counter(void* void_self, SlimList* args) { - Count* self = (Count*)void_self; - snprintf(self->result, 32, "%d", self->count); - return self->result; +static const char* counter(void* void_self, SlimList* args) +{ + Count* self = (Count*)void_self; + snprintf(self->result, 32, "%d", self->count); + return self->result; } - SLIM_CREATE_FIXTURE(Count) - SLIM_FUNCTION(count) - SLIM_FUNCTION(counter) +SLIM_FUNCTION(count) +SLIM_FUNCTION(counter) SLIM_END - diff --git a/fixtures/ScriptTableExampleEcho.c b/fixtures/ScriptTableExampleEcho.c index 9faf01e..2fcf356 100644 --- a/fixtures/ScriptTableExampleEcho.c +++ b/fixtures/ScriptTableExampleEcho.c @@ -6,35 +6,35 @@ typedef struct Echo { - char result[32]; + char result[32]; } Echo; void* Echo_Create(StatementExecutor* errorHandler, SlimList* args) { - Echo* self = (Echo*)malloc(sizeof(Echo)); - memset(self, 0, sizeof(Echo)); - return self; + Echo* self = (Echo*)malloc(sizeof(Echo)); + memset(self, 0, sizeof(Echo)); + return self; } -void Echo_Destroy(void *self) +void Echo_Destroy(void* self) { - free(self); + free(self); } static const char* echo(void* void_self, SlimList* args) { - if (SlimList_GetLength(args) != 1) - { - return SLIM_EXCEPTION("Exactly 1 argument expected"); - } + if (SlimList_GetLength(args) != 1) + { + return SLIM_EXCEPTION("Exactly 1 argument expected"); + } - Echo* self = (Echo*)void_self; - const char* stringToEcho = SlimList_GetStringAt(args, 0); - strncpy(self->result, stringToEcho, sizeof(self->result)); - self->result[sizeof(self->result)-1] = '\0'; - return self->result; + Echo* self = (Echo*)void_self; + const char* stringToEcho = SlimList_GetStringAt(args, 0); + strncpy(self->result, stringToEcho, sizeof(self->result)); + self->result[sizeof(self->result) - 1] = '\0'; + return self->result; } SLIM_CREATE_FIXTURE(Echo) - SLIM_FUNCTION(echo) +SLIM_FUNCTION(echo) SLIM_END diff --git a/fixtures/ScriptTableExampleEchoLoudly.c b/fixtures/ScriptTableExampleEchoLoudly.c index 5e4875b..009797c 100644 --- a/fixtures/ScriptTableExampleEchoLoudly.c +++ b/fixtures/ScriptTableExampleEchoLoudly.c @@ -7,54 +7,54 @@ typedef struct EchoLoudly { - char result[32]; + char result[32]; } EchoLoudly; void* EchoLoudly_Create(StatementExecutor* errorHandler, SlimList* args) { - EchoLoudly* self = (EchoLoudly*)malloc(sizeof(EchoLoudly)); - memset(self, 0, sizeof(EchoLoudly)); - return self; + EchoLoudly* self = (EchoLoudly*)malloc(sizeof(EchoLoudly)); + memset(self, 0, sizeof(EchoLoudly)); + return self; } void EchoLoudly_Destroy(void* self) { - free(self); + free(self); } static const char* echo(void* void_self, SlimList* args) { - if (SlimList_GetLength(args) != 1) - { - return SLIM_EXCEPTION("Exactly 1 argument expected"); - } + if (SlimList_GetLength(args) != 1) + { + return SLIM_EXCEPTION("Exactly 1 argument expected"); + } - EchoLoudly* self = (EchoLoudly*)void_self; - const char* stringToEcho = SlimList_GetStringAt(args, 0); + EchoLoudly* self = (EchoLoudly*)void_self; + const char* stringToEcho = SlimList_GetStringAt(args, 0); - strncpy(self->result, stringToEcho, 32); - self->result[31] = '\0'; + strncpy(self->result, stringToEcho, 32); + self->result[31] = '\0'; - for (char* i = self->result; *i != '\0'; ++i) - { - *i = toupper(*i); - } + for (char* i = self->result; *i != '\0'; ++i) + { + *i = toupper(*i); + } - return self->result; + return self->result; } static const char* repeat(void* void_self, SlimList* args) { - if (SlimList_GetLength(args) != 0) - { - return SLIM_EXCEPTION("Exactly 0 arguments expected"); - } + if (SlimList_GetLength(args) != 0) + { + return SLIM_EXCEPTION("Exactly 0 arguments expected"); + } - EchoLoudly* self = (EchoLoudly*)void_self; - return self->result; + EchoLoudly* self = (EchoLoudly*)void_self; + return self->result; } SLIM_CREATE_FIXTURE(EchoLoudly) - SLIM_FUNCTION(echo) - SLIM_FUNCTION(repeat) +SLIM_FUNCTION(echo) +SLIM_FUNCTION(repeat) SLIM_END diff --git a/include/CSlim/Fixtures.h b/include/CSlim/Fixtures.h index 2df1b2e..3ae9515 100644 --- a/include/CSlim/Fixtures.h +++ b/include/CSlim/Fixtures.h @@ -6,39 +6,37 @@ extern "C" { #include "StatementExecutor.h" -#define SLIM_QUOTES(x) #x -#define SLIM_FIXTURE(fixture) \ -extern void fixture##_Register(StatementExecutor*);\ -StatementExecutor_AddFixture(executor, fixture##_Register); +#define SLIM_QUOTES(x) #x +#define SLIM_FIXTURE(fixture) \ + extern void fixture##_Register(StatementExecutor*); \ + StatementExecutor_AddFixture(executor, fixture##_Register); -#define SLIM_FIXTURES void AddFixtures(StatementExecutor* executor) \ -{ +#define SLIM_FIXTURES \ + void AddFixtures(StatementExecutor* executor) \ + { #define SLIM_END } -#define PRIVATE_REGISTER_FIXTURE(name) StatementExecutor_RegisterFixture(executor, #name, name##_Create, name##_Destroy); +#define PRIVATE_REGISTER_FIXTURE(name) \ + StatementExecutor_RegisterFixture(executor, #name, name##_Create, name##_Destroy); -#define SLIM_CREATE_EMPTY_FIXTURE(name) \ - void name##_Register(StatementExecutor* executor) \ - { \ - PRIVATE_REGISTER_FIXTURE(name)\ - } +#define SLIM_CREATE_EMPTY_FIXTURE(name) \ + void name##_Register(StatementExecutor* executor) { PRIVATE_REGISTER_FIXTURE(name) } - -#define SLIM_CREATE_FIXTURE(name) static const char * fixtureName = #name; \ -void name##_Register(StatementExecutor* executor) \ -{ \ - PRIVATE_REGISTER_FIXTURE(name); +#define SLIM_CREATE_FIXTURE(name) \ + static const char* fixtureName = #name; \ + void name##_Register(StatementExecutor* executor) \ + { \ + PRIVATE_REGISTER_FIXTURE(name); #define SLIM_FUNCTION(name) StatementExecutor_RegisterMethod(executor, fixtureName, #name, name); +#define SLIM_ABORT(reason) SLIM_QUOTES(__EXCEPTION__ : ABORT_SLIM_TEST : message : << reason.>>) -#define SLIM_ABORT(reason) SLIM_QUOTES(__EXCEPTION__:ABORT_SLIM_TEST:message:<>) - -#define SLIM_EXCEPTION(reason) SLIM_QUOTES(__EXCEPTION__:message:<>) - -#define SLIM_CONSTRUCTOR_ERROR(errorHandler, reason) StatementExecutor_ConstructorError(errorHandler, reason); +#define SLIM_EXCEPTION(reason) SLIM_QUOTES(__EXCEPTION__ : message : << reason.>>) +#define SLIM_CONSTRUCTOR_ERROR(errorHandler, reason) \ + StatementExecutor_ConstructorError(errorHandler, reason); #ifndef CPP_COMPILING #ifdef __cplusplus diff --git a/include/CSlim/ListExecutor.h b/include/CSlim/ListExecutor.h index 3ac2a7b..a4cf725 100644 --- a/include/CSlim/ListExecutor.h +++ b/include/CSlim/ListExecutor.h @@ -12,8 +12,8 @@ extern "C" { typedef struct ListExecutor ListExecutor; ListExecutor* ListExecutor_Create(StatementExecutor*); -void ListExecutor_Destroy(ListExecutor*); -SlimList* ListExecutor_Execute(ListExecutor*, SlimList*); +void ListExecutor_Destroy(ListExecutor*); +SlimList* ListExecutor_Execute(ListExecutor*, SlimList*); #ifndef CPP_COMPILING #ifdef __cplusplus diff --git a/include/CSlim/Slim.h b/include/CSlim/Slim.h index e486833..c3eec76 100644 --- a/include/CSlim/Slim.h +++ b/include/CSlim/Slim.h @@ -11,10 +11,10 @@ extern "C" { typedef struct Slim Slim; -Slim * Slim_Create(); -void Slim_Destroy(Slim*); -char * Slim_HandleMessage(void* self, char * message); -int Slim_HandleConnection(Slim* self, void* comLink, com_func_send_t send, com_func_recv_t recv); +Slim* Slim_Create(); +void Slim_Destroy(Slim*); +char* Slim_HandleMessage(void* self, char* message); +int Slim_HandleConnection(Slim* self, void* comLink, com_func_send_t send, com_func_recv_t recv); #ifndef CPP_COMPILING #ifdef __cplusplus @@ -22,4 +22,4 @@ int Slim_HandleConnection(Slim* self, void* comLink, com_func_send_t send, com_f #endif #endif -#endif +#endif diff --git a/include/CSlim/SlimConnectionHandler.h b/include/CSlim/SlimConnectionHandler.h index 36db5c5..4c10b40 100644 --- a/include/CSlim/SlimConnectionHandler.h +++ b/include/CSlim/SlimConnectionHandler.h @@ -9,14 +9,18 @@ extern "C" { typedef struct SlimConnectionHandler SlimConnectionHandler; -typedef int(*com_func_send_t)(void * handle, const char * msg, int length); -typedef int(*com_func_recv_t)(void * handle, char * msg, int length); -typedef char * (*handler_func_t)(void *, char *); +typedef int (*com_func_send_t)(void* handle, const char* msg, int length); +typedef int (*com_func_recv_t)(void* handle, char* msg, int length); +typedef char* (*handler_func_t)(void*, char*); -SlimConnectionHandler* SlimConnectionHandler_Create(com_func_send_t sendFunction, com_func_recv_t recvFunction, void * comLink); -void SlimConnectionHandler_Destroy(SlimConnectionHandler*); -int SlimConnectionHandler_Run(SlimConnectionHandler*); -void SlimConnectionHandler_RegisterSlimMessageHandler(SlimConnectionHandler*, void* handler, handler_func_t ); +SlimConnectionHandler* SlimConnectionHandler_Create(com_func_send_t sendFunction, + com_func_recv_t recvFunction, + void* comLink); +void SlimConnectionHandler_Destroy(SlimConnectionHandler*); +int SlimConnectionHandler_Run(SlimConnectionHandler*); +void SlimConnectionHandler_RegisterSlimMessageHandler(SlimConnectionHandler*, + void* handler, + handler_func_t); #ifndef CPP_COMPILING #ifdef __cplusplus diff --git a/include/CSlim/SlimList.h b/include/CSlim/SlimList.h index b6ed1fc..4c9972c 100644 --- a/include/CSlim/SlimList.h +++ b/include/CSlim/SlimList.h @@ -8,32 +8,32 @@ extern "C" { #endif typedef struct SlimList SlimList; -typedef struct Node SlimListIterator; +typedef struct Node SlimListIterator; SlimList* SlimList_Create(void); -void SlimList_Destroy(SlimList*); +void SlimList_Destroy(SlimList*); SlimListIterator* SlimList_CreateIterator(SlimList*); -int SlimList_Iterator_HasItem(SlimListIterator*); -void SlimList_Iterator_Advance(SlimListIterator**); -void SlimList_Iterator_AdvanceBy(SlimListIterator**, int); +int SlimList_Iterator_HasItem(SlimListIterator*); +void SlimList_Iterator_Advance(SlimListIterator**); +void SlimList_Iterator_AdvanceBy(SlimListIterator**, int); const char* SlimList_Iterator_GetString(SlimListIterator*); -SlimList* SlimList_Iterator_GetList(SlimListIterator*); -void SlimList_Iterator_Replace(SlimListIterator*, const char*); - -extern void SlimList_AddString(SlimList*, char const *); -void SlimList_AddList(SlimList* self, SlimList* element); -void SlimList_PopHead(SlimList* self); -int SlimList_GetLength(SlimList*); -int SlimList_Equals(SlimList* self, SlimList* other); -SlimList * SlimList_GetListAt(SlimList* self, int index); -const char * SlimList_GetStringAt(SlimList* self, int index); -double SlimList_GetDoubleAt(SlimList* self, int index); -SlimList* SlimList_GetHashAt(SlimList* self, int index); -void SlimList_ReplaceAt(SlimList* self, int index, char const * replacementString); -void SlimList_AddBuffer(SlimList* self, char const* buffer, int length); -SlimList* SlimList_GetTailAt(SlimList*, int index); +SlimList* SlimList_Iterator_GetList(SlimListIterator*); +void SlimList_Iterator_Replace(SlimListIterator*, const char*); + +extern void SlimList_AddString(SlimList*, char const*); +void SlimList_AddList(SlimList* self, SlimList* element); +void SlimList_PopHead(SlimList* self); +int SlimList_GetLength(SlimList*); +int SlimList_Equals(SlimList* self, SlimList* other); +SlimList* SlimList_GetListAt(SlimList* self, int index); +const char* SlimList_GetStringAt(SlimList* self, int index); +double SlimList_GetDoubleAt(SlimList* self, int index); +SlimList* SlimList_GetHashAt(SlimList* self, int index); +void SlimList_ReplaceAt(SlimList* self, int index, char const* replacementString); +void SlimList_AddBuffer(SlimList* self, char const* buffer, int length); +SlimList* SlimList_GetTailAt(SlimList*, int index); const char* SlimList_ToString(SlimList*); /// Use CSlim_DestroyString to deallocate the string #ifndef CPP_COMPILING diff --git a/include/CSlim/SlimListDeserializer.h b/include/CSlim/SlimListDeserializer.h index 2fed4dd..d28d7a3 100644 --- a/include/CSlim/SlimListDeserializer.h +++ b/include/CSlim/SlimListDeserializer.h @@ -7,7 +7,7 @@ extern "C" { #endif #endif -SlimList* SlimList_Deserialize(char const *); +SlimList* SlimList_Deserialize(char const*); #ifndef CPP_COMPILING #ifdef __cplusplus diff --git a/include/CSlim/SlimListSerializer.h b/include/CSlim/SlimListSerializer.h index 2a9891f..29e876d 100644 --- a/include/CSlim/SlimListSerializer.h +++ b/include/CSlim/SlimListSerializer.h @@ -10,8 +10,8 @@ extern "C" { #include "SlimList.h" char* SlimList_Serialize(SlimList*); -void SlimList_Release(char *serializedResults); -int SlimList_SerializedLength(SlimList*); +void SlimList_Release(char* serializedResults); +int SlimList_SerializedLength(SlimList*); #ifndef CPP_COMPILING #ifdef __cplusplus diff --git a/include/CSlim/SlimUtil.h b/include/CSlim/SlimUtil.h index 8863049..10205a1 100644 --- a/include/CSlim/SlimUtil.h +++ b/include/CSlim/SlimUtil.h @@ -7,23 +7,23 @@ extern "C" { #endif #endif -const char * CSlim_BuyBuf(char const*, int); -const char * CSlim_BuyString(char const*); +const char* CSlim_BuyBuf(char const*, int); +const char* CSlim_BuyString(char const*); const char* CSlim_CreateEmptyString(void); -void CSlim_ConcatenateString(const char**, const char*); -int CSlim_StringStartsWith(const char* string, const char* prefix); -void CSlim_DestroyString(const char*); +void CSlim_ConcatenateString(const char**, const char*); +int CSlim_StringStartsWith(const char* string, const char* prefix); +void CSlim_DestroyString(const char*); typedef struct MapStringInt { - const char* string; - int n; + const char* string; + int n; } MapStringInt; -int CSlim_MapToIntFrom(MapStringInt*, const char*); +int CSlim_MapToIntFrom(MapStringInt*, const char*); const char* CSlim_MapToStringFrom(MapStringInt*, int); -int CSlim_IsCharacter(unsigned char const* byte); +int CSlim_IsCharacter(unsigned char const* byte); #ifndef CPP_COMPILING #ifdef __cplusplus diff --git a/include/CSlim/StatementExecutor.h b/include/CSlim/StatementExecutor.h index cdae550..91c51e5 100644 --- a/include/CSlim/StatementExecutor.h +++ b/include/CSlim/StatementExecutor.h @@ -10,24 +10,36 @@ extern "C" { #include "SlimList.h" typedef struct StatementExecutor StatementExecutor; -typedef void(*Fixture)(StatementExecutor*); -typedef void*(*Constructor)(StatementExecutor*, SlimList*); -typedef void(*Destructor)(void *); -typedef const char*(*Method)(void *, SlimList*); +typedef void (*Fixture)(StatementExecutor*); +typedef void* (*Constructor)(StatementExecutor*, SlimList*); +typedef void (*Destructor)(void*); +typedef const char* (*Method)(void*, SlimList*); StatementExecutor* StatementExecutor_Create(void); -void StatementExecutor_Destroy(StatementExecutor*); +void StatementExecutor_Destroy(StatementExecutor*); void StatementExecutor_AddFixture(StatementExecutor* executor, Fixture); -void StatementExecutor_RegisterFixture(StatementExecutor*, char const * className, Constructor, Destructor); -void StatementExecutor_RegisterMethod(StatementExecutor*, char const * className, char const * methodName, Method); - -const char* StatementExecutor_Make(StatementExecutor*, char const* instanceName, char const* className, SlimList* args); -const char* StatementExecutor_Call(StatementExecutor*, char const* instanceName, char const* methodName, SlimList*); -void* StatementExecutor_Instance(StatementExecutor*, char const* instanceName); -void StatementExecutor_SetSymbol(StatementExecutor*, char const* symbol, char const* value); - -void StatementExecutor_ConstructorError(StatementExecutor* executor, char const* message); +void StatementExecutor_RegisterFixture(StatementExecutor*, + char const* className, + Constructor, + Destructor); +void StatementExecutor_RegisterMethod(StatementExecutor*, + char const* className, + char const* methodName, + Method); + +const char* StatementExecutor_Make(StatementExecutor*, + char const* instanceName, + char const* className, + SlimList* args); +const char* StatementExecutor_Call(StatementExecutor*, + char const* instanceName, + char const* methodName, + SlimList*); +void* StatementExecutor_Instance(StatementExecutor*, char const* instanceName); +void StatementExecutor_SetSymbol(StatementExecutor*, char const* symbol, char const* value); + +void StatementExecutor_ConstructorError(StatementExecutor* executor, char const* message); const char* StatementExecutor_FixtureError(char const* message); #ifndef CPP_COMPILING diff --git a/include/Com/SocketServer.h b/include/Com/SocketServer.h index 3ce5d01..55103ca 100644 --- a/include/Com/SocketServer.h +++ b/include/Com/SocketServer.h @@ -16,9 +16,9 @@ extern "C" { typedef struct SocketServer SocketServer; SocketServer* SocketServer_Create(void); -void SocketServer_Destroy(SocketServer*); -extern int SocketServer_Run(SocketServer* self, char * port); -extern void SocketServer_register_handler(SocketServer* self, int (*handlerFunction)(int)); +void SocketServer_Destroy(SocketServer*); +extern int SocketServer_Run(SocketServer* self, char* port); +extern void SocketServer_register_handler(SocketServer* self, int (*handlerFunction)(int)); #ifndef CPP_COMPILING #ifdef __cplusplus @@ -26,4 +26,4 @@ extern void SocketServer_register_handler(SocketServer* self, int (*handlerFunct #endif #endif -#endif // D_SocketServer_H +#endif // D_SocketServer_H diff --git a/include/Com/TcpComLink.h b/include/Com/TcpComLink.h index 6663119..69eda4a 100644 --- a/include/Com/TcpComLink.h +++ b/include/Com/TcpComLink.h @@ -16,9 +16,9 @@ extern "C" { typedef struct TcpComLink TcpComLink; TcpComLink* TcpComLink_Create(int socket); -void TcpComLink_Destroy(TcpComLink*); -int TcpComLink_send(void * voidSelf, const char * msg, int length); -int TcpComLink_recv(void * voidSelf, char * buffer, int length); +void TcpComLink_Destroy(TcpComLink*); +int TcpComLink_send(void* voidSelf, const char* msg, int length); +int TcpComLink_recv(void* voidSelf, char* buffer, int length); #ifndef CPP_COMPILING #ifdef __cplusplus @@ -26,4 +26,4 @@ int TcpComLink_recv(void * voidSelf, char * buffer, int length); #endif #endif -#endif // D_TcpComLink_H +#endif // D_TcpComLink_H diff --git a/include/ComArduino/SerialComLink.h b/include/ComArduino/SerialComLink.h index d5a8adc..9baa3f7 100644 --- a/include/ComArduino/SerialComLink.h +++ b/include/ComArduino/SerialComLink.h @@ -6,7 +6,7 @@ typedef struct SerialComLink SerialComLink; SerialComLink* SerialComLink_Create(); void SerialComLink_Destroy(SerialComLink* self); -int SerialComLink_send(void * voidSelf, char * msg, int length); -int SerialComLink_recv(void * voidSelf, char * buffer, int length); +int SerialComLink_send(void* voidSelf, char* msg, int length); +int SerialComLink_recv(void* voidSelf, char* buffer, int length); #endif \ No newline at end of file diff --git a/include/ComArduino/TcpComLink.h b/include/ComArduino/TcpComLink.h index ffffb66..2b0fc7d 100644 --- a/include/ComArduino/TcpComLink.h +++ b/include/ComArduino/TcpComLink.h @@ -9,9 +9,9 @@ typedef struct TcpComLink TcpComLink; -TcpComLink* TcpComLink_Create(Client *); -void TcpComLink_Destroy(TcpComLink*); -int TcpComLink_send(void * voidSelf, const char * msg, int length); -int TcpComLink_recv(void * voidSelf, char * buffer, int length); +TcpComLink* TcpComLink_Create(Client*); +void TcpComLink_Destroy(TcpComLink*); +int TcpComLink_send(void* voidSelf, const char* msg, int length); +int TcpComLink_recv(void* voidSelf, char* buffer, int length); -#endif // D_TcpComLink_H +#endif // D_TcpComLink_H diff --git a/include/ExecutorC/SymbolTable.h b/include/ExecutorC/SymbolTable.h index 8d4d59e..99cc60d 100644 --- a/include/ExecutorC/SymbolTable.h +++ b/include/ExecutorC/SymbolTable.h @@ -10,10 +10,10 @@ extern "C" { typedef struct SymbolTable SymbolTable; SymbolTable* SymbolTable_Create(void); -void SymbolTable_Destroy(SymbolTable*); -const char * SymbolTable_FindSymbol(SymbolTable* self, char const* name, int length); -void SymbolTable_SetSymbol(SymbolTable* self, char const* symbol, char const* value); -int SymbolTable_GetSymbolLength(SymbolTable* self, char const* symbol, int length); +void SymbolTable_Destroy(SymbolTable*); +const char* SymbolTable_FindSymbol(SymbolTable* self, char const* name, int length); +void SymbolTable_SetSymbol(SymbolTable* self, char const* symbol, char const* value); +int SymbolTable_GetSymbolLength(SymbolTable* self, char const* symbol, int length); #ifndef CPP_COMPILING #ifdef __cplusplus diff --git a/src/CSlim/ListExecutor.c b/src/CSlim/ListExecutor.c index 9196965..d3f0414 100644 --- a/src/CSlim/ListExecutor.c +++ b/src/CSlim/ListExecutor.c @@ -1,126 +1,135 @@ #include "ListExecutor.h" #include "SlimUtil.h" -#include +#include "compatibility.h" #include +#include #include -#include "compatibility.h" struct ListExecutor { - StatementExecutor* executor; + StatementExecutor* executor; }; ListExecutor* ListExecutor_Create(StatementExecutor* executor) { - ListExecutor* self = (ListExecutor*)malloc(sizeof(ListExecutor)); - memset(self, 0, sizeof(ListExecutor)); - self->executor = executor; - return self; + ListExecutor* self = (ListExecutor*)malloc(sizeof(ListExecutor)); + memset(self, 0, sizeof(ListExecutor)); + self->executor = executor; + return self; } void ListExecutor_Destroy(ListExecutor* self) { - free(self); + free(self); } static void AddResult(SlimList* list, const char* id, const char* result) { - SlimList* pair = SlimList_Create(); - SlimList_AddString(pair, id); - SlimList_AddString(pair, result); - SlimList_AddList(list, pair); - SlimList_Destroy(pair); + SlimList* pair = SlimList_Create(); + SlimList_AddString(pair, id); + SlimList_AddString(pair, result); + SlimList_AddList(list, pair); + SlimList_Destroy(pair); } -const char* InvalidCommand(SlimList* instruction) { - const char* id = SlimList_GetStringAt(instruction, 0); - const char* command = SlimList_GetStringAt(instruction, 1); - static char msg[128]; - snprintf(msg, (size_t)128, "__EXCEPTION__:message:<>", id, command); - return CSlim_BuyString(msg); +const char* InvalidCommand(SlimList* instruction) +{ + const char* id = SlimList_GetStringAt(instruction, 0); + const char* command = SlimList_GetStringAt(instruction, 1); + static char msg[128]; + snprintf(msg, (size_t)128, "__EXCEPTION__:message:<>", id, + command); + return CSlim_BuyString(msg); } -const char* MalformedInstruction(SlimList* instruction) { - static char msg[128]; +const char* MalformedInstruction(SlimList* instruction) +{ + static char msg[128]; - const char* listAsAString = SlimList_ToString(instruction); - snprintf(msg, (size_t)128, "__EXCEPTION__:message:<>", listAsAString); - CSlim_DestroyString(listAsAString); + const char* listAsAString = SlimList_ToString(instruction); + snprintf(msg, (size_t)128, "__EXCEPTION__:message:<>", listAsAString); + CSlim_DestroyString(listAsAString); - return CSlim_BuyString(msg); + return CSlim_BuyString(msg); } -const char* Import() { - return CSlim_BuyString("OK"); +const char* Import() +{ + return CSlim_BuyString("OK"); } -const char* Make(ListExecutor* self, SlimList* instruction) { - const char *instanceName, *className, *result; - instanceName = SlimList_GetStringAt(instruction, 2); - className = SlimList_GetStringAt(instruction, 3); - SlimList* args = SlimList_GetTailAt(instruction, 4); - result = CSlim_BuyString(StatementExecutor_Make(self->executor, instanceName, className, args)); - SlimList_Destroy(args); - return result; +const char* Make(ListExecutor* self, SlimList* instruction) +{ + const char *instanceName, *className, *result; + instanceName = SlimList_GetStringAt(instruction, 2); + className = SlimList_GetStringAt(instruction, 3); + SlimList* args = SlimList_GetTailAt(instruction, 4); + result = CSlim_BuyString(StatementExecutor_Make(self->executor, instanceName, className, args)); + SlimList_Destroy(args); + return result; } -const char* Call(ListExecutor* self, SlimList* instruction) { +const char* Call(ListExecutor* self, SlimList* instruction) +{ const char *instanceName, *methodName, *result; - SlimList* args; - if (SlimList_GetLength(instruction) < 4) - return MalformedInstruction(instruction); - instanceName = SlimList_GetStringAt(instruction, 2); - methodName = SlimList_GetStringAt(instruction, 3); - args = SlimList_GetTailAt(instruction, 4); - result = CSlim_BuyString(StatementExecutor_Call(self->executor, instanceName, methodName, args)); - SlimList_Destroy(args); - return result; + SlimList* args; + if (SlimList_GetLength(instruction) < 4) + return MalformedInstruction(instruction); + instanceName = SlimList_GetStringAt(instruction, 2); + methodName = SlimList_GetStringAt(instruction, 3); + args = SlimList_GetTailAt(instruction, 4); + result = CSlim_BuyString(StatementExecutor_Call(self->executor, instanceName, methodName, args)); + SlimList_Destroy(args); + return result; } -const char* CallAndAssign(ListExecutor* self, SlimList* instruction) { +const char* CallAndAssign(ListExecutor* self, SlimList* instruction) +{ const char *symbolName, *instanceName, *methodName, *result; - SlimList* args; - if (SlimList_GetLength(instruction) < 5) - return MalformedInstruction(instruction); - symbolName = SlimList_GetStringAt(instruction, 2); - instanceName = SlimList_GetStringAt(instruction, 3); - methodName = SlimList_GetStringAt(instruction, 4); - args = SlimList_GetTailAt(instruction, 5); - result = CSlim_BuyString(StatementExecutor_Call(self->executor, instanceName, methodName, args)); - StatementExecutor_SetSymbol(self->executor, symbolName, result); - SlimList_Destroy(args); - return result; + SlimList* args; + if (SlimList_GetLength(instruction) < 5) + return MalformedInstruction(instruction); + symbolName = SlimList_GetStringAt(instruction, 2); + instanceName = SlimList_GetStringAt(instruction, 3); + methodName = SlimList_GetStringAt(instruction, 4); + args = SlimList_GetTailAt(instruction, 5); + result = CSlim_BuyString(StatementExecutor_Call(self->executor, instanceName, methodName, args)); + StatementExecutor_SetSymbol(self->executor, symbolName, result); + SlimList_Destroy(args); + return result; } -const char* Dispatch(ListExecutor* self, SlimList* instruction) { - const char* command = SlimList_GetStringAt(instruction, 1); - if (strcmp(command, "import") == 0) - return Import(); - else if (strcmp(command, "make") == 0) - return Make(self, instruction); - else if (strcmp(command, "call") == 0) - return Call(self, instruction); - else if (strcmp(command, "callAndAssign") == 0) - return CallAndAssign(self, instruction); - else - return InvalidCommand(instruction); +const char* Dispatch(ListExecutor* self, SlimList* instruction) +{ + const char* command = SlimList_GetStringAt(instruction, 1); + if (strcmp(command, "import") == 0) + return Import(); + else if (strcmp(command, "make") == 0) + return Make(self, instruction); + else if (strcmp(command, "call") == 0) + return Call(self, instruction); + else if (strcmp(command, "callAndAssign") == 0) + return CallAndAssign(self, instruction); + else + return InvalidCommand(instruction); } SlimList* ListExecutor_Execute(ListExecutor* self, SlimList* instructions) { - SlimList* results = SlimList_Create(); + SlimList* results = SlimList_Create(); - SlimListIterator* iterator = SlimList_CreateIterator(instructions); - while (SlimList_Iterator_HasItem(iterator)) { - SlimList* instruction = SlimList_Iterator_GetList(iterator); - const char* id = SlimList_GetStringAt(instruction, 0); - const char* result = Dispatch(self, instruction); - AddResult(results, id, result); + SlimListIterator* iterator = SlimList_CreateIterator(instructions); + while (SlimList_Iterator_HasItem(iterator)) + { + SlimList* instruction = SlimList_Iterator_GetList(iterator); + const char* id = SlimList_GetStringAt(instruction, 0); + const char* result = Dispatch(self, instruction); + AddResult(results, id, result); - CSlim_DestroyString(result); - SlimList_Iterator_Advance(&iterator); - } + CSlim_DestroyString(result); + SlimList_Iterator_Advance(&iterator); + } - return results; + return results; } diff --git a/src/CSlim/Slim.c b/src/CSlim/Slim.c index 814ba00..3227ec2 100644 --- a/src/CSlim/Slim.c +++ b/src/CSlim/Slim.c @@ -1,24 +1,24 @@ #include #include +#include "ListExecutor.h" #include "Slim.h" #include "SlimList.h" #include "SlimListDeserializer.h" -#include "StatementExecutor.h" -#include "ListExecutor.h" #include "SlimListSerializer.h" +#include "StatementExecutor.h" void AddFixtures(StatementExecutor*); struct Slim { - StatementExecutor * statementExecutor; - ListExecutor * listExecutor; + StatementExecutor* statementExecutor; + ListExecutor* listExecutor; }; -Slim * Slim_Create() +Slim* Slim_Create() { - Slim * self = (Slim*)malloc(sizeof(Slim)); + Slim* self = (Slim*)malloc(sizeof(Slim)); memset(self, 0, sizeof(Slim)); self->statementExecutor = StatementExecutor_Create(); AddFixtures(self->statementExecutor); @@ -26,19 +26,19 @@ Slim * Slim_Create() return self; } -void Slim_Destroy(Slim * self) +void Slim_Destroy(Slim* self) { ListExecutor_Destroy(self->listExecutor); StatementExecutor_Destroy(self->statementExecutor); free(self); } -char * Slim_HandleMessage(void* voidSelf, char * message) +char* Slim_HandleMessage(void* voidSelf, char* message) { - Slim* self = (Slim*)voidSelf; + Slim* self = (Slim*)voidSelf; SlimList* instructions = SlimList_Deserialize(message); SlimList* results = ListExecutor_Execute(self->listExecutor, instructions); - char * response = SlimList_Serialize(results); + char* response = SlimList_Serialize(results); SlimList_Destroy(results); SlimList_Destroy(instructions); return response; @@ -46,7 +46,7 @@ char * Slim_HandleMessage(void* voidSelf, char * message) int Slim_HandleConnection(Slim* self, void* comLink, com_func_send_t send, com_func_recv_t recv) { - int result = 0; + int result = 0; SlimConnectionHandler* connection = SlimConnectionHandler_Create(send, recv, comLink); SlimConnectionHandler_RegisterSlimMessageHandler(connection, self, &Slim_HandleMessage); result = SlimConnectionHandler_Run(connection); diff --git a/src/CSlim/SlimConnectionHandler.c b/src/CSlim/SlimConnectionHandler.c index d25986f..e5c78a9 100644 --- a/src/CSlim/SlimConnectionHandler.c +++ b/src/CSlim/SlimConnectionHandler.c @@ -1,106 +1,112 @@ #include "SlimConnectionHandler.h" #include "SlimListSerializer.h" +#include #include #include -#include -#include struct SlimConnectionHandler { - com_func_send_t sendFunc; - com_func_recv_t recvFunc; - void * comLink; - handler_func_t slimHandlerFunc; - void * slimHandler; + com_func_send_t sendFunc; + com_func_recv_t recvFunc; + void* comLink; + handler_func_t slimHandlerFunc; + void* slimHandler; }; -SlimConnectionHandler* SlimConnectionHandler_Create(com_func_send_t sendFunction, com_func_recv_t recvFunction, void * comLink) +SlimConnectionHandler* SlimConnectionHandler_Create(com_func_send_t sendFunction, + com_func_recv_t recvFunction, + void* comLink) { - SlimConnectionHandler* self = (SlimConnectionHandler*)malloc(sizeof(SlimConnectionHandler)); - memset(self, 0, sizeof(SlimConnectionHandler)); - self->sendFunc = sendFunction; - self->recvFunc = recvFunction; - self->comLink = comLink; - return self; + SlimConnectionHandler* self = (SlimConnectionHandler*)malloc(sizeof(SlimConnectionHandler)); + memset(self, 0, sizeof(SlimConnectionHandler)); + self->sendFunc = sendFunction; + self->recvFunc = recvFunction; + self->comLink = comLink; + return self; } void SlimConnectionHandler_Destroy(SlimConnectionHandler* self) { - free(self); + free(self); } -void SlimConnectionHandler_RegisterSlimMessageHandler(SlimConnectionHandler* self, void* handler, handler_func_t handlerFunc ) +void SlimConnectionHandler_RegisterSlimMessageHandler(SlimConnectionHandler* self, + void* handler, + handler_func_t handlerFunc) { self->slimHandler = handler; - self->slimHandlerFunc = handlerFunc; + self->slimHandlerFunc = handlerFunc; } int read_size(SlimConnectionHandler* self) { - char size[7]; - int size_i = 0; - char colon; - memset(size, (size_t)0, (size_t)7); + char size[7]; + int size_i = 0; + char colon; + memset(size, (size_t)0, (size_t)7); - int receiveResult = self->recvFunc(self->comLink, size, 6); - if (receiveResult == 6) - { - if ((self->recvFunc(self->comLink, &colon, 1)) == 1 && colon == ':') - { - size_i = atoi(size); - } - } else if (receiveResult == -1) { - size_i = -1;; - } - return size_i; + int receiveResult = self->recvFunc(self->comLink, size, 6); + if (receiveResult == 6) + { + if ((self->recvFunc(self->comLink, &colon, 1)) == 1 && colon == ':') + { + size_i = atoi(size); + } + } + else if (receiveResult == -1) + { + size_i = -1; + ; + } + return size_i; } - int SlimConnectionHandler_Run(SlimConnectionHandler* self) { - if (self->sendFunc(self->comLink, "Slim -- V0.2\n", 13) == -1) - { - return -1; - } - - char* message = NULL; - while(1) - { - int size_i = read_size(self); + if (self->sendFunc(self->comLink, "Slim -- V0.2\n", 13) == -1) + { + return -1; + } - if (size_i > 0) - { - free(message); - message = (char*)malloc(size_i + (size_t)1); - memset(message, 0, (size_t)size_i + (size_t)1); - int numbytes = self->recvFunc(self->comLink, message, size_i); - if (numbytes != size_i) - { - printf("did not receive right number of bytes. %d expected but received %d\n", size_i, numbytes); - break; - } - if (strcmp("bye", message) == 0) - { - break; - } - //execute and get response - char* response_message = self->slimHandlerFunc(self->slimHandler, message); - int response_length = (int)strlen(response_message); - char * length_buffer = (char *)malloc((size_t)8); - sprintf(length_buffer, "%06d:", response_length); - int send_result = self->sendFunc(self->comLink, length_buffer, 7); - free(length_buffer); - send_result = self->sendFunc(self->comLink, response_message, response_length); - SlimList_Release(response_message); - } else if (size_i == -1) - { - break; - } - } - free(message); - fflush(stdout); - return 0; + char* message = NULL; + while (1) + { + int size_i = read_size(self); + if (size_i > 0) + { + free(message); + message = (char*)malloc(size_i + (size_t)1); + memset(message, 0, (size_t)size_i + (size_t)1); + int numbytes = self->recvFunc(self->comLink, message, size_i); + if (numbytes != size_i) + { + printf("did not receive right number of bytes. %d expected but received %d\n", size_i, + numbytes); + break; + } + if (strcmp("bye", message) == 0) + { + break; + } + //execute and get response + char* response_message = self->slimHandlerFunc(self->slimHandler, message); + int response_length = (int)strlen(response_message); + char* length_buffer = (char*)malloc((size_t)8); + sprintf(length_buffer, "%06d:", response_length); + int send_result = self->sendFunc(self->comLink, length_buffer, 7); + free(length_buffer); + send_result = self->sendFunc(self->comLink, response_message, response_length); + SlimList_Release(response_message); + } + else if (size_i == -1) + { + break; + } + } + free(message); + fflush(stdout); + return 0; } diff --git a/src/CSlim/SlimList.c b/src/CSlim/SlimList.c index d91c630..7bbca82 100644 --- a/src/CSlim/SlimList.c +++ b/src/CSlim/SlimList.c @@ -1,176 +1,181 @@ #include "SlimList.h" -#include "SlimUtil.h" #include "SlimListDeserializer.h" #include "SlimListSerializer.h" +#include "SlimUtil.h" +#include #include #include #include -#include //static local variables typedef struct Node Node; -struct Node { - Node* next; - const char* string; - SlimList* list; +struct Node +{ + Node* next; + const char* string; + SlimList* list; }; -struct SlimList { - int length; - Node* head; - Node* tail; +struct SlimList +{ + int length; + Node* head; + Node* tail; }; - static void insertNode(SlimList* self, Node* node); static void SlimList_DestroyNode(Node* node); SlimList* SlimList_Create(void) { - SlimList* self = (SlimList*)malloc(sizeof(SlimList)); - memset(self, 0, sizeof(SlimList)); - return self; + SlimList* self = (SlimList*)malloc(sizeof(SlimList)); + memset(self, 0, sizeof(SlimList)); + return self; } void SlimList_Destroy(SlimList* self) { - Node * node; - Node * next; - - for(node = self->head; node; node = next) - { - next = node->next; - SlimList_DestroyNode(node); - } - free(self); + Node* node; + Node* next; + + for (node = self->head; node; node = next) + { + next = node->next; + SlimList_DestroyNode(node); + } + free(self); } -static void SlimList_DestroyNode(Node* node) { - if (node->string) - free((void*)node->string); +static void SlimList_DestroyNode(Node* node) +{ + if (node->string) + free((void*)node->string); - if (node->list) - SlimList_Destroy(node->list); + if (node->list) + SlimList_Destroy(node->list); - free(node); + free(node); } -SlimListIterator* SlimList_CreateIterator(SlimList* list) { - return list->head; +SlimListIterator* SlimList_CreateIterator(SlimList* list) +{ + return list->head; } -int SlimList_Iterator_HasItem(SlimListIterator* iterator) { - return iterator != NULL; +int SlimList_Iterator_HasItem(SlimListIterator* iterator) +{ + return iterator != NULL; } -void SlimList_Iterator_Advance(SlimListIterator** iterator) { - if (*iterator != NULL) - *iterator = (*iterator)->next; +void SlimList_Iterator_Advance(SlimListIterator** iterator) +{ + if (*iterator != NULL) + *iterator = (*iterator)->next; } void SlimList_AddBuffer(SlimList* self, char const* buffer, int length) { - Node* newNode = (Node*)malloc(sizeof(Node)); - newNode->next = 0; - newNode->list = 0; + Node* newNode = (Node*)malloc(sizeof(Node)); + newNode->next = 0; + newNode->list = 0; - insertNode(self, newNode); + insertNode(self, newNode); - newNode->string = CSlim_BuyBuf(buffer, length); + newNode->string = CSlim_BuyBuf(buffer, length); } - void SlimList_AddString(SlimList* self, char const* string) { - SlimList_AddBuffer(self, string, string ? (int)strlen(string) : 0); + SlimList_AddBuffer(self, string, string ? (int)strlen(string) : 0); } void SlimList_AddList(SlimList* self, SlimList* element) { - char * embedded = SlimList_Serialize(element); - SlimList_AddString(self, embedded); - SlimList_Release(embedded); + char* embedded = SlimList_Serialize(element); + SlimList_AddString(self, embedded); + SlimList_Release(embedded); } void SlimList_PopHead(SlimList* self) { - assert(self->head != NULL); + assert(self->head != NULL); - Node* previousHead = self->head; - self->head = previousHead->next; + Node* previousHead = self->head; + self->head = previousHead->next; - if (self->tail == previousHead) - self->tail = NULL; + if (self->tail == previousHead) + self->tail = NULL; - self->length--; + self->length--; - SlimList_DestroyNode(previousHead); + SlimList_DestroyNode(previousHead); } int SlimList_GetLength(SlimList* self) { - return self->length; + return self->length; } -int SlimList_Equals(SlimList* self, SlimList* other){ - Node *p, *q; - if (self->length != other->length) - return 0; +int SlimList_Equals(SlimList* self, SlimList* other) +{ + Node *p, *q; + if (self->length != other->length) + return 0; - for (p = self->head, q=other->head; p; p=p->next, q=q->next) - { - if (strcmp(p->string, q->string) != 0) - return 0; - } + for (p = self->head, q = other->head; p; p = p->next, q = q->next) + { + if (strcmp(p->string, q->string) != 0) + return 0; + } - return 1; + return 1; } Node* SlimList_GetNodeAt(SlimList* self, int index) { - int i; - Node* node = self->head; + int i; + Node* node = self->head; - if (index >= self->length) - return 0; + if (index >= self->length) + return 0; - for (i = 0; i < index; i++) - { - node = node->next; - } - return node; + for (i = 0; i < index; i++) + { + node = node->next; + } + return node; } -SlimList * SlimList_GetListAt(SlimList* self, int index) +SlimList* SlimList_GetListAt(SlimList* self, int index) { - Node * node = SlimList_GetNodeAt(self, index); - return SlimList_Iterator_GetList(node); + Node* node = SlimList_GetNodeAt(self, index); + return SlimList_Iterator_GetList(node); } SlimList* SlimList_Iterator_GetList(SlimListIterator* iterator) { - assert(iterator != NULL); + assert(iterator != NULL); - if (iterator->list == 0) - iterator->list = SlimList_Deserialize(iterator->string); + if (iterator->list == 0) + iterator->list = SlimList_Deserialize(iterator->string); - return iterator->list; + return iterator->list; } const char* SlimList_GetStringAt(SlimList* self, int index) { - Node* node = SlimList_GetNodeAt(self, index); - if(node == 0) - return 0; + Node* node = SlimList_GetNodeAt(self, index); + if (node == 0) + return 0; - return SlimList_Iterator_GetString(node); + return SlimList_Iterator_GetString(node); } const char* SlimList_Iterator_GetString(SlimListIterator* iterator) { - assert(iterator != NULL); - return iterator->string; + assert(iterator != NULL); + return iterator->string; } double SlimList_GetDoubleAt(SlimList* self, int index) @@ -179,136 +184,146 @@ double SlimList_GetDoubleAt(SlimList* self, int index) return atof(speed_s); } -static const char * parseHashCell(const char ** cellStart) +static const char* parseHashCell(const char** cellStart) { - const char * cellValue = *cellStart + strlen(""); - const char * cellStop = strstr(cellValue, ""); - - int length = (int)(cellStop - cellValue); - char * buf = (char*)malloc(length + 1); - strncpy(buf, cellValue, length); - buf[length] = '\0'; - - *cellStart = strstr(cellStop + strlen(""), ""); - - return buf; + const char* cellValue = *cellStart + strlen(""); + const char* cellStop = strstr(cellValue, ""); + + int length = (int)(cellStop - cellValue); + char* buf = (char*)malloc(length + 1); + strncpy(buf, cellValue, length); + buf[length] = '\0'; + + *cellStart = strstr(cellStop + strlen(""), ""); + + return buf; } -static SlimList* parseHashEntry(const char * row) +static SlimList* parseHashEntry(const char* row) { - SlimList * element = SlimList_Create(); + SlimList* element = SlimList_Create(); + + const char* cellStart = strstr(row, ""); - const char * cellStart = strstr(row, ""); + const char* hashKey = parseHashCell(&cellStart); + SlimList_AddString(element, hashKey); + free((void*)hashKey); - const char * hashKey = parseHashCell(&cellStart); - SlimList_AddString(element, hashKey); - free((void*)hashKey); + const char* hashValue = parseHashCell(&cellStart); + SlimList_AddString(element, hashValue); + free((void*)hashValue); - const char * hashValue = parseHashCell(&cellStart); - SlimList_AddString(element, hashValue); - free((void*)hashValue); - - return element; + return element; } -static SlimList* SlimList_deserializeHash(const char * serializedHash) -{ - SlimList *element; - SlimList *hash = SlimList_Create(); - - const char * row = strstr(serializedHash, ""); +static SlimList* SlimList_deserializeHash(const char* serializedHash) +{ + SlimList* element; + SlimList* hash = SlimList_Create(); + + const char* row = strstr(serializedHash, ""); while (row != NULL) - { - element = parseHashEntry(row); - SlimList_AddList(hash, element); - SlimList_Destroy(element); - row = strstr(row + strlen(""), ""); - } - return hash; + { + element = parseHashEntry(row); + SlimList_AddList(hash, element); + SlimList_Destroy(element); + row = strstr(row + strlen(""), ""); + } + return hash; } SlimList* SlimList_GetHashAt(SlimList* self, int index) { - return SlimList_deserializeHash(SlimList_GetStringAt(self, 0)); + return SlimList_deserializeHash(SlimList_GetStringAt(self, 0)); } -void SlimList_ReplaceAt(SlimList* self, int index, char const * replacementString) +void SlimList_ReplaceAt(SlimList* self, int index, char const* replacementString) { - Node* node = SlimList_GetNodeAt(self, index); - SlimList_Iterator_Replace(node, replacementString); + Node* node = SlimList_GetNodeAt(self, index); + SlimList_Iterator_Replace(node, replacementString); } -void SlimList_Iterator_Replace(SlimListIterator* iterator, const char* replacementString) { - if (iterator->list != 0) { - SlimList_Destroy(iterator->list); - iterator->list = 0; - } - const char* newString = CSlim_BuyString(replacementString); - free((void*)iterator->string); - iterator->string = newString; +void SlimList_Iterator_Replace(SlimListIterator* iterator, const char* replacementString) +{ + if (iterator->list != 0) + { + SlimList_Destroy(iterator->list); + iterator->list = 0; + } + const char* newString = CSlim_BuyString(replacementString); + free((void*)iterator->string); + iterator->string = newString; } static void insertNode(SlimList* self, Node* node) { - if (self->length == 0) - { - self->head = node; - } - else - { - self->tail->next = node; - } - self->tail = node; - self->length++; + if (self->length == 0) + { + self->head = node; + } + else + { + self->tail->next = node; + } + self->tail = node; + self->length++; } -void SlimList_Iterator_AdvanceBy(SlimListIterator** iterator, int amount) { - int i; - for (i = 0; i < amount; i++) { - SlimList_Iterator_Advance(iterator); - } +void SlimList_Iterator_AdvanceBy(SlimListIterator** iterator, int amount) +{ + int i; + for (i = 0; i < amount; i++) + { + SlimList_Iterator_Advance(iterator); + } } SlimList* SlimList_GetTailAt(SlimList* self, int index) { - SlimList * tail = SlimList_Create(); + SlimList* tail = SlimList_Create(); - SlimListIterator* iterator = SlimList_CreateIterator(self); - SlimList_Iterator_AdvanceBy(&iterator, index); + SlimListIterator* iterator = SlimList_CreateIterator(self); + SlimList_Iterator_AdvanceBy(&iterator, index); - while (SlimList_Iterator_HasItem(iterator)) - { - SlimList_AddString(tail, SlimList_Iterator_GetString(iterator)); - SlimList_Iterator_Advance(&iterator); - } + while (SlimList_Iterator_HasItem(iterator)) + { + SlimList_AddString(tail, SlimList_Iterator_GetString(iterator)); + SlimList_Iterator_Advance(&iterator); + } - return tail; + return tail; } -const char* SlimList_ToString(SlimList* self) { - const char* result = CSlim_CreateEmptyString(); - CSlim_ConcatenateString(&result, "["); - - SlimListIterator* iterator = SlimList_CreateIterator(self); - while (SlimList_Iterator_HasItem(iterator)) { - SlimList* sublist = SlimList_Iterator_GetList(iterator); - - if (sublist != NULL) { - const char* subListAsAString = SlimList_ToString(sublist); - CSlim_ConcatenateString(&result, subListAsAString); - CSlim_DestroyString(subListAsAString); - } else { - CSlim_ConcatenateString(&result, "\""); - CSlim_ConcatenateString(&result, SlimList_Iterator_GetString(iterator)); - CSlim_ConcatenateString(&result, "\""); - } - - if (iterator->next != NULL) { - CSlim_ConcatenateString(&result, ", "); - } - SlimList_Iterator_Advance(&iterator); - } - CSlim_ConcatenateString(&result, "]"); - - return result; +const char* SlimList_ToString(SlimList* self) +{ + const char* result = CSlim_CreateEmptyString(); + CSlim_ConcatenateString(&result, "["); + + SlimListIterator* iterator = SlimList_CreateIterator(self); + while (SlimList_Iterator_HasItem(iterator)) + { + SlimList* sublist = SlimList_Iterator_GetList(iterator); + + if (sublist != NULL) + { + const char* subListAsAString = SlimList_ToString(sublist); + CSlim_ConcatenateString(&result, subListAsAString); + CSlim_DestroyString(subListAsAString); + } + else + { + CSlim_ConcatenateString(&result, "\""); + CSlim_ConcatenateString(&result, SlimList_Iterator_GetString(iterator)); + CSlim_ConcatenateString(&result, "\""); + } + + if (iterator->next != NULL) + { + CSlim_ConcatenateString(&result, ", "); + } + SlimList_Iterator_Advance(&iterator); + } + CSlim_ConcatenateString(&result, "]"); + + return result; } diff --git a/src/CSlim/SlimListDeserializer.c b/src/CSlim/SlimListDeserializer.c index f135bd9..eeb7c7a 100644 --- a/src/CSlim/SlimListDeserializer.c +++ b/src/CSlim/SlimListDeserializer.c @@ -3,66 +3,65 @@ #include #include -#define SKIP(a) \ -if (*current != (a))\ -{\ - SlimList_Destroy(list); \ - return 0;\ -}\ -current++; +#define SKIP(a) \ + if (*current != (a)) \ + { \ + SlimList_Destroy(list); \ + return 0; \ + } \ + current++; int readLength(char const** readPtr) { - int length = atoi(*readPtr); - *readPtr += 6; - return length; + int length = atoi(*readPtr); + *readPtr += 6; + return length; } -int ByteLength( int characterLength, char const * current ) +int ByteLength(int characterLength, char const* current) { - unsigned char const * p; - int chars=0; - int bytes=0; - for( p = (unsigned char const*) current; chars <= characterLength; p++) - { - bytes++; - if( CSlim_IsCharacter(p) == 1 ) - chars++; - } - if( chars > characterLength ) - bytes--; - return bytes; + unsigned char const* p; + int chars = 0; + int bytes = 0; + for (p = (unsigned char const*)current; chars <= characterLength; p++) + { + bytes++; + if (CSlim_IsCharacter(p) == 1) + chars++; + } + if (chars > characterLength) + bytes--; + return bytes; } SlimList* SlimList_Deserialize(char const* serializedList) { - int listLength; - SlimList * list = 0; - char const * current = 0; + int listLength; + SlimList* list = 0; + char const* current = 0; - if(serializedList == 0 || strlen(serializedList) == 0) - return 0; + if (serializedList == 0 || strlen(serializedList) == 0) + return 0; - current = serializedList; - list = SlimList_Create(); + current = serializedList; + list = SlimList_Create(); - SKIP('[') + SKIP('[') - listLength = readLength(¤t); + listLength = readLength(¤t); - SKIP(':') + SKIP(':') - while (listLength--) - { - int characterLength = readLength(¤t); - SKIP(':') - int byteLength = ByteLength(characterLength, current); - SlimList_AddBuffer(list, current, byteLength); - current += byteLength; - SKIP(':') - } + while (listLength--) + { + int characterLength = readLength(¤t); + SKIP(':') + int byteLength = ByteLength(characterLength, current); + SlimList_AddBuffer(list, current, byteLength); + current += byteLength; + SKIP(':') + } - SKIP(']') - return list; + SKIP(']') + return list; } - diff --git a/src/CSlim/SlimListSerializer.c b/src/CSlim/SlimListSerializer.c index a8aab2b..46f526e 100644 --- a/src/CSlim/SlimListSerializer.c +++ b/src/CSlim/SlimListSerializer.c @@ -1,69 +1,75 @@ +#include "SlimListSerializer.h" #include "SlimList.h" #include "SlimUtil.h" -#include "SlimListSerializer.h" -#include -#include #include +#include +#include static const char* stringForNullNode = "null"; -enum {LIST_OVERHEAD=9, ELEMENT_OVERHEAD=8}; +enum +{ + LIST_OVERHEAD = 9, + ELEMENT_OVERHEAD = 8 +}; static const char* GetStringWithNullAsANormalString(SlimListIterator* iterator) { - const char* nodeString = SlimList_Iterator_GetString(iterator); + const char* nodeString = SlimList_Iterator_GetString(iterator); - if (nodeString == NULL) - nodeString = stringForNullNode; + if (nodeString == NULL) + nodeString = stringForNullNode; - return nodeString; + return nodeString; } -long FieldLength(unsigned char * nodeString) +long FieldLength(unsigned char* nodeString) { - unsigned char *p; - long fieldlength=0; - for (p=nodeString;*p;p++) - if (CSlim_IsCharacter(p) == 1) - fieldlength++; - return fieldlength; + unsigned char* p; + long fieldlength = 0; + for (p = nodeString; *p; p++) + if (CSlim_IsCharacter(p) == 1) + fieldlength++; + return fieldlength; } int SlimList_SerializedLength(SlimList* self) { - int length = LIST_OVERHEAD; + int length = LIST_OVERHEAD; - SlimListIterator* iterator = SlimList_CreateIterator(self); - while (SlimList_Iterator_HasItem(iterator)) { - length += strlen(GetStringWithNullAsANormalString(iterator)) + ELEMENT_OVERHEAD; + SlimListIterator* iterator = SlimList_CreateIterator(self); + while (SlimList_Iterator_HasItem(iterator)) + { + length += strlen(GetStringWithNullAsANormalString(iterator)) + ELEMENT_OVERHEAD; - SlimList_Iterator_Advance(&iterator); - } + SlimList_Iterator_Advance(&iterator); + } - return length; + return length; } char* SlimList_Serialize(SlimList* self) { - char* buf = (char*)malloc(SlimList_SerializedLength(self)+1); - char* write_ptr = buf; - int listLength = SlimList_GetLength(self); + char* buf = (char*)malloc(SlimList_SerializedLength(self) + 1); + char* write_ptr = buf; + int listLength = SlimList_GetLength(self); + + write_ptr += sprintf(write_ptr, "[%06d:", listLength); - write_ptr += sprintf(write_ptr, "[%06d:", listLength); + SlimListIterator* iterator = SlimList_CreateIterator(self); + while (SlimList_Iterator_HasItem(iterator)) + { + unsigned char* nodeString = (unsigned char*)GetStringWithNullAsANormalString(iterator); + write_ptr += sprintf(write_ptr, "%06ld:%s:", FieldLength(nodeString), nodeString); - SlimListIterator* iterator = SlimList_CreateIterator(self); - while (SlimList_Iterator_HasItem(iterator)) { - unsigned char * nodeString = (unsigned char *) GetStringWithNullAsANormalString(iterator); - write_ptr += sprintf(write_ptr, "%06ld:%s:", FieldLength(nodeString), nodeString); - - SlimList_Iterator_Advance(&iterator); - } - strcpy(write_ptr, "]"); - return buf; + SlimList_Iterator_Advance(&iterator); + } + strcpy(write_ptr, "]"); + return buf; } -void SlimList_Release(char *serializedResults) +void SlimList_Release(char* serializedResults) { - if(serializedResults) + if (serializedResults) free(serializedResults); } diff --git a/src/CSlim/SlimUtil.c b/src/CSlim/SlimUtil.c index e725b8c..b700eb6 100644 --- a/src/CSlim/SlimUtil.c +++ b/src/CSlim/SlimUtil.c @@ -1,74 +1,77 @@ -#include -#include #include "SlimUtil.h" #include +#include +#include -const char * CSlim_BuyBuf(char const* buffer, int length) +const char* CSlim_BuyBuf(char const* buffer, int length) { - if (buffer == NULL) - return NULL; + if (buffer == NULL) + return NULL; - char * purchase = (char*)malloc(length+1); - strncpy(purchase, buffer, length); - purchase[length] = '\0'; - return purchase; + char* purchase = (char*)malloc(length + 1); + strncpy(purchase, buffer, length); + purchase[length] = '\0'; + return purchase; } -const char * CSlim_BuyString(char const* string) +const char* CSlim_BuyString(char const* string) { - if (string == NULL) - return NULL; - return CSlim_BuyBuf(string, (int)strlen(string)); + if (string == NULL) + return NULL; + return CSlim_BuyBuf(string, (int)strlen(string)); } -const char* CSlim_CreateEmptyString(void) { - char* result = (char*)malloc(sizeof(char)); - assert(result != NULL); +const char* CSlim_CreateEmptyString(void) +{ + char* result = (char*)malloc(sizeof(char)); + assert(result != NULL); - result[0] = '\0'; - return result; + result[0] = '\0'; + return result; } -void CSlim_DestroyString(char const* string) { - free((void*)string); +void CSlim_DestroyString(char const* string) +{ + free((void*)string); } //Note: the location of toAppendTo may change as a result of calling this function. The old location should no longer be used. -void CSlim_ConcatenateString(const char** toAppendTo, const char* toAppend) { - size_t requiredLength = strlen(*toAppendTo) + strlen(toAppend) + 1; +void CSlim_ConcatenateString(const char** toAppendTo, const char* toAppend) +{ + size_t requiredLength = strlen(*toAppendTo) + strlen(toAppend) + 1; - char *temp = (char*)realloc((char*)*toAppendTo, requiredLength * sizeof(char)); - assert(temp != NULL); + char* temp = (char*)realloc((char*)*toAppendTo, requiredLength * sizeof(char)); + assert(temp != NULL); - strcat(temp, toAppend); + strcat(temp, toAppend); - *toAppendTo = temp; + *toAppendTo = temp; } int CSlim_StringStartsWith(const char* string, const char* prefix) { - return strncmp(string, prefix, strlen(prefix)) == 0; + return strncmp(string, prefix, strlen(prefix)) == 0; } int CSlim_MapToIntFrom(MapStringInt* map, const char* name) { - MapStringInt* p = map; - while (p->string != NULL && 0 != strcmp(name, p->string)) - { - p++; - } + MapStringInt* p = map; + while (p->string != NULL && 0 != strcmp(name, p->string)) + { + p++; + } - return p->n; + return p->n; } const char* CSlim_MapToStringFrom(MapStringInt* map, int n) { - MapStringInt* p = map; - while (p->string != NULL && n != p->n) - { - p++; - } + MapStringInt* p = map; + while (p->string != NULL && n != p->n) + { + p++; + } - return p->string; + return p->string; } int CSlim_IsCharacter(unsigned char const* byte) diff --git a/src/CSlim_main/Main.c b/src/CSlim_main/Main.c index 8e416da..7710ea8 100644 --- a/src/CSlim_main/Main.c +++ b/src/CSlim_main/Main.c @@ -1,34 +1,33 @@ #include "Slim.h" -#include "SocketServer.h" #include "SlimConnectionHandler.h" +#include "SocketServer.h" #include "TcpComLink.h" #include #include -Slim * slim; +Slim* slim; int connection_handler(int socket) { - int result = 0; - TcpComLink * comLink = TcpComLink_Create(socket); + int result = 0; + TcpComLink* comLink = TcpComLink_Create(socket); - result = Slim_HandleConnection(slim, (void*)comLink, &TcpComLink_send, &TcpComLink_recv); + result = Slim_HandleConnection(slim, (void*)comLink, &TcpComLink_send, &TcpComLink_recv); - TcpComLink_Destroy(comLink); + TcpComLink_Destroy(comLink); - return result; + return result; } int main(int ac, char** av) { - slim = Slim_Create(); - SocketServer* server = SocketServer_Create(); - SocketServer_register_handler(server, &connection_handler); + slim = Slim_Create(); + SocketServer* server = SocketServer_Create(); + SocketServer_register_handler(server, &connection_handler); - int result = SocketServer_Run(server, av[1]); + int result = SocketServer_Run(server, av[1]); - SocketServer_Destroy(server); - Slim_Destroy(slim); - return result; + SocketServer_Destroy(server); + Slim_Destroy(slim); + return result; } - diff --git a/src/Com/SocketServer.c b/src/Com/SocketServer.c index ddd5884..6aa4c66 100644 --- a/src/Com/SocketServer.c +++ b/src/Com/SocketServer.c @@ -1,143 +1,147 @@ #include "SocketServer.h" -#include -#include -#include -#include +#include #include +#include +#include +#include +#include +#include #include -#include #include -#include -#include -#include +#include #include -#include - +#include //static local variables struct SocketServer { - int (*handler)(int); + int (*handler)(int); }; SocketServer* SocketServer_Create(void) { - SocketServer* self = (SocketServer*)malloc(sizeof(SocketServer)); - memset(self, 0, sizeof(SocketServer)); - return self; + SocketServer* self = (SocketServer*)malloc(sizeof(SocketServer)); + memset(self, 0, sizeof(SocketServer)); + return self; } void SocketServer_Destroy(SocketServer* self) { - free(self); + free(self); } -#define BACKLOG 10 // how many pending connections queue will hold +#define BACKLOG 10 // how many pending connections queue will hold void sigchld_handler(int s) { - while(waitpid(-1, NULL, WNOHANG) > 0); + while (waitpid(-1, NULL, WNOHANG) > 0) + ; } // get sockaddr, IPv4 or IPv6: -void *get_in_addr(struct sockaddr *sa) +void* get_in_addr(struct sockaddr* sa) { - if (sa->sa_family == AF_INET) { - return &(((struct sockaddr_in*)sa)->sin_addr); - } + if (sa->sa_family == AF_INET) + { + return &(((struct sockaddr_in*)sa)->sin_addr); + } - return &(((struct sockaddr_in6*)sa)->sin6_addr); + return &(((struct sockaddr_in6*)sa)->sin6_addr); } - + void SocketServer_register_handler(SocketServer* self, int (*handlerFunction)(int)) { - self->handler = handlerFunction; + self->handler = handlerFunction; } void serve(SocketServer* self, int socket) { - (*self->handler)(socket); + (*self->handler)(socket); } -int SocketServer_Run(SocketServer* self, char * listening_port_number) +int SocketServer_Run(SocketServer* self, char* listening_port_number) { - int sockfd, new_fd; // listen on sock_fd, new connection on new_fd - struct addrinfo hints, *servinfo, *p; - struct sockaddr_storage their_addr; // connector's address information - socklen_t sin_size; - struct sigaction sa; - int yes=1; - char s[INET6_ADDRSTRLEN]; - int rv; - - memset(&hints, 0, sizeof hints); - hints.ai_family = AF_UNSPEC; - hints.ai_socktype = SOCK_STREAM; - hints.ai_flags = AI_PASSIVE; // use my IP - - if ((rv = getaddrinfo(NULL, listening_port_number, &hints, &servinfo)) != 0) { - fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(rv)); - return 1; + int sockfd, new_fd; // listen on sock_fd, new connection on new_fd + struct addrinfo hints, *servinfo, *p; + struct sockaddr_storage their_addr; // connector's address information + socklen_t sin_size; + struct sigaction sa; + int yes = 1; + char s[INET6_ADDRSTRLEN]; + int rv; + + memset(&hints, 0, sizeof hints); + hints.ai_family = AF_UNSPEC; + hints.ai_socktype = SOCK_STREAM; + hints.ai_flags = AI_PASSIVE; // use my IP + + if ((rv = getaddrinfo(NULL, listening_port_number, &hints, &servinfo)) != 0) + { + fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(rv)); + return 1; + } + + // loop through all the results and bind to the first we can + for (p = servinfo; p != NULL; p = p->ai_next) + { + if ((sockfd = socket(p->ai_family, p->ai_socktype, p->ai_protocol)) == -1) + { + perror("server: socket"); + continue; } - // loop through all the results and bind to the first we can - for(p = servinfo; p != NULL; p = p->ai_next) { - if ((sockfd = socket(p->ai_family, p->ai_socktype, - p->ai_protocol)) == -1) { - perror("server: socket"); - continue; - } - - if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &yes, - sizeof(int)) == -1) { - perror("setsockopt"); - exit(1); - } - - if (bind(sockfd, p->ai_addr, p->ai_addrlen) == -1) { - close(sockfd); - perror("server: bind"); - continue; - } - - break; + if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)) == -1) + { + perror("setsockopt"); + exit(1); } - if (p == NULL) { - fprintf(stderr, "server: failed to bind\n"); - return 2; + if (bind(sockfd, p->ai_addr, p->ai_addrlen) == -1) + { + close(sockfd); + perror("server: bind"); + continue; } - freeaddrinfo(servinfo); // all done with this structure + break; + } - if (listen(sockfd, BACKLOG) == -1) { - perror("listen"); - exit(1); - } + if (p == NULL) + { + fprintf(stderr, "server: failed to bind\n"); + return 2; + } - sa.sa_handler = sigchld_handler; // reap all dead processes - sigemptyset(&sa.sa_mask); - sa.sa_flags = SA_RESTART; - if (sigaction(SIGCHLD, &sa, NULL) == -1) { - perror("sigaction"); - exit(1); - } + freeaddrinfo(servinfo); // all done with this structure - sin_size = sizeof their_addr; - new_fd = accept(sockfd, (struct sockaddr *)&their_addr, &sin_size); - if (new_fd == -1) { - perror("accept"); - return -1; - } + if (listen(sockfd, BACKLOG) == -1) + { + perror("listen"); + exit(1); + } - inet_ntop(their_addr.ss_family, - get_in_addr((struct sockaddr *)&their_addr), - s, sizeof s); + sa.sa_handler = sigchld_handler; // reap all dead processes + sigemptyset(&sa.sa_mask); + sa.sa_flags = SA_RESTART; + if (sigaction(SIGCHLD, &sa, NULL) == -1) + { + perror("sigaction"); + exit(1); + } - serve(self, new_fd); + sin_size = sizeof their_addr; + new_fd = accept(sockfd, (struct sockaddr*)&their_addr, &sin_size); + if (new_fd == -1) + { + perror("accept"); + return -1; + } - close(new_fd); + inet_ntop(their_addr.ss_family, get_in_addr((struct sockaddr*)&their_addr), s, sizeof s); - return 0; -} + serve(self, new_fd); + + close(new_fd); + return 0; +} diff --git a/src/Com/TcpComLink.c b/src/Com/TcpComLink.c index 2add43e..bcdc552 100644 --- a/src/Com/TcpComLink.c +++ b/src/Com/TcpComLink.c @@ -6,43 +6,45 @@ //static local variables struct TcpComLink { - int socket; + int socket; }; TcpComLink* TcpComLink_Create(int socket) { - TcpComLink* self = (TcpComLink*)malloc(sizeof(TcpComLink)); - memset(self, 0, sizeof(TcpComLink)); - self->socket = socket; - return self; + TcpComLink* self = (TcpComLink*)malloc(sizeof(TcpComLink)); + memset(self, 0, sizeof(TcpComLink)); + self->socket = socket; + return self; } void TcpComLink_Destroy(TcpComLink* self) { - free(self); + free(self); } - -int TcpComLink_send(void * voidSelf, const char * msg, int length) +int TcpComLink_send(void* voidSelf, const char* msg, int length) { - TcpComLink * self = (TcpComLink *)voidSelf; - int total = 0; // how many bytes we've sent - int bytesleft = length; // how many we have left to send - int n; - - while(total < length) { - n = (int)send(self->socket, msg+total, bytesleft, 0); - if (n == -1) { break; } - total += n; - bytesleft -= n; + TcpComLink* self = (TcpComLink*)voidSelf; + int total = 0; // how many bytes we've sent + int bytesleft = length; // how many we have left to send + int n; + + while (total < length) + { + n = (int)send(self->socket, msg + total, bytesleft, 0); + if (n == -1) + { + break; } + total += n; + bytesleft -= n; + } - return total; -} - + return total; +} -int TcpComLink_recv(void * voidSelf, char * buffer, int length) +int TcpComLink_recv(void* voidSelf, char* buffer, int length) { - TcpComLink * self = (TcpComLink *)voidSelf; - return (int)recv(self->socket, buffer, length, MSG_WAITALL); + TcpComLink* self = (TcpComLink*)voidSelf; + return (int)recv(self->socket, buffer, length, MSG_WAITALL); } diff --git a/src/ComArduino/SerialComLink.cpp b/src/ComArduino/SerialComLink.cpp index 9f959db..86c3910 100644 --- a/src/ComArduino/SerialComLink.cpp +++ b/src/ComArduino/SerialComLink.cpp @@ -9,32 +9,33 @@ struct SerialComLink SerialComLink* SerialComLink_Create() { - return 0; + return 0; } void SerialComLink_Destroy(SerialComLink* self) { } - -int SerialComLink_send(void * voidSelf, char * msg, int length) +int SerialComLink_send(void* voidSelf, char* msg, int length) { Serial.write((uint8_t*)msg, length); return length; } -int SerialComLink_recv(void * voidSelf, char * buffer, int length) +int SerialComLink_recv(void* voidSelf, char* buffer, int length) { int bytes_read = 0; - while(Serial.available() <= 0) + while (Serial.available() <= 0) { delay(100); } - while(bytes_read < length) { - while(Serial.available() <= 0); - buffer[bytes_read] = (char) Serial.read(); + while (bytes_read < length) + { + while (Serial.available() <= 0) + ; + buffer[bytes_read] = (char)Serial.read(); bytes_read += 1; } diff --git a/src/ComArduino/TcpComLink.cpp b/src/ComArduino/TcpComLink.cpp index 154cd46..46e2246 100644 --- a/src/ComArduino/TcpComLink.cpp +++ b/src/ComArduino/TcpComLink.cpp @@ -2,44 +2,42 @@ #include - #include "TcpComLink.h" //static local variables struct TcpComLink { - Client * client; + Client* client; }; -TcpComLink* TcpComLink_Create(Client * client) +TcpComLink* TcpComLink_Create(Client* client) { - TcpComLink* self = (TcpComLink*)malloc(sizeof(TcpComLink)); - memset(self, 0, sizeof(TcpComLink)); - self->client = client; - return self; + TcpComLink* self = (TcpComLink*)malloc(sizeof(TcpComLink)); + memset(self, 0, sizeof(TcpComLink)); + self->client = client; + return self; } void TcpComLink_Destroy(TcpComLink* self) { - free(self); + free(self); } - -int TcpComLink_send(void * voidSelf, const char * msg, int length) +int TcpComLink_send(void* voidSelf, const char* msg, int length) { - TcpComLink * self = (TcpComLink *)voidSelf; + TcpComLink* self = (TcpComLink*)voidSelf; self->client->write((uint8_t*)(msg), length); return length; -} - +} -int TcpComLink_recv(void * voidSelf, char * buffer, int length) +int TcpComLink_recv(void* voidSelf, char* buffer, int length) { - TcpComLink * self = (TcpComLink *)voidSelf; - int bytes_read = 0; + TcpComLink* self = (TcpComLink*)voidSelf; + int bytes_read = 0; - Client * client = self->client; - while(client->available() > 0 && bytes_read < length) { + Client* client = self->client; + while (client->available() > 0 && bytes_read < length) + { buffer[bytes_read] = client->read(); bytes_read += 1; } diff --git a/src/ComWin32/SocketServer.c b/src/ComWin32/SocketServer.c index 5c0f324..f5fb5c6 100644 --- a/src/ComWin32/SocketServer.c +++ b/src/ComWin32/SocketServer.c @@ -1,6 +1,6 @@ #include "SocketServer.h" -#include #include +#include static void StartWSA(SocketServer* self); static void BindToSocket(SocketServer* self); @@ -11,95 +11,95 @@ static void WaitForConnection(SocketServer* self); //static local variables struct SocketServer { - int (*handler)(int); - SOCKET Socket; - int itsPort; + int (*handler)(int); + SOCKET Socket; + int itsPort; }; SocketServer* SocketServer_Create(void) { - SocketServer* self = (SocketServer*)malloc(sizeof(SocketServer)); - memset(self, 0, sizeof(SocketServer)); - return self; + SocketServer* self = (SocketServer*)malloc(sizeof(SocketServer)); + memset(self, 0, sizeof(SocketServer)); + return self; } void SocketServer_Destroy(SocketServer* self) { - Shutdown(self); - free(self); + Shutdown(self); + free(self); } void SocketServer_register_handler(SocketServer* self, int (*handlerFunction)(int)) { - self->handler = handlerFunction; + self->handler = handlerFunction; } void serve(SocketServer* self, int socket) { - (*self->handler)(socket); + (*self->handler)(socket); } -int SocketServer_Run(SocketServer* self, char * listening_port_number) +int SocketServer_Run(SocketServer* self, char* listening_port_number) { - self->itsPort = atoi(listening_port_number); - StartWSA(self); - CreateSocket(self); - BindToSocket(self); - WaitForConnection(self); - Shutdown(self); - - return 0; + self->itsPort = atoi(listening_port_number); + StartWSA(self); + CreateSocket(self); + BindToSocket(self); + WaitForConnection(self); + Shutdown(self); + + return 0; } void Shutdown(SocketServer* self) { - shutdown(self->Socket,SD_SEND); - closesocket(self->Socket); - WSACleanup(); + shutdown(self->Socket, SD_SEND); + closesocket(self->Socket); + WSACleanup(); } void WaitForConnection(SocketServer* self) { - listen(self->Socket,1); + listen(self->Socket, 1); + + SOCKET TempSock = SOCKET_ERROR; + while (TempSock == SOCKET_ERROR) + { + TempSock = accept(self->Socket, NULL, NULL); + } - SOCKET TempSock = SOCKET_ERROR; - while(TempSock==SOCKET_ERROR) - { - TempSock = accept(self->Socket,NULL,NULL); - } - - serve(self, TempSock); + serve(self, TempSock); - closesocket(TempSock); + closesocket(TempSock); } void StartWSA(SocketServer* self) { - WSADATA WsaDat; - if(WSAStartup(MAKEWORD(2,2),&WsaDat) != 0) - { - printf("WSA Initialization failed!"); - } + WSADATA WsaDat; + if (WSAStartup(MAKEWORD(2, 2), &WsaDat) != 0) + { + printf("WSA Initialization failed!"); + } } void CreateSocket(SocketServer* self) { - self->Socket = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP); - if(self->Socket == INVALID_SOCKET) - { - printf("Socket creationg failed."); - } + self->Socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); + if (self->Socket == INVALID_SOCKET) + { + printf("Socket creationg failed."); + } } void BindToSocket(SocketServer* self) { - SOCKADDR_IN serverInf; - serverInf.sin_family=AF_INET; - serverInf.sin_addr.s_addr=INADDR_ANY; - serverInf.sin_port=htons(self->itsPort); - - if(bind(self->Socket,(SOCKADDR*)(&serverInf),sizeof(serverInf)) == SOCKET_ERROR) - { - printf("Unable to bind socket!"); - } + SOCKADDR_IN serverInf; + serverInf.sin_family = AF_INET; + serverInf.sin_addr.s_addr = INADDR_ANY; + serverInf.sin_port = htons(self->itsPort); + + if (bind(self->Socket, (SOCKADDR*)(&serverInf), sizeof(serverInf)) == SOCKET_ERROR) + { + printf("Unable to bind socket!"); + } } diff --git a/src/ComWin32/TcpComLink.c b/src/ComWin32/TcpComLink.c index 518dab8..11d7bd9 100644 --- a/src/ComWin32/TcpComLink.c +++ b/src/ComWin32/TcpComLink.c @@ -4,48 +4,52 @@ //static local variables struct TcpComLink { - SOCKET Socket; + SOCKET Socket; }; TcpComLink* TcpComLink_Create(int socket) { - TcpComLink* self = (TcpComLink*)malloc(sizeof(TcpComLink)); - memset(self, 0, sizeof(TcpComLink)); - self->Socket = socket; - return self; + TcpComLink* self = (TcpComLink*)malloc(sizeof(TcpComLink)); + memset(self, 0, sizeof(TcpComLink)); + self->Socket = socket; + return self; } void TcpComLink_Destroy(TcpComLink* self) { - free(self); + free(self); } -int TcpComLink_send(void * voidSelf, const char * msg, int length) +int TcpComLink_send(void* voidSelf, const char* msg, int length) { - TcpComLink * self = (TcpComLink *)voidSelf; - int total = 0; // how many bytes we've sent - int bytesleft = length; // how many we have left to send - int n; - - while(total < length) { - n = send(self->Socket, msg+total, bytesleft, 0); - if (n == -1) { break; } - total += n; - bytesleft -= n; + TcpComLink* self = (TcpComLink*)voidSelf; + int total = 0; // how many bytes we've sent + int bytesleft = length; // how many we have left to send + int n; + + while (total < length) + { + n = send(self->Socket, msg + total, bytesleft, 0); + if (n == -1) + { + break; } + total += n; + bytesleft -= n; + } - return total; -} + return total; +} -int TcpComLink_recv(void * voidSelf, char * buffer, int length) +int TcpComLink_recv(void* voidSelf, char* buffer, int length) { - TcpComLink * self = (TcpComLink *)voidSelf; - - //No MSG_WAITALL flag in winsock2 ???? - int bytesReceived = 0; - while (bytesReceived < length) - { - bytesReceived += recv(self->Socket, buffer + bytesReceived, length - bytesReceived, 0); - } - return bytesReceived; + TcpComLink* self = (TcpComLink*)voidSelf; + + //No MSG_WAITALL flag in winsock2 ???? + int bytesReceived = 0; + while (bytesReceived < length) + { + bytesReceived += recv(self->Socket, buffer + bytesReceived, length - bytesReceived, 0); + } + return bytesReceived; } diff --git a/src/ExecutorC/StatementExecutor.c b/src/ExecutorC/StatementExecutor.c index 1bd2e81..3a8c6de 100644 --- a/src/ExecutorC/StatementExecutor.c +++ b/src/ExecutorC/StatementExecutor.c @@ -2,376 +2,443 @@ #include "SlimList.h" #include "SlimListDeserializer.h" #include "SlimListSerializer.h" +#include "SlimUtil.h" +#include #include #include -#include -#include "SlimUtil.h" // #include #include "SymbolTable.h" #include "assert.h" -#include #include "compatibility.h" +#include -typedef struct methodNode { - struct methodNode* next; - char const* name; - Method method; +typedef struct methodNode +{ + struct methodNode* next; + char const* name; + Method method; } MethodNode; -typedef struct fixtureNode { - struct fixtureNode* next; - Constructor constructor; - Destructor destructor; - MethodNode* methods; - char const* name; +typedef struct fixtureNode +{ + struct fixtureNode* next; + Constructor constructor; + Destructor destructor; + MethodNode* methods; + char const* name; } FixtureNode; -typedef struct instanceNode { - struct instanceNode* next; - char const* name; - void* instance; - FixtureNode* fixture; +typedef struct instanceNode +{ + struct instanceNode* next; + char const* name; + void* instance; + FixtureNode* fixture; } InstanceNode; -typedef struct symbolNode { - struct symbolNode* next; - char const* name; - char const* value; +typedef struct symbolNode +{ + struct symbolNode* next; + char const* name; + char const* value; } SymbolNode; struct StatementExecutor { - FixtureNode* fixtures; - InstanceNode* instances; - InstanceNode* libraryInstances; - SymbolTable * symbolTable; - char message[120]; - char const* userMessage; + FixtureNode* fixtures; + InstanceNode* instances; + InstanceNode* libraryInstances; + SymbolTable* symbolTable; + char message[120]; + char const* userMessage; }; - - -static void destroyInstances(InstanceNode*); -static void destroyFixtures(FixtureNode*); -static void destroyMethods(MethodNode*); +static void destroyInstances(InstanceNode*); +static void destroyFixtures(FixtureNode*); +static void destroyMethods(MethodNode*); static FixtureNode* findFixture(StatementExecutor* executor, const char* classNameWithSymbols); -static int isLibraryInstanceName(const char* instanceName); -static void pushInstance(InstanceNode** stack, InstanceNode* instanceNode); -static MethodNode* findMethodNode(MethodNode* methodNodes, const char* methodName); -static const char* invokeMethodOnInstanceWithArguments(StatementExecutor* executor, MethodNode* methodNode, InstanceNode* instanceNode, SlimList* args); -void replaceSymbols(SymbolTable*, SlimList*); -static const char* replaceString(SymbolTable*, const char*); -static const char* replaceStringFrom(SymbolTable*, const char*, const char*); -static int lengthOfSymbol(const char *); -static FixtureNode * findFixtureByName(StatementExecutor* executor, char const * className); -static void Null_Destroy(void* self); -static void* Null_Create(StatementExecutor* executor, SlimList* args); - +static int isLibraryInstanceName(const char* instanceName); +static void pushInstance(InstanceNode** stack, InstanceNode* instanceNode); +static MethodNode* findMethodNode(MethodNode* methodNodes, const char* methodName); +static const char* invokeMethodOnInstanceWithArguments(StatementExecutor* executor, + MethodNode* methodNode, + InstanceNode* instanceNode, + SlimList* args); +void replaceSymbols(SymbolTable*, SlimList*); +static const char* replaceString(SymbolTable*, const char*); +static const char* replaceStringFrom(SymbolTable*, const char*, const char*); +static int lengthOfSymbol(const char*); +static FixtureNode* findFixtureByName(StatementExecutor* executor, char const* className); +static void Null_Destroy(void* self); +static void* Null_Create(StatementExecutor* executor, SlimList* args); StatementExecutor* StatementExecutor_Create(void) { - StatementExecutor* self = (StatementExecutor*)malloc(sizeof(StatementExecutor)); - memset(self, 0, sizeof(StatementExecutor)); - self->symbolTable = SymbolTable_Create(); - return self; + StatementExecutor* self = (StatementExecutor*)malloc(sizeof(StatementExecutor)); + memset(self, 0, sizeof(StatementExecutor)); + self->symbolTable = SymbolTable_Create(); + return self; } -static int compareNamesIgnoreUnderScores(const char * name1, const char * name2) -{ - while (*name1 && *name2) - { - if (*name1 == *name2) { name1++; name2++;} - else if ((*name1) == '_') name1++; - else if (*name2 == '_') name2++; - else return 0; - } - if (*name1 != *name2) - return 0; - return 1; +static int compareNamesIgnoreUnderScores(const char* name1, const char* name2) +{ + while (*name1 && *name2) + { + if (*name1 == *name2) + { + name1++; + name2++; + } + else if ((*name1) == '_') + name1++; + else if (*name2 == '_') + name2++; + else + return 0; + } + if (*name1 != *name2) + return 0; + return 1; } InstanceNode* GetInstanceNode(StatementExecutor* executor, char const* instanceName) { - InstanceNode* instanceNode; - for (instanceNode = executor->instances; instanceNode; instanceNode = instanceNode->next) { -// if (strcmp(instanceNode->name, instanceName) == 0) { - if (compareNamesIgnoreUnderScores(instanceNode->name, instanceName)) { - return instanceNode; - } - } - return NULL; + InstanceNode* instanceNode; + for (instanceNode = executor->instances; instanceNode; instanceNode = instanceNode->next) + { + // if (strcmp(instanceNode->name, instanceName) == 0) { + if (compareNamesIgnoreUnderScores(instanceNode->name, instanceName)) + { + return instanceNode; + } + } + return NULL; } void StatementExecutor_Destroy(StatementExecutor* self) { - destroyInstances(self->libraryInstances); - destroyInstances(self->instances); - destroyFixtures(self->fixtures); - SymbolTable_Destroy(self->symbolTable); - free(self); + destroyInstances(self->libraryInstances); + destroyInstances(self->instances); + destroyFixtures(self->fixtures); + SymbolTable_Destroy(self->symbolTable); + free(self); } -static void destroyInstances(InstanceNode* head) { - InstanceNode* instanceNode; - for (instanceNode = head; instanceNode;) { - InstanceNode* nextInstanceNode = instanceNode->next; - instanceNode->fixture->destructor(instanceNode->instance); - free(instanceNode); - instanceNode = nextInstanceNode; - } +static void destroyInstances(InstanceNode* head) +{ + InstanceNode* instanceNode; + for (instanceNode = head; instanceNode;) + { + InstanceNode* nextInstanceNode = instanceNode->next; + instanceNode->fixture->destructor(instanceNode->instance); + free(instanceNode); + instanceNode = nextInstanceNode; + } } -static void destroyFixtures(FixtureNode* head) { - FixtureNode* fixtureNode; - for (fixtureNode = head; fixtureNode;) { - FixtureNode* nextFixtureNode = fixtureNode->next; - destroyMethods(fixtureNode->methods); - free(fixtureNode); - fixtureNode = nextFixtureNode; - } +static void destroyFixtures(FixtureNode* head) +{ + FixtureNode* fixtureNode; + for (fixtureNode = head; fixtureNode;) + { + FixtureNode* nextFixtureNode = fixtureNode->next; + destroyMethods(fixtureNode->methods); + free(fixtureNode); + fixtureNode = nextFixtureNode; + } } -static void destroyMethods(MethodNode* head) { - MethodNode* node; - for (node = head; node;) { - MethodNode* nextNode = node->next; - free(node); - node = nextNode; - } +static void destroyMethods(MethodNode* head) +{ + MethodNode* node; + for (node = head; node;) + { + MethodNode* nextNode = node->next; + free(node); + node = nextNode; + } } -const char* StatementExecutor_Make(StatementExecutor* executor, char const* instanceName, char const* className, SlimList* args){ - FixtureNode* fixtureNode = findFixture(executor, className); - if (fixtureNode) { - InstanceNode* instanceNode = (InstanceNode* )malloc(sizeof(InstanceNode)); - if (isLibraryInstanceName(instanceName)) { - pushInstance(&(executor->libraryInstances), instanceNode); - } else { - pushInstance(&(executor->instances), instanceNode); - } - instanceNode->name = instanceName; - instanceNode->fixture = fixtureNode; - replaceSymbols(executor->symbolTable, args); - executor->userMessage = NULL; - instanceNode->instance = (fixtureNode->constructor)(executor, args); - if (instanceNode->instance != NULL) { - return "OK"; - } else { - const char * formatString = "__EXCEPTION__:message:<>"; - snprintf(executor->message, 120, formatString, className, executor->userMessage ? executor->userMessage : ""); - return executor->message; - } - } - const char * formatString = "__EXCEPTION__:message:<>"; - snprintf(executor->message, 120, formatString, className); - return executor->message; +const char* StatementExecutor_Make(StatementExecutor* executor, + char const* instanceName, + char const* className, + SlimList* args) +{ + FixtureNode* fixtureNode = findFixture(executor, className); + if (fixtureNode) + { + InstanceNode* instanceNode = (InstanceNode*)malloc(sizeof(InstanceNode)); + if (isLibraryInstanceName(instanceName)) + { + pushInstance(&(executor->libraryInstances), instanceNode); + } + else + { + pushInstance(&(executor->instances), instanceNode); + } + instanceNode->name = instanceName; + instanceNode->fixture = fixtureNode; + replaceSymbols(executor->symbolTable, args); + executor->userMessage = NULL; + instanceNode->instance = (fixtureNode->constructor)(executor, args); + if (instanceNode->instance != NULL) + { + return "OK"; + } + else + { + const char* formatString = + "__EXCEPTION__:message:<>"; + snprintf(executor->message, 120, formatString, className, + executor->userMessage ? executor->userMessage : ""); + return executor->message; + } + } + const char* formatString = "__EXCEPTION__:message:<>"; + snprintf(executor->message, 120, formatString, className); + return executor->message; } -const char* StatementExecutor_Call(StatementExecutor* executor, char const* instanceName, char const* methodName, SlimList* args){ - InstanceNode* instanceNode = GetInstanceNode(executor, instanceName); - if (instanceNode) - { - MethodNode* methodNode = findMethodNode(instanceNode->fixture->methods, methodName); - if (methodNode) { - return invokeMethodOnInstanceWithArguments(executor, methodNode, instanceNode, args); - } - - for (InstanceNode* libraryInstanceNode = executor->libraryInstances; libraryInstanceNode; libraryInstanceNode = libraryInstanceNode->next) { - methodNode = findMethodNode(libraryInstanceNode->fixture->methods, methodName); - if (methodNode) { - return invokeMethodOnInstanceWithArguments(executor, methodNode, libraryInstanceNode, args); - } - } - - const char * formatString = "__EXCEPTION__:message:<>"; - snprintf(executor->message, 120, formatString, methodName, SlimList_GetLength(args), instanceNode->fixture->name); - return executor->message; - } - const char * formatString = "__EXCEPTION__:message:<>"; - snprintf(executor->message, 120, formatString, instanceName); - return executor->message; +const char* StatementExecutor_Call(StatementExecutor* executor, + char const* instanceName, + char const* methodName, + SlimList* args) +{ + InstanceNode* instanceNode = GetInstanceNode(executor, instanceName); + if (instanceNode) + { + MethodNode* methodNode = findMethodNode(instanceNode->fixture->methods, methodName); + if (methodNode) + { + return invokeMethodOnInstanceWithArguments(executor, methodNode, instanceNode, args); + } + + for (InstanceNode* libraryInstanceNode = executor->libraryInstances; libraryInstanceNode; + libraryInstanceNode = libraryInstanceNode->next) + { + methodNode = findMethodNode(libraryInstanceNode->fixture->methods, methodName); + if (methodNode) + { + return invokeMethodOnInstanceWithArguments(executor, methodNode, libraryInstanceNode, args); + } + } + + const char* formatString = "__EXCEPTION__:message:<>"; + snprintf(executor->message, 120, formatString, methodName, SlimList_GetLength(args), + instanceNode->fixture->name); + return executor->message; + } + const char* formatString = "__EXCEPTION__:message:<>"; + snprintf(executor->message, 120, formatString, instanceName); + return executor->message; } static FixtureNode* findFixture(StatementExecutor* executor, const char* classNameWithSymbols) { - const char* className = replaceString(executor->symbolTable, classNameWithSymbols); - FixtureNode* fixtureNode = findFixtureByName(executor, className); - free((void*)className); - return fixtureNode; + const char* className = replaceString(executor->symbolTable, classNameWithSymbols); + FixtureNode* fixtureNode = findFixtureByName(executor, className); + free((void*)className); + return fixtureNode; } static int isLibraryInstanceName(const char* instanceName) { - return CSlim_StringStartsWith(instanceName, "library"); + return CSlim_StringStartsWith(instanceName, "library"); } static void pushInstance(InstanceNode** stack, InstanceNode* instanceNode) { - instanceNode->next = *stack; - *stack = instanceNode; + instanceNode->next = *stack; + *stack = instanceNode; } static MethodNode* findMethodNode(MethodNode* methodNodes, const char* methodName) { - MethodNode* node = NULL; - for (node = methodNodes; node; node = node->next) { - if (compareNamesIgnoreUnderScores(methodName, node->name)) { - break; - } - } - return node; + MethodNode* node = NULL; + for (node = methodNodes; node; node = node->next) + { + if (compareNamesIgnoreUnderScores(methodName, node->name)) + { + break; + } + } + return node; } -static const char* invokeMethodOnInstanceWithArguments(StatementExecutor* executor, MethodNode* methodNode, InstanceNode* instanceNode, SlimList* args) +static const char* invokeMethodOnInstanceWithArguments(StatementExecutor* executor, + MethodNode* methodNode, + InstanceNode* instanceNode, + SlimList* args) { - replaceSymbols(executor->symbolTable, args); - return methodNode->method(instanceNode->instance, args); + replaceSymbols(executor->symbolTable, args); + return methodNode->method(instanceNode->instance, args); } -void replaceSymbols(SymbolTable* symbolTable, SlimList* list) { - SlimListIterator* iterator = SlimList_CreateIterator(list); - while (SlimList_Iterator_HasItem(iterator)) { - const char* string = SlimList_Iterator_GetString(iterator); - SlimList* embeddedList = SlimList_Deserialize(string); - if (embeddedList == NULL) { - const char* replacedString = replaceString(symbolTable, string); - SlimList_Iterator_Replace(iterator, replacedString); - free((void*)replacedString); - } else { - replaceSymbols(symbolTable, embeddedList); - char* serializedReplacedList = SlimList_Serialize(embeddedList); - SlimList_Iterator_Replace(iterator, serializedReplacedList); - SlimList_Destroy(embeddedList); - SlimList_Release(serializedReplacedList); - } - SlimList_Iterator_Advance(&iterator); - } +void replaceSymbols(SymbolTable* symbolTable, SlimList* list) +{ + SlimListIterator* iterator = SlimList_CreateIterator(list); + while (SlimList_Iterator_HasItem(iterator)) + { + const char* string = SlimList_Iterator_GetString(iterator); + SlimList* embeddedList = SlimList_Deserialize(string); + if (embeddedList == NULL) + { + const char* replacedString = replaceString(symbolTable, string); + SlimList_Iterator_Replace(iterator, replacedString); + free((void*)replacedString); + } + else + { + replaceSymbols(symbolTable, embeddedList); + char* serializedReplacedList = SlimList_Serialize(embeddedList); + SlimList_Iterator_Replace(iterator, serializedReplacedList); + SlimList_Destroy(embeddedList); + SlimList_Release(serializedReplacedList); + } + SlimList_Iterator_Advance(&iterator); + } } -static const char* replaceString(SymbolTable* symbolTable, const char* string) { - return replaceStringFrom(symbolTable, string, string); +static const char* replaceString(SymbolTable* symbolTable, const char* string) +{ + return replaceStringFrom(symbolTable, string, string); } -static const char* replaceStringFrom(SymbolTable* symbolTable, const char* string, const char* from) { - const char * dollarSign = strpbrk(from, "$"); - if (dollarSign) - { - int length = lengthOfSymbol(dollarSign + 1); - const char * symbolValue = SymbolTable_FindSymbol(symbolTable, dollarSign + 1, length); - if (symbolValue) - { - int valueLength = strlen(symbolValue); - int bufferLength = strlen(string)+valueLength-(length+1) + 1; - char * newString = (char*)malloc(bufferLength); - memset(newString, 0, bufferLength); - strncat(newString, string, (dollarSign - string)); - strcat(newString, symbolValue); - strcat(newString, dollarSign + 1 + length); - - assert(bufferLength == strlen(newString) + 1); - - const char* recursedString = replaceStringFrom(symbolTable, newString, newString); - free(newString); - return recursedString; - } - else - { - if (*(dollarSign+1) == 0) - return CSlim_BuyString(string); - - return replaceStringFrom(symbolTable, string, dollarSign+1); - } - } - return CSlim_BuyString(string); +static const char* replaceStringFrom(SymbolTable* symbolTable, const char* string, const char* from) +{ + const char* dollarSign = strpbrk(from, "$"); + if (dollarSign) + { + int length = lengthOfSymbol(dollarSign + 1); + const char* symbolValue = SymbolTable_FindSymbol(symbolTable, dollarSign + 1, length); + if (symbolValue) + { + int valueLength = strlen(symbolValue); + int bufferLength = strlen(string) + valueLength - (length + 1) + 1; + char* newString = (char*)malloc(bufferLength); + memset(newString, 0, bufferLength); + strncat(newString, string, (dollarSign - string)); + strcat(newString, symbolValue); + strcat(newString, dollarSign + 1 + length); + + assert(bufferLength == strlen(newString) + 1); + + const char* recursedString = replaceStringFrom(symbolTable, newString, newString); + free(newString); + return recursedString; + } + else + { + if (*(dollarSign + 1) == 0) + return CSlim_BuyString(string); + + return replaceStringFrom(symbolTable, string, dollarSign + 1); + } + } + return CSlim_BuyString(string); } -static int lengthOfSymbol(const char * start) +static int lengthOfSymbol(const char* start) { - int length = 0; - while(isalnum(*start)) - { - start++; - length ++; - } - return length; + int length = 0; + while (isalnum(*start)) + { + start++; + length++; + } + return length; } -void* StatementExecutor_Instance(StatementExecutor* executor, char const* instanceName){ +void* StatementExecutor_Instance(StatementExecutor* executor, char const* instanceName) +{ - InstanceNode* instanceNode = GetInstanceNode(executor, instanceName); - if (instanceNode) - return instanceNode->instance; - return NULL; + InstanceNode* instanceNode = GetInstanceNode(executor, instanceName); + if (instanceNode) + return instanceNode->instance; + return NULL; } -void StatementExecutor_AddFixture(StatementExecutor* executor, Fixture fixture) { - fixture(executor); +void StatementExecutor_AddFixture(StatementExecutor* executor, Fixture fixture) +{ + fixture(executor); } -void StatementExecutor_RegisterFixture(StatementExecutor* executor, char const * className, Constructor constructor, Destructor destructor){ - FixtureNode* fixtureNode = findFixtureByName(executor, className); - if (!fixtureNode) - { - fixtureNode = (FixtureNode*)malloc(sizeof(FixtureNode)); - fixtureNode->next = executor->fixtures; - executor->fixtures = fixtureNode; - fixtureNode->name = className; - fixtureNode->methods = NULL; - } - - fixtureNode->constructor = constructor; - fixtureNode->destructor = destructor; +void StatementExecutor_RegisterFixture(StatementExecutor* executor, + char const* className, + Constructor constructor, + Destructor destructor) +{ + FixtureNode* fixtureNode = findFixtureByName(executor, className); + if (!fixtureNode) + { + fixtureNode = (FixtureNode*)malloc(sizeof(FixtureNode)); + fixtureNode->next = executor->fixtures; + executor->fixtures = fixtureNode; + fixtureNode->name = className; + fixtureNode->methods = NULL; + } + + fixtureNode->constructor = constructor; + fixtureNode->destructor = destructor; } -static FixtureNode * findFixtureByName(StatementExecutor* executor, char const* className) +static FixtureNode* findFixtureByName(StatementExecutor* executor, char const* className) { - FixtureNode* fixtureNode = NULL; - for (fixtureNode = executor->fixtures; fixtureNode; fixtureNode = fixtureNode->next) { -// if (strcmp(fixtureNode->name, className) == 0) { - if (compareNamesIgnoreUnderScores(fixtureNode->name, className)) { - break; - } - } - return fixtureNode; + FixtureNode* fixtureNode = NULL; + for (fixtureNode = executor->fixtures; fixtureNode; fixtureNode = fixtureNode->next) + { + // if (strcmp(fixtureNode->name, className) == 0) { + if (compareNamesIgnoreUnderScores(fixtureNode->name, className)) + { + break; + } + } + return fixtureNode; } -void StatementExecutor_RegisterMethod(StatementExecutor* executor, char const * className, char const * methodName, Method method){ - FixtureNode* fixtureNode = findFixtureByName(executor, className); - if (fixtureNode == NULL) { - StatementExecutor_RegisterFixture(executor, className, Null_Create, Null_Destroy); - fixtureNode = findFixtureByName(executor, className); - } - - MethodNode* node = (MethodNode*)malloc(sizeof(MethodNode)); - node->name = methodName; - node->method = method; - node->next = fixtureNode->methods; - fixtureNode->methods = node; - return; +void StatementExecutor_RegisterMethod(StatementExecutor* executor, + char const* className, + char const* methodName, + Method method) +{ + FixtureNode* fixtureNode = findFixtureByName(executor, className); + if (fixtureNode == NULL) + { + StatementExecutor_RegisterFixture(executor, className, Null_Create, Null_Destroy); + fixtureNode = findFixtureByName(executor, className); + } + + MethodNode* node = (MethodNode*)malloc(sizeof(MethodNode)); + node->name = methodName; + node->method = method; + node->next = fixtureNode->methods; + fixtureNode->methods = node; + return; } -void StatementExecutor_SetSymbol(StatementExecutor* self, char const* symbol, char const* value) { - SymbolTable_SetSymbol(self->symbolTable, symbol, value); +void StatementExecutor_SetSymbol(StatementExecutor* self, char const* symbol, char const* value) +{ + SymbolTable_SetSymbol(self->symbolTable, symbol, value); } -void StatementExecutor_ConstructorError(StatementExecutor* executor, char const* message) { - executor->userMessage = message; +void StatementExecutor_ConstructorError(StatementExecutor* executor, char const* message) +{ + executor->userMessage = message; } -const char* StatementExecutor_FixtureError(char const* message) { - static char buffer[128]; - const char * formatString = "__EXCEPTION__:message:<<%.100s.>>"; - snprintf(buffer, sizeof(buffer), formatString, message); - return buffer; +const char* StatementExecutor_FixtureError(char const* message) +{ + static char buffer[128]; + const char* formatString = "__EXCEPTION__:message:<<%.100s.>>"; + snprintf(buffer, sizeof(buffer), formatString, message); + return buffer; } static void* Null_Create(StatementExecutor* executor, SlimList* args) { - return NULL; + return NULL; } static void Null_Destroy(void* self) { } - - diff --git a/src/ExecutorC/SymbolTable.c b/src/ExecutorC/SymbolTable.c index d0847ee..7646750 100644 --- a/src/ExecutorC/SymbolTable.c +++ b/src/ExecutorC/SymbolTable.c @@ -1,63 +1,65 @@ #include "SymbolTable.h" +#include "SlimUtil.h" #include #include -#include "SlimUtil.h" -typedef struct symbolNode { - struct symbolNode* next; - const char* name; - const char* value; +typedef struct symbolNode +{ + struct symbolNode* next; + const char* name; + const char* value; } SymbolNode; struct SymbolTable { - SymbolNode * head; + SymbolNode* head; }; SymbolTable* SymbolTable_Create(void) { - SymbolTable* self = (SymbolTable*)malloc(sizeof(SymbolTable)); - memset(self, 0, sizeof(SymbolTable)); - return self; + SymbolTable* self = (SymbolTable*)malloc(sizeof(SymbolTable)); + memset(self, 0, sizeof(SymbolTable)); + return self; } void SymbolTable_Destroy(SymbolTable* self) { - SymbolNode* node; - for (node = self->head; node;) { - SymbolNode* nextSymbolNode = node->next; - free((void*)node->name); - free((void*)node->value); - free(node); - node = nextSymbolNode; - } - free(self); + SymbolNode* node; + for (node = self->head; node;) + { + SymbolNode* nextSymbolNode = node->next; + free((void*)node->name); + free((void*)node->value); + free(node); + node = nextSymbolNode; + } + free(self); } -const char * SymbolTable_FindSymbol(SymbolTable* self, char const * name, int length) { - SymbolNode* node; - for (node = self->head; node; node = node->next) - { - if (strlen(node->name) == length && strncmp(node->name, name, length) == 0) - return node->value; - } - return NULL; +const char* SymbolTable_FindSymbol(SymbolTable* self, char const* name, int length) +{ + SymbolNode* node; + for (node = self->head; node; node = node->next) + { + if (strlen(node->name) == length && strncmp(node->name, name, length) == 0) + return node->value; + } + return NULL; } -void SymbolTable_SetSymbol(SymbolTable* self, char const * symbol, char const * value) { - SymbolNode * symbolNode = (SymbolNode * )malloc(sizeof(SymbolNode)); - symbolNode->name = CSlim_BuyString(symbol); - symbolNode->value = CSlim_BuyString(value); - symbolNode->next = self->head; - self->head = symbolNode; +void SymbolTable_SetSymbol(SymbolTable* self, char const* symbol, char const* value) +{ + SymbolNode* symbolNode = (SymbolNode*)malloc(sizeof(SymbolNode)); + symbolNode->name = CSlim_BuyString(symbol); + symbolNode->value = CSlim_BuyString(value); + symbolNode->next = self->head; + self->head = symbolNode; } int SymbolTable_GetSymbolLength(SymbolTable* self, char const* symbol, int length) { - const char * symbolValue = SymbolTable_FindSymbol(self, symbol, length); - if (symbolValue == NULL) - return -1; - return strlen(symbolValue); + const char* symbolValue = SymbolTable_FindSymbol(self, symbol, length); + if (symbolValue == NULL) + return -1; + return strlen(symbolValue); } - - diff --git a/tests/AllTests.cpp b/tests/AllTests.cpp index 31a3907..e0545d4 100644 --- a/tests/AllTests.cpp +++ b/tests/AllTests.cpp @@ -3,6 +3,5 @@ int main(int ac, char** av) { - return CommandLineTestRunner::RunAllTests(ac, av); + return CommandLineTestRunner::RunAllTests(ac, av); } - diff --git a/tests/CSlim/ListExecutorTest.cpp b/tests/CSlim/ListExecutorTest.cpp index 253225f..fb4d337 100644 --- a/tests/CSlim/ListExecutorTest.cpp +++ b/tests/CSlim/ListExecutorTest.cpp @@ -7,44 +7,44 @@ TEST_GROUP(ListExecutor) { - ListExecutor* listExecutor; - SlimList* instructions; - StatementExecutor * statementExecutor; - void setup() + ListExecutor* listExecutor; + SlimList* instructions; + StatementExecutor* statementExecutor; + void setup() + { + statementExecutor = StatementExecutor_Create(); + StatementExecutor_AddFixture(statementExecutor, TestSlim_Register); + listExecutor = ListExecutor_Create(statementExecutor); + instructions = SlimList_Create(); + char const* import[] = {"i1", "import", "blah", 0}; + addStatementTo(instructions, import); + char const* make[] = {"m1", "make", "test_slim", "TestSlim", 0}; + addStatementTo(instructions, make); + } + + void teardown() + { + ListExecutor_Destroy(listExecutor); + SlimList_Destroy(instructions); + StatementExecutor_Destroy(statementExecutor); + } + + void addStatementTo(SlimList * instructions, char const** elements) + { + SlimList* statement = SlimList_Create(); + while (*elements) { - statementExecutor = StatementExecutor_Create(); - StatementExecutor_AddFixture(statementExecutor, TestSlim_Register); - listExecutor = ListExecutor_Create(statementExecutor); - instructions = SlimList_Create(); - char const * import[] = {"i1", "import", "blah", 0}; - addStatementTo(instructions, import); - char const * make[] = {"m1", "make", "test_slim", "TestSlim", 0}; - addStatementTo(instructions, make); - - } - - void teardown() - { - ListExecutor_Destroy(listExecutor); - SlimList_Destroy(instructions); - StatementExecutor_Destroy(statementExecutor); - } - - void addStatementTo(SlimList* instructions, char const** elements) - { - SlimList* statement = SlimList_Create(); - while (*elements) { - SlimList_AddString(statement, *elements++); - } - SlimList_AddList(instructions, statement); - SlimList_Destroy(statement); + SlimList_AddString(statement, *elements++); } + SlimList_AddList(instructions, statement); + SlimList_Destroy(statement); + } }; TEST(ListExecutor, ImportShouldReturnOk) { - SlimList * results = ListExecutor_Execute(listExecutor, instructions); - SlimList * importResult = SlimList_GetListAt(results, 0); + SlimList* results = ListExecutor_Execute(listExecutor, instructions); + SlimList* importResult = SlimList_GetListAt(results, 0); STRCMP_EQUAL("i1", SlimList_GetStringAt(importResult, 0)); STRCMP_EQUAL("OK", SlimList_GetStringAt(importResult, 1)); SlimList_Destroy(results); @@ -52,93 +52,94 @@ TEST(ListExecutor, ImportShouldReturnOk) TEST(ListExecutor, CannotExecuteAnInvalidOperation) { - char const * invalid[] = {"inv1", "Invalid", 0}; + char const* invalid[] = {"inv1", "Invalid", 0}; addStatementTo(instructions, invalid); - SlimList * results = ListExecutor_Execute(listExecutor, instructions); + SlimList* results = ListExecutor_Execute(listExecutor, instructions); LONGS_EQUAL(3, SlimList_GetLength(results)); - SlimList * invalidStatementResult = SlimList_GetListAt(results, 2); - - + SlimList* invalidStatementResult = SlimList_GetListAt(results, 2); + STRCMP_EQUAL("inv1", SlimList_GetStringAt(invalidStatementResult, 0)); - STRCMP_EQUAL("__EXCEPTION__:message:<>", SlimList_GetStringAt(invalidStatementResult, 1)); - SlimList_Destroy(results); + STRCMP_EQUAL("__EXCEPTION__:message:<>", + SlimList_GetStringAt(invalidStatementResult, 1)); + SlimList_Destroy(results); } TEST(ListExecutor, CanCallASimpleFunction) { - char const * call[] = {"call1", "call", "test_slim", "returnValue", 0}; + char const* call[] = {"call1", "call", "test_slim", "returnValue", 0}; addStatementTo(instructions, call); - - SlimList * results = ListExecutor_Execute(listExecutor, instructions); + SlimList* results = ListExecutor_Execute(listExecutor, instructions); LONGS_EQUAL(3, SlimList_GetLength(results)); - SlimList * makeResult = SlimList_GetListAt(results, 1); + SlimList* makeResult = SlimList_GetListAt(results, 1); STRCMP_EQUAL("m1", SlimList_GetStringAt(makeResult, 0)); STRCMP_EQUAL("OK", SlimList_GetStringAt(makeResult, 1)); - - SlimList * callResult = SlimList_GetListAt(results, 2); + + SlimList* callResult = SlimList_GetListAt(results, 2); STRCMP_EQUAL("call1", SlimList_GetStringAt(callResult, 0)); STRCMP_EQUAL("value", SlimList_GetStringAt(callResult, 1)); - - SlimList_Destroy(results); - + + SlimList_Destroy(results); } TEST(ListExecutor, CantExecuteMalformedInstruction) { - char const * call[] = {"call1", "call", "notEnoughArguments", 0}; - addStatementTo(instructions, call); - SlimList * results = ListExecutor_Execute(listExecutor, instructions); - SlimList * invalidStatementResult = SlimList_GetListAt(results, 2); - STRCMP_EQUAL("__EXCEPTION__:message:<>", SlimList_GetStringAt(invalidStatementResult, 1)); - SlimList_Destroy(results); + char const* call[] = {"call1", "call", "notEnoughArguments", 0}; + addStatementTo(instructions, call); + SlimList* results = ListExecutor_Execute(listExecutor, instructions); + SlimList* invalidStatementResult = SlimList_GetListAt(results, 2); + STRCMP_EQUAL("__EXCEPTION__:message:<>", + SlimList_GetStringAt(invalidStatementResult, 1)); + SlimList_Destroy(results); } TEST(ListExecutor, CantCallAmethodOnAnInstanceThatDoesntExist) { - char const * call[] = {"call1", "call", "noSuchInstance", "method", 0}; - addStatementTo(instructions, call); - SlimList * results = ListExecutor_Execute(listExecutor, instructions); - SlimList * invalidStatementResult = SlimList_GetListAt(results, 2); - STRCMP_EQUAL("__EXCEPTION__:message:<>", SlimList_GetStringAt(invalidStatementResult, 1)); + char const* call[] = {"call1", "call", "noSuchInstance", "method", 0}; + addStatementTo(instructions, call); + SlimList* results = ListExecutor_Execute(listExecutor, instructions); + SlimList* invalidStatementResult = SlimList_GetListAt(results, 2); + STRCMP_EQUAL("__EXCEPTION__:message:<>", + SlimList_GetStringAt(invalidStatementResult, 1)); SlimList_Destroy(results); } -TEST(ListExecutor, ShouldRespondToAnEmptySetOfInstructionsWithAnEmptySetOfResults) +TEST(ListExecutor, ShouldRespondToAnEmptySetOfInstructionsWithAnEmptySetOfResults) { SlimList* instructions = SlimList_Create(); - SlimList * results = ListExecutor_Execute(listExecutor, instructions); + SlimList* results = ListExecutor_Execute(listExecutor, instructions); LONGS_EQUAL(0, SlimList_GetLength(results)); SlimList_Destroy(results); SlimList_Destroy(instructions); } -TEST(ListExecutor, CanPassArgumentsToConstructor) -{ - char const * make2[] = {"make2", "make", "test_slim2", "TestSlim", "ConstructorArgument", 0}; - char const * call[] = {"call1", "call", "test_slim2", "getConstructionArg", 0}; +TEST(ListExecutor, CanPassArgumentsToConstructor) +{ + char const* make2[] = {"make2", "make", "test_slim2", "TestSlim", "ConstructorArgument", 0}; + char const* call[] = {"call1", "call", "test_slim2", "getConstructionArg", 0}; addStatementTo(instructions, make2); - addStatementTo(instructions, call); - SlimList * results = ListExecutor_Execute(listExecutor, instructions); - SlimList * callResult = SlimList_GetListAt(results, 3); + addStatementTo(instructions, call); + SlimList* results = ListExecutor_Execute(listExecutor, instructions); + SlimList* callResult = SlimList_GetListAt(results, 3); STRCMP_EQUAL("ConstructorArgument", SlimList_GetStringAt(callResult, 1)); SlimList_Destroy(results); } TEST(ListExecutor, CanCallAFunctionMoreThanOnce) { - char const * call[] = {"call1", "call", "test_slim", "echo", "Hello", 0}; - addStatementTo(instructions, call); - char const * call2[] = {"call2", "call", "test_slim", "echo", "Goodbye", 0}; - addStatementTo(instructions, call2); - - SlimList * results = ListExecutor_Execute(listExecutor, instructions); - - SlimList * callResult = SlimList_GetListAt(results, 2); + char const* call[] = {"call1", "call", "test_slim", "echo", "Hello", 0}; + addStatementTo(instructions, call); + char const* call2[] = {"call2", "call", "test_slim", "echo", "Goodbye", 0}; + addStatementTo(instructions, call2); + + SlimList* results = ListExecutor_Execute(listExecutor, instructions); + + SlimList* callResult = SlimList_GetListAt(results, 2); STRCMP_EQUAL("Hello", SlimList_GetStringAt(callResult, 1)); - callResult = SlimList_GetListAt(results, 3); + callResult = SlimList_GetListAt(results, 3); STRCMP_EQUAL("Goodbye", SlimList_GetStringAt(callResult, 1)); SlimList_Destroy(results); @@ -146,17 +147,17 @@ TEST(ListExecutor, CanCallAFunctionMoreThanOnce) TEST(ListExecutor, CanAssignTheReturnValueToASymbol) { - char const * call[] = {"id1", "callAndAssign", "v", "test_slim", "add", "x", "y", 0}; - addStatementTo(instructions, call); + char const* call[] = {"id1", "callAndAssign", "v", "test_slim", "add", "x", "y", 0}; + addStatementTo(instructions, call); - char const * call2[] = {"id2", "call", "test_slim", "echo", "$v", 0}; - addStatementTo(instructions, call2); + char const* call2[] = {"id2", "call", "test_slim", "echo", "$v", 0}; + addStatementTo(instructions, call2); - SlimList * results = ListExecutor_Execute(listExecutor, instructions); + SlimList* results = ListExecutor_Execute(listExecutor, instructions); - SlimList * callResult = SlimList_GetListAt(results, 2); + SlimList* callResult = SlimList_GetListAt(results, 2); STRCMP_EQUAL("xy", SlimList_GetStringAt(callResult, 1)); - callResult = SlimList_GetListAt(results, 3); + callResult = SlimList_GetListAt(results, 3); STRCMP_EQUAL("xy", SlimList_GetStringAt(callResult, 1)); SlimList_Destroy(results); @@ -164,18 +165,18 @@ TEST(ListExecutor, CanAssignTheReturnValueToASymbol) TEST(ListExecutor, CanReplateMultipleSymbolsInASingleArgument) { - char const * call[] = {"id1", "callAndAssign", "v1", "test_slim", "echo", "Bob", 0}; - addStatementTo(instructions, call); - - char const * call2[] = {"id2", "callAndAssign", "v2", "test_slim", "echo", "Martin", 0}; - addStatementTo(instructions, call2); - - char const * call3[] = {"id2", "call", "test_slim", "echo", "name: $v1 $v2 $12.23", 0}; - addStatementTo(instructions, call3); - - SlimList * results = ListExecutor_Execute(listExecutor, instructions); - - SlimList * callResult = SlimList_GetListAt(results, 4); + char const* call[] = {"id1", "callAndAssign", "v1", "test_slim", "echo", "Bob", 0}; + addStatementTo(instructions, call); + + char const* call2[] = {"id2", "callAndAssign", "v2", "test_slim", "echo", "Martin", 0}; + addStatementTo(instructions, call2); + + char const* call3[] = {"id2", "call", "test_slim", "echo", "name: $v1 $v2 $12.23", 0}; + addStatementTo(instructions, call3); + + SlimList* results = ListExecutor_Execute(listExecutor, instructions); + + SlimList* callResult = SlimList_GetListAt(results, 4); STRCMP_EQUAL("name: Bob Martin $12.23", SlimList_GetStringAt(callResult, 1)); SlimList_Destroy(results); @@ -186,46 +187,46 @@ TEST(ListExecutor, CanPassAndReturnAList) SlimList* l = SlimList_Create(); SlimList_AddString(l, "1"); SlimList_AddString(l, "2"); - + SlimList* statement = SlimList_Create(); SlimList_AddString(statement, "id1"); SlimList_AddString(statement, "call"); SlimList_AddString(statement, "test_slim"); SlimList_AddString(statement, "echo"); SlimList_AddList(statement, l); - + SlimList_AddList(instructions, statement); SlimList_Destroy(statement); - - SlimList * results = ListExecutor_Execute(listExecutor, instructions); - SlimList * callResult = SlimList_GetListAt(results, 2); - SlimList * resultList = SlimList_GetListAt(callResult, 1); + SlimList* results = ListExecutor_Execute(listExecutor, instructions); + + SlimList* callResult = SlimList_GetListAt(results, 2); + SlimList* resultList = SlimList_GetListAt(callResult, 1); CHECK(SlimList_Equals(l, resultList)); SlimList_Destroy(results); - SlimList_Destroy(l); + SlimList_Destroy(l); } TEST(ListExecutor, CanReturnNull) { - char const * call[] = {"id1", "call", "test_slim", "null", 0}; + char const* call[] = {"id1", "call", "test_slim", "null", 0}; addStatementTo(instructions, call); - - SlimList * results = ListExecutor_Execute(listExecutor, instructions); - SlimList * callResult = SlimList_GetListAt(results, 2); - + SlimList* results = ListExecutor_Execute(listExecutor, instructions); + + SlimList* callResult = SlimList_GetListAt(results, 2); + STRCMP_EQUAL("null", SlimList_GetStringAt(callResult, 1)); - - SlimList_Destroy(results); + + SlimList_Destroy(results); } TEST(ListExecutor, CanPassASymbolInAList) { - char const * call[] = {"id1", "callAndAssign", "v", "test_slim", "echo", "Bob", 0}; - addStatementTo(instructions, call); - + char const* call[] = {"id1", "callAndAssign", "v", "test_slim", "echo", "Bob", 0}; + addStatementTo(instructions, call); + SlimList* statement = SlimList_Create(); SlimList_AddString(statement, "id2"); SlimList_AddString(statement, "call"); @@ -235,14 +236,14 @@ TEST(ListExecutor, CanPassASymbolInAList) SlimList* l = SlimList_Create(); SlimList_AddString(l, "$v"); SlimList_AddList(statement, l); - + SlimList_AddList(instructions, statement); SlimList_Destroy(statement); - - SlimList * results = ListExecutor_Execute(listExecutor, instructions); - SlimList * callResult = SlimList_GetListAt(results, 3); - SlimList * resultList = SlimList_GetListAt(callResult, 1); + SlimList* results = ListExecutor_Execute(listExecutor, instructions); + + SlimList* callResult = SlimList_GetListAt(results, 3); + SlimList* resultList = SlimList_GetListAt(callResult, 1); SlimList* expected = SlimList_Create(); SlimList_AddString(expected, "Bob"); @@ -250,7 +251,6 @@ TEST(ListExecutor, CanPassASymbolInAList) CHECK(SlimList_Equals(expected, resultList)); SlimList_Destroy(results); - SlimList_Destroy(l); + SlimList_Destroy(l); SlimList_Destroy(expected); - } diff --git a/tests/CSlim/SlimConnectionHandlerTest.cpp b/tests/CSlim/SlimConnectionHandlerTest.cpp index 7b5421c..7459901 100644 --- a/tests/CSlim/SlimConnectionHandlerTest.cpp +++ b/tests/CSlim/SlimConnectionHandlerTest.cpp @@ -1,100 +1,106 @@ #include "CppUTest/TestHarness.h" -#include "SlimList.h" #include "SlimConnectionHandler.h" +#include "SlimList.h" -#include -#include -#include -#include #include "compatibility.h" +#include +#include +#include +#include -extern "C" +extern "C" { +#include "CppUTest/TestHarness_c.h" + +struct MockComLink +{ + char lastSendMsg[32]; + int lastSendIndex; + char const* recvStream; + char const* recvPtr; + SlimList* sendReturnCodes; +}; +int mock_send_func(void* voidSelf, const char* msg, int length) { - #include "CppUTest/TestHarness_c.h" - - struct MockComLink { - char lastSendMsg[32]; - int lastSendIndex; - char const * recvStream; - char const * recvPtr; - SlimList* sendReturnCodes; - }; - int mock_send_func(void * voidSelf, const char * msg, int length) + MockComLink* self = (MockComLink*)voidSelf; + strncpy(self->lastSendMsg + self->lastSendIndex, msg, length); + self->lastSendIndex += length; + + int result = length; + + if (SlimList_GetLength(self->sendReturnCodes) > 0) { - MockComLink * self = (MockComLink*)voidSelf; - strncpy(self->lastSendMsg + self->lastSendIndex, msg, length); - self->lastSendIndex += length; + const char* resultAsAString = SlimList_GetStringAt(self->sendReturnCodes, 0); + result = atoi(resultAsAString); - int result = length; + SlimList_PopHead(self->sendReturnCodes); + } - if (SlimList_GetLength(self->sendReturnCodes) > 0) - { - const char* resultAsAString = SlimList_GetStringAt(self->sendReturnCodes, 0); - result = atoi(resultAsAString); + return result; +} - SlimList_PopHead(self->sendReturnCodes); - } +int mock_recv_func(void* voidSelf, char* buffer, int length) +{ + MockComLink* self = (MockComLink*)voidSelf; + assert(self->recvPtr != NULL); - return result; - } + int result = length; + strncpy(buffer, self->recvPtr, length); + if (strlen(self->recvPtr) < result) + result = strlen(self->recvPtr); - int mock_recv_func(void * voidSelf, char * buffer, int length) - { - MockComLink * self = (MockComLink*)voidSelf; - assert(self->recvPtr != NULL); + self->recvPtr += result; - int result = length; - strncpy(buffer, self->recvPtr, length); - if (strlen(self->recvPtr) < result) - result = strlen(self->recvPtr); + if (result == 0) + result = -1; - self->recvPtr += result; + return result; +} - if (result == 0) result = -1; +char sentSlimMessage[32]; +void* sentMsgHandler; +char* mock_handle_slim_message(void* self, char* message) +{ + strcpy(sentSlimMessage, message); + sentMsgHandler = self; - return result; - } + static char* slimResponse = NULL; + slimResponse = (char*)malloc(8 * sizeof(char)); + strcpy(slimResponse, "ghijklm"); + return slimResponse; +} - char * slimResponse; - char sentSlimMessage[32]; - void * sentMsgHandler; - char * mock_handle_slim_message(void* self, char * message) +void AddSendResult(MockComLink* self, int result) +{ + char string[22]; + sprintf(string, "%d", result); + SlimList_AddString(self->sendReturnCodes, string); +} +} + +TEST_GROUP(SlimConnectionHandler) +{ + SlimConnectionHandler* slimConnectionHandler; + MockComLink comLink; + void* mockMessageHandler; + void setup() { - strcpy(sentSlimMessage, message); - sentMsgHandler = self; - return slimResponse; + slimConnectionHandler = + SlimConnectionHandler_Create(&mock_send_func, &mock_recv_func, (void*)&comLink); + memset(comLink.lastSendMsg, 0, 32); + comLink.lastSendIndex = 0; + mockMessageHandler = (void*)0x123456; + + comLink.sendReturnCodes = SlimList_Create(); + SlimConnectionHandler_RegisterSlimMessageHandler(slimConnectionHandler, mockMessageHandler, + &mock_handle_slim_message); } - void AddSendResult(MockComLink * self, int result) + void teardown() { - char string[22]; - sprintf(string, "%d", result); - SlimList_AddString(self->sendReturnCodes, string); + SlimConnectionHandler_Destroy(slimConnectionHandler); + SlimList_Destroy(comLink.sendReturnCodes); } -} - -TEST_GROUP(SlimConnectionHandler) -{ - SlimConnectionHandler* slimConnectionHandler; - MockComLink comLink; - void* mockMessageHandler; - void setup() - { - slimConnectionHandler = SlimConnectionHandler_Create(&mock_send_func, &mock_recv_func, (void*)&comLink); - memset(comLink.lastSendMsg, 0, 32); - comLink.lastSendIndex = 0; - mockMessageHandler = (void*)0x123456; - - comLink.sendReturnCodes = SlimList_Create(); - SlimConnectionHandler_RegisterSlimMessageHandler(slimConnectionHandler, mockMessageHandler, &mock_handle_slim_message); - } - - void teardown() - { - SlimConnectionHandler_Destroy(slimConnectionHandler); - SlimList_Destroy(comLink.sendReturnCodes); - } }; TEST(SlimConnectionHandler, ShouldSendVersion) @@ -112,9 +118,6 @@ TEST(SlimConnectionHandler, ShouldReadMessageAndCallSlimHandler) comLink.recvStream = "000006:abcdef000003:bye"; comLink.recvPtr = comLink.recvStream; - slimResponse = (char*)cpputest_malloc(8); - strcpy(slimResponse, "ghijklm"); - SlimConnectionHandler_Run(slimConnectionHandler); STRCMP_EQUAL("Slim -- V0.2\n000007:ghijklm", comLink.lastSendMsg); @@ -124,21 +127,20 @@ TEST(SlimConnectionHandler, ShouldReadMessageAndCallSlimHandler) TEST(SlimConnectionHandler, CanMockSendResultsAsPartOfTest) { - int expected = 1; - AddSendResult(&comLink, expected); - char message[] = ""; + int expected = 1; + AddSendResult(&comLink, expected); + char message[] = ""; - int actual = mock_send_func(&comLink, message, 0); - CHECK_EQUAL(expected, actual); + int actual = mock_send_func(&comLink, message, 0); + CHECK_EQUAL(expected, actual); } TEST(SlimConnectionHandler, HandlesSendErrorWithoutMemoryLeak) { - char message[] = ""; - comLink.recvStream = message; - comLink.recvPtr = comLink.recvStream; + char message[] = ""; + comLink.recvStream = message; + comLink.recvPtr = comLink.recvStream; - AddSendResult(&comLink, -1); - SlimConnectionHandler_Run(slimConnectionHandler); + AddSendResult(&comLink, -1); + SlimConnectionHandler_Run(slimConnectionHandler); } - diff --git a/tests/CSlim/SlimListDeserializerTest.cpp b/tests/CSlim/SlimListDeserializerTest.cpp index 5307283..ab75602 100644 --- a/tests/CSlim/SlimListDeserializerTest.cpp +++ b/tests/CSlim/SlimListDeserializerTest.cpp @@ -1,6 +1,6 @@ +#include #include #include -#include #include "SlimList.h" #include "SlimListDeserializer.h" @@ -11,80 +11,79 @@ TEST_GROUP(SlimListDeserializer) { - SlimList* slimList; - SlimList* deserializedList; - char* serializedList; - - void setup() - { - slimList = SlimList_Create(); - serializedList = 0; - deserializedList = 0; - } - - void teardown() - { - SlimList_Destroy(slimList); - - if (deserializedList) - SlimList_Destroy(deserializedList); - - if (serializedList != 0) - SlimList_Release(serializedList); - } - - void check_lists_equal(SlimList* expected, SlimList* actual) { - CHECK(SlimList_Equals(expected, actual)); - } - + SlimList* slimList; + SlimList* deserializedList; + char* serializedList; + + void setup() + { + slimList = SlimList_Create(); + serializedList = 0; + deserializedList = 0; + } + + void teardown() + { + SlimList_Destroy(slimList); + + if (deserializedList) + SlimList_Destroy(deserializedList); + + if (serializedList != 0) + SlimList_Release(serializedList); + } + + void check_lists_equal(SlimList * expected, SlimList * actual) + { + CHECK(SlimList_Equals(expected, actual)); + } }; - TEST(SlimListDeserializer, deserializeEmptyList) { - deserializedList = SlimList_Deserialize("[000000:]"); - CHECK(deserializedList != 0); - LONGS_EQUAL(0, SlimList_GetLength(deserializedList)); + deserializedList = SlimList_Deserialize("[000000:]"); + CHECK(deserializedList != 0); + LONGS_EQUAL(0, SlimList_GetLength(deserializedList)); } TEST(SlimListDeserializer, deserializeNull) { - SlimList* list = SlimList_Deserialize(0); - POINTERS_EQUAL(0, list); + SlimList* list = SlimList_Deserialize(0); + POINTERS_EQUAL(0, list); } TEST(SlimListDeserializer, deserializeEmptyString) { - SlimList* list = SlimList_Deserialize(""); - POINTERS_EQUAL(0, list); + SlimList* list = SlimList_Deserialize(""); + POINTERS_EQUAL(0, list); } TEST(SlimListDeserializer, MissingOpenBracketReturnsNull) { - SlimList* list = SlimList_Deserialize("hello"); - POINTERS_EQUAL(0, list); + SlimList* list = SlimList_Deserialize("hello"); + POINTERS_EQUAL(0, list); } TEST(SlimListDeserializer, MissingClosingBracketReturnsNull) { - SlimList* list = SlimList_Deserialize("[000000:"); - POINTERS_EQUAL(0, list); + SlimList* list = SlimList_Deserialize("[000000:"); + POINTERS_EQUAL(0, list); } TEST(SlimListDeserializer, canDeserializeCanonicalListWithOneElement) { - char const* canonicalList = "[000001:000008:Hi doug.:]"; - SlimList* deserializedList = SlimList_Deserialize(canonicalList); - CHECK(deserializedList != NULL); - LONGS_EQUAL(1, SlimList_GetLength(deserializedList)); - STRCMP_EQUAL("Hi doug.", SlimList_GetStringAt(deserializedList, 0)); - SlimList_Destroy(deserializedList); + char const* canonicalList = "[000001:000008:Hi doug.:]"; + SlimList* deserializedList = SlimList_Deserialize(canonicalList); + CHECK(deserializedList != NULL); + LONGS_EQUAL(1, SlimList_GetLength(deserializedList)); + STRCMP_EQUAL("Hi doug.", SlimList_GetStringAt(deserializedList, 0)); + SlimList_Destroy(deserializedList); } TEST(SlimListDeserializer, canDeserializeWithMultibyteCharacters) { char const* canonicalList = "[000001:000008:Hi JRÜ€©:]"; - SlimList* deserializedList = SlimList_Deserialize(canonicalList); + SlimList* deserializedList = SlimList_Deserialize(canonicalList); CHECK(deserializedList != NULL); LONGS_EQUAL(1, SlimList_GetLength(deserializedList)); STRCMP_EQUAL("Hi JRÜ€©", SlimList_GetStringAt(deserializedList, 0)); @@ -93,50 +92,50 @@ TEST(SlimListDeserializer, canDeserializeWithMultibyteCharacters) TEST(SlimListDeserializer, canDeSerializeListWithOneElement) { - SlimList_AddString(slimList, "hello"); - serializedList = SlimList_Serialize(slimList); - deserializedList = SlimList_Deserialize(serializedList); - CHECK(deserializedList != 0); - check_lists_equal(slimList, deserializedList); + SlimList_AddString(slimList, "hello"); + serializedList = SlimList_Serialize(slimList); + deserializedList = SlimList_Deserialize(serializedList); + CHECK(deserializedList != 0); + check_lists_equal(slimList, deserializedList); } TEST(SlimListDeserializer, canDeSerializeListWithTwoElements) { - SlimList_AddString(slimList, "hello"); - SlimList_AddString(slimList, "bob"); - serializedList = SlimList_Serialize(slimList); - deserializedList = SlimList_Deserialize(serializedList); - CHECK(deserializedList != 0); - check_lists_equal(slimList, deserializedList); + SlimList_AddString(slimList, "hello"); + SlimList_AddString(slimList, "bob"); + serializedList = SlimList_Serialize(slimList); + deserializedList = SlimList_Deserialize(serializedList); + CHECK(deserializedList != 0); + check_lists_equal(slimList, deserializedList); } TEST(SlimListDeserializer, canAddSubList) { - SlimList* embeddedList; - embeddedList = SlimList_Create(); - SlimList_AddString(embeddedList, "element"); - SlimList_AddList(slimList, embeddedList); - serializedList = SlimList_Serialize(slimList); - deserializedList = SlimList_Deserialize(serializedList); - SlimList * subList = SlimList_GetListAt(deserializedList, 0); - subList = SlimList_GetListAt(deserializedList, 0); - check_lists_equal(embeddedList, subList); - - SlimList_Destroy(embeddedList); + SlimList* embeddedList; + embeddedList = SlimList_Create(); + SlimList_AddString(embeddedList, "element"); + SlimList_AddList(slimList, embeddedList); + serializedList = SlimList_Serialize(slimList); + deserializedList = SlimList_Deserialize(serializedList); + SlimList* subList = SlimList_GetListAt(deserializedList, 0); + subList = SlimList_GetListAt(deserializedList, 0); + check_lists_equal(embeddedList, subList); + + SlimList_Destroy(embeddedList); } TEST(SlimListDeserializer, getStringWhereThereIsAList) { - SlimList* embeddedList; - embeddedList = SlimList_Create(); - SlimList_AddString(embeddedList, "element"); - SlimList_AddList(slimList, embeddedList); - serializedList = SlimList_Serialize(slimList); - deserializedList = SlimList_Deserialize(serializedList); - const char * string = SlimList_GetStringAt(deserializedList, 0); - - STRCMP_EQUAL("[000001:000007:element:]", string); - // POINTERS_EQUAL(0, string); ????????????????????????????????????? - - SlimList_Destroy(embeddedList); + SlimList* embeddedList; + embeddedList = SlimList_Create(); + SlimList_AddString(embeddedList, "element"); + SlimList_AddList(slimList, embeddedList); + serializedList = SlimList_Serialize(slimList); + deserializedList = SlimList_Deserialize(serializedList); + const char* string = SlimList_GetStringAt(deserializedList, 0); + + STRCMP_EQUAL("[000001:000007:element:]", string); + // POINTERS_EQUAL(0, string); ????????????????????????????????????? + + SlimList_Destroy(embeddedList); } diff --git a/tests/CSlim/SlimListSerializerTest.cpp b/tests/CSlim/SlimListSerializerTest.cpp index a3b67eb..c2ac51c 100644 --- a/tests/CSlim/SlimListSerializerTest.cpp +++ b/tests/CSlim/SlimListSerializerTest.cpp @@ -1,6 +1,6 @@ +#include #include #include -#include #include "SlimList.h" #include "SlimListSerializer.h" @@ -11,11 +11,11 @@ TEST_GROUP(SlimListSerializer) { SlimList* slimList; - char* serializedList; + char* serializedList; void setup() { - slimList = SlimList_Create(); + slimList = SlimList_Create(); serializedList = 0; } @@ -29,84 +29,83 @@ TEST_GROUP(SlimListSerializer) TEST(SlimListSerializer, SerializeAListWithNoElements) { - serializedList = SlimList_Serialize(slimList); - STRCMP_EQUAL("[000000:]", serializedList); + serializedList = SlimList_Serialize(slimList); + STRCMP_EQUAL("[000000:]", serializedList); } TEST(SlimListSerializer, SerializeAListWithOneElements) { - SlimList_AddString(slimList, "hello"); - serializedList = SlimList_Serialize(slimList); - STRCMP_EQUAL("[000001:000005:hello:]", serializedList); + SlimList_AddString(slimList, "hello"); + serializedList = SlimList_Serialize(slimList); + STRCMP_EQUAL("[000001:000005:hello:]", serializedList); } TEST(SlimListSerializer, SerializeAListWithTwoElements) { - SlimList_AddString(slimList, "hello"); - SlimList_AddString(slimList, "world"); + SlimList_AddString(slimList, "hello"); + SlimList_AddString(slimList, "world"); - serializedList = SlimList_Serialize(slimList); + serializedList = SlimList_Serialize(slimList); - STRCMP_EQUAL("[000002:000005:hello:000005:world:]", serializedList); + STRCMP_EQUAL("[000002:000005:hello:000005:world:]", serializedList); } TEST(SlimListSerializer, ListCopysItsString) { - char string[12] = "Hello"; - SlimList_AddString(slimList, string); - strcpy(string, "Goodbye"); - serializedList = SlimList_Serialize(slimList); - STRCMP_EQUAL("[000001:000005:Hello:]", serializedList); + char string[12] = "Hello"; + SlimList_AddString(slimList, string); + strcpy(string, "Goodbye"); + serializedList = SlimList_Serialize(slimList); + STRCMP_EQUAL("[000001:000005:Hello:]", serializedList); } TEST(SlimListSerializer, canCopyAList) { - SlimList_AddString(slimList, "123456"); - SlimList_AddString(slimList, "987654"); - - SlimList* copy = SlimList_Create(); - int i; - for (i=0; i #include #include -#include #include "SlimList.h" #include "SlimUtil.h" @@ -10,128 +10,127 @@ TEST_GROUP(SlimList) { - SlimList* slimList; - SlimList* deserializedList; - char* serializedList; - - void setup() - { - slimList = SlimList_Create(); - serializedList = 0; - deserializedList = 0; - } - - void teardown() - { - SlimList_Destroy(slimList); - - if (deserializedList) - SlimList_Destroy(deserializedList); - - if (serializedList != 0) - cpputest_free(serializedList); - } - - void check_lists_equal(SlimList* expected, SlimList* actual) { - CHECK(SlimList_Equals(expected, actual)); - } - + SlimList* slimList; + SlimList* deserializedList; + char* serializedList; + + void setup() + { + slimList = SlimList_Create(); + serializedList = 0; + deserializedList = 0; + } + + void teardown() + { + SlimList_Destroy(slimList); + + if (deserializedList) + SlimList_Destroy(deserializedList); + + if (serializedList != 0) + cpputest_free(serializedList); + } + + void check_lists_equal(SlimList * expected, SlimList * actual) + { + CHECK(SlimList_Equals(expected, actual)); + } }; TEST(SlimList, twoEmptyListsAreEqual) { - SlimList* list = SlimList_Create(); - check_lists_equal(slimList, list); - SlimList_Destroy(list); + SlimList* list = SlimList_Create(); + check_lists_equal(slimList, list); + SlimList_Destroy(list); } TEST(SlimList, twoDifferentLenghtListsAreNotEqual) { - SlimList* list = SlimList_Create(); - SlimList_AddString(slimList, "hello"); - CHECK(!SlimList_Equals(slimList, list)); - SlimList_Destroy(list); + SlimList* list = SlimList_Create(); + SlimList_AddString(slimList, "hello"); + CHECK(!SlimList_Equals(slimList, list)); + SlimList_Destroy(list); } TEST(SlimList, twoSingleElementListsWithDifferentElmementsAreNotEqual) { - SlimList* list = SlimList_Create(); - SlimList_AddString(slimList, "hello"); - SlimList_AddString(list, "goodbye"); - CHECK(!SlimList_Equals(slimList, list)); - SlimList_Destroy(list); + SlimList* list = SlimList_Create(); + SlimList_AddString(slimList, "hello"); + SlimList_AddString(list, "goodbye"); + CHECK(!SlimList_Equals(slimList, list)); + SlimList_Destroy(list); } - TEST(SlimList, twoIdenticalMultipleElementListsElmementsAreEqual) { - SlimList* list = SlimList_Create(); - SlimList_AddString(slimList, "hello"); - SlimList_AddString(slimList, "goodbye"); - SlimList_AddString(list, "hello"); - SlimList_AddString(list, "goodbye"); - CHECK(SlimList_Equals(slimList, list)); - SlimList_Destroy(list); + SlimList* list = SlimList_Create(); + SlimList_AddString(slimList, "hello"); + SlimList_AddString(slimList, "goodbye"); + SlimList_AddString(list, "hello"); + SlimList_AddString(list, "goodbye"); + CHECK(SlimList_Equals(slimList, list)); + SlimList_Destroy(list); } - TEST(SlimList, twoNonIdenticalMultipleElementListsElmementsAreNotEqual) { - SlimList* list = SlimList_Create(); - SlimList_AddString(slimList, "hello"); - SlimList_AddString(slimList, "hello"); - SlimList_AddString(list, "hello"); - SlimList_AddString(list, "goodbye"); - CHECK(!SlimList_Equals(slimList, list)); - SlimList_Destroy(list); + SlimList* list = SlimList_Create(); + SlimList_AddString(slimList, "hello"); + SlimList_AddString(slimList, "hello"); + SlimList_AddString(list, "hello"); + SlimList_AddString(list, "goodbye"); + CHECK(!SlimList_Equals(slimList, list)); + SlimList_Destroy(list); } - TEST(SlimList, canGetElements) { - SlimList_AddString(slimList, "element1"); - SlimList_AddString(slimList, "element2"); - STRCMP_EQUAL("element1", SlimList_GetStringAt(slimList, 0)); - STRCMP_EQUAL("element2", SlimList_GetStringAt(slimList, 1)); + SlimList_AddString(slimList, "element1"); + SlimList_AddString(slimList, "element2"); + STRCMP_EQUAL("element1", SlimList_GetStringAt(slimList, 0)); + STRCMP_EQUAL("element2", SlimList_GetStringAt(slimList, 1)); } TEST(SlimList, canGetHashWithOneElement) { - SlimList_AddString(slimList, "
namebob
"); + SlimList_AddString(slimList, "
namebob
"); - SlimList * hash = SlimList_GetHashAt(slimList, 0); - SlimList * twoElementList = SlimList_GetListAt(hash, 0); + SlimList* hash = SlimList_GetHashAt(slimList, 0); + SlimList* twoElementList = SlimList_GetListAt(hash, 0); - STRCMP_EQUAL("name", SlimList_GetStringAt(twoElementList, 0)); - STRCMP_EQUAL("bob", SlimList_GetStringAt(twoElementList, 1)); - SlimList_Destroy(hash); + STRCMP_EQUAL("name", SlimList_GetStringAt(twoElementList, 0)); + STRCMP_EQUAL("bob", SlimList_GetStringAt(twoElementList, 1)); + SlimList_Destroy(hash); } TEST(SlimList, canGetHashWithMultipleElements) { - SlimList_AddString(slimList, "
namedough
addrhere
"); + SlimList_AddString( + slimList, + "
namedough
addrhere
"); - SlimList * hash = SlimList_GetHashAt(slimList, 0); - SlimList * twoElementList = SlimList_GetListAt(hash,1); + SlimList* hash = SlimList_GetHashAt(slimList, 0); + SlimList* twoElementList = SlimList_GetListAt(hash, 1); - STRCMP_EQUAL("addr", SlimList_GetStringAt(twoElementList, 0)); - STRCMP_EQUAL("here", SlimList_GetStringAt(twoElementList, 1)); - SlimList_Destroy(hash); + STRCMP_EQUAL("addr", SlimList_GetStringAt(twoElementList, 0)); + STRCMP_EQUAL("here", SlimList_GetStringAt(twoElementList, 1)); + SlimList_Destroy(hash); } TEST(SlimList, cannotGetElementThatAreNotThere) { - SlimList_AddString(slimList, "element1"); - SlimList_AddString(slimList, "element2"); - POINTERS_EQUAL(0, SlimList_GetStringAt(slimList, 3)); + SlimList_AddString(slimList, "element1"); + SlimList_AddString(slimList, "element2"); + POINTERS_EQUAL(0, SlimList_GetStringAt(slimList, 3)); } TEST(SlimList, canReplaceString) { - SlimList_AddString(slimList, "replaceMe"); - SlimList_ReplaceAt(slimList, 0, "WithMe"); + SlimList_AddString(slimList, "replaceMe"); + SlimList_ReplaceAt(slimList, 0, "WithMe"); - STRCMP_EQUAL("WithMe", SlimList_GetStringAt(slimList, 0)); + STRCMP_EQUAL("WithMe", SlimList_GetStringAt(slimList, 0)); } TEST(SlimList, canGetTail) @@ -159,119 +158,117 @@ TEST(SlimList, getDouble) TEST(SlimList, ToStringForEmptyList) { - const char* listAsAString = SlimList_ToString(slimList); - STRCMP_EQUAL("[]", listAsAString); - CSlim_DestroyString(listAsAString); + const char* listAsAString = SlimList_ToString(slimList); + STRCMP_EQUAL("[]", listAsAString); + CSlim_DestroyString(listAsAString); } TEST(SlimList, toStringForSimpleList) { - SlimList_AddString(slimList, "a"); - SlimList_AddString(slimList, "b"); - const char* stringVersionOfList = SlimList_ToString(slimList); + SlimList_AddString(slimList, "a"); + SlimList_AddString(slimList, "b"); + const char* stringVersionOfList = SlimList_ToString(slimList); - STRCMP_EQUAL("[\"a\", \"b\"]", stringVersionOfList); + STRCMP_EQUAL("[\"a\", \"b\"]", stringVersionOfList); - CSlim_DestroyString(stringVersionOfList); + CSlim_DestroyString(stringVersionOfList); } TEST(SlimList, toStringDoesNotHaveASideEffectWhichChangesResultsFromPriorCalls) { - const char* priorString = SlimList_ToString(slimList); + const char* priorString = SlimList_ToString(slimList); - SlimList_AddString(slimList, "a"); - const char* listWithAnElementAsASting = SlimList_ToString(slimList); + SlimList_AddString(slimList, "a"); + const char* listWithAnElementAsASting = SlimList_ToString(slimList); - int areStringsTheSame = (strcmp(priorString, listWithAnElementAsASting) == 0); - CHECK_FALSE(areStringsTheSame); + int areStringsTheSame = (strcmp(priorString, listWithAnElementAsASting) == 0); + CHECK_FALSE(areStringsTheSame); - CSlim_DestroyString(priorString); - CSlim_DestroyString(listWithAnElementAsASting); + CSlim_DestroyString(priorString); + CSlim_DestroyString(listWithAnElementAsASting); } TEST(SlimList, recursiveToString) { - SlimList_AddString(slimList, "a"); - SlimList_AddString(slimList, "b"); + SlimList_AddString(slimList, "a"); + SlimList_AddString(slimList, "b"); - SlimList* sublist = SlimList_Create(); - SlimList_AddString(sublist, "3"); - SlimList_AddString(sublist, "4"); + SlimList* sublist = SlimList_Create(); + SlimList_AddString(sublist, "3"); + SlimList_AddString(sublist, "4"); - SlimList_AddList(slimList, sublist); + SlimList_AddList(slimList, sublist); - const char* listAsAString = SlimList_ToString(slimList); - STRCMP_EQUAL("[\"a\", \"b\", [\"3\", \"4\"]]", listAsAString); - CSlim_DestroyString(listAsAString); + const char* listAsAString = SlimList_ToString(slimList); + STRCMP_EQUAL("[\"a\", \"b\", [\"3\", \"4\"]]", listAsAString); + CSlim_DestroyString(listAsAString); - SlimList_Destroy(sublist); + SlimList_Destroy(sublist); } TEST(SlimList, toStringForLongList) { - const int entries = 128; //TODO: consider updating the size given its no longer as relevant - int i; + const int entries = 128; //TODO: consider updating the size given its no longer as relevant + int i; - for (i = 0; i < entries; i++) - { - SlimList_AddString(slimList, "a"); - } + for (i = 0; i < entries; i++) + { + SlimList_AddString(slimList, "a"); + } - const char* listAsAString = SlimList_ToString(slimList); - CSlim_DestroyString(listAsAString); + const char* listAsAString = SlimList_ToString(slimList); + CSlim_DestroyString(listAsAString); } TEST(SlimList, CanPopHeadOnListWithOneEntry) { - SlimList_AddString(slimList, "a"); - SlimList_PopHead(slimList); - CHECK_EQUAL(0, SlimList_GetLength(slimList)); + SlimList_AddString(slimList, "a"); + SlimList_PopHead(slimList); + CHECK_EQUAL(0, SlimList_GetLength(slimList)); } TEST(SlimList, CanInsertAfterPoppingListWithEntries) { - SlimList_AddString(slimList, "a"); - SlimList_AddString(slimList, "a"); + SlimList_AddString(slimList, "a"); + SlimList_AddString(slimList, "a"); - SlimList_PopHead(slimList); - SlimList_PopHead(slimList); + SlimList_PopHead(slimList); + SlimList_PopHead(slimList); - SlimList_AddString(slimList, "a"); - SlimList_AddString(slimList, "a"); - CHECK_EQUAL(2, SlimList_GetLength(slimList)); + SlimList_AddString(slimList, "a"); + SlimList_AddString(slimList, "a"); + CHECK_EQUAL(2, SlimList_GetLength(slimList)); } TEST(SlimList, iteratorDoesNotHaveAnItemWhenEmpty) { - SlimListIterator* iterator = SlimList_CreateIterator(slimList); - CHECK_FALSE(SlimList_Iterator_HasItem(iterator)); + SlimListIterator* iterator = SlimList_CreateIterator(slimList); + CHECK_FALSE(SlimList_Iterator_HasItem(iterator)); } TEST(SlimList, iteratorHasItem) { - SlimList_AddString(slimList, "a"); - SlimListIterator* iterator = SlimList_CreateIterator(slimList); + SlimList_AddString(slimList, "a"); + SlimListIterator* iterator = SlimList_CreateIterator(slimList); - CHECK_TRUE(SlimList_Iterator_HasItem(iterator)); + CHECK_TRUE(SlimList_Iterator_HasItem(iterator)); } TEST(SlimList, iteratorNext) { - SlimList_AddString(slimList, "a"); - SlimListIterator* iterator = SlimList_CreateIterator(slimList); - SlimList_Iterator_Advance(&iterator); + SlimList_AddString(slimList, "a"); + SlimListIterator* iterator = SlimList_CreateIterator(slimList); + SlimList_Iterator_Advance(&iterator); - CHECK_FALSE(SlimList_Iterator_HasItem(iterator)); + CHECK_FALSE(SlimList_Iterator_HasItem(iterator)); } - TEST(SlimList, iteratorGetString) { - const char* contents = "a"; - SlimList_AddString(slimList, contents); - SlimListIterator* iterator = SlimList_CreateIterator(slimList); + const char* contents = "a"; + SlimList_AddString(slimList, contents); + SlimListIterator* iterator = SlimList_CreateIterator(slimList); - const char *actual = SlimList_Iterator_GetString(iterator); - STRCMP_EQUAL(contents, actual); + const char* actual = SlimList_Iterator_GetString(iterator); + STRCMP_EQUAL(contents, actual); } - diff --git a/tests/CSlim/SlimUtilTest.cpp b/tests/CSlim/SlimUtilTest.cpp index 38c8b00..64f4366 100644 --- a/tests/CSlim/SlimUtilTest.cpp +++ b/tests/CSlim/SlimUtilTest.cpp @@ -1,14 +1,13 @@ +#include #include #include -#include #include "SlimUtil.h" #include "CppUTest/TestHarness.h" #include "CppUTest/TestHarness_c.h" -TEST_GROUP(SlimUtil) -{ +TEST_GROUP(SlimUtil){ }; @@ -40,13 +39,13 @@ TEST(SlimUtil, CanConcatenateToANonEmptyString) TEST(SlimUtil, StringStartsWith) { - CHECK(CSlim_StringStartsWith("", "")); - CHECK_FALSE(CSlim_StringStartsWith("", "a")); - CHECK_FALSE(CSlim_StringStartsWith("a", "ab")); - CHECK(CSlim_StringStartsWith("a", "")); - CHECK(CSlim_StringStartsWith("a", "a")); - CHECK(CSlim_StringStartsWith("ab", "a")); - CHECK_FALSE(CSlim_StringStartsWith("a", "b")); - CHECK(CSlim_StringStartsWith("abc", "ab")); - CHECK_FALSE(CSlim_StringStartsWith("abc", "ac")); + CHECK(CSlim_StringStartsWith("", "")); + CHECK_FALSE(CSlim_StringStartsWith("", "a")); + CHECK_FALSE(CSlim_StringStartsWith("a", "ab")); + CHECK(CSlim_StringStartsWith("a", "")); + CHECK(CSlim_StringStartsWith("a", "a")); + CHECK(CSlim_StringStartsWith("ab", "a")); + CHECK_FALSE(CSlim_StringStartsWith("a", "b")); + CHECK(CSlim_StringStartsWith("abc", "ab")); + CHECK_FALSE(CSlim_StringStartsWith("abc", "ac")); } diff --git a/tests/CSlim/StatementExecutorTest.cpp b/tests/CSlim/StatementExecutorTest.cpp index 81921fe..25ea7ca 100644 --- a/tests/CSlim/StatementExecutorTest.cpp +++ b/tests/CSlim/StatementExecutorTest.cpp @@ -1,545 +1,577 @@ #include "CppUTest/TestHarness.h" #include "CppUTestExt/MockSupport.h" -#include "StatementExecutor.h" -#include "TestSlim.h" #include "SlimList.h" #include "SlimListDeserializer.h" +#include "StatementExecutor.h" +#include "TestSlim.h" -#include #include +#include TEST_GROUP(StatementExecutor) { StatementExecutor* statementExecutor; - SlimList* args; - SlimList* empty; + SlimList* args; + SlimList* empty; void setup() { - args = SlimList_Create(); - empty = SlimList_Create(); - statementExecutor = StatementExecutor_Create(); - StatementExecutor_AddFixture(statementExecutor, TestSlim_Register); - StatementExecutor_Make(statementExecutor, "test_slim", "TestSlim", empty); - } - - void teardown() - { - StatementExecutor_Destroy(statementExecutor); - SlimList_Destroy(args); - SlimList_Destroy(empty); - } + args = SlimList_Create(); + empty = SlimList_Create(); + statementExecutor = StatementExecutor_Create(); + StatementExecutor_AddFixture(statementExecutor, TestSlim_Register); + StatementExecutor_Make(statementExecutor, "test_slim", "TestSlim", empty); + } + + void teardown() + { + StatementExecutor_Destroy(statementExecutor); + SlimList_Destroy(args); + SlimList_Destroy(empty); + } }; TEST(StatementExecutor, canCallFunctionWithNoArguments) { - StatementExecutor_Call(statementExecutor, "test_slim", "noArgs", args); - TestSlim* testSlim = (TestSlim*)StatementExecutor_Instance(statementExecutor, "test_slim"); - CHECK(TestSlim_noArgsCalled(testSlim)); + StatementExecutor_Call(statementExecutor, "test_slim", "noArgs", args); + TestSlim* testSlim = (TestSlim*)StatementExecutor_Instance(statementExecutor, "test_slim"); + CHECK(TestSlim_noArgsCalled(testSlim)); } TEST(StatementExecutor, cantCallFunctionThatDoesNotExist) { - const char* result = StatementExecutor_Call(statementExecutor, "test_slim", "noSuchMethod", args); - STRCMP_EQUAL("__EXCEPTION__:message:<>", result); + const char* result = StatementExecutor_Call(statementExecutor, "test_slim", "noSuchMethod", args); + STRCMP_EQUAL("__EXCEPTION__:message:<>", result); - result = StatementExecutor_Call(statementExecutor, "test_slim", "noOtherSuchMethod", args); - STRCMP_EQUAL("__EXCEPTION__:message:<>", result); + result = StatementExecutor_Call(statementExecutor, "test_slim", "noOtherSuchMethod", args); + STRCMP_EQUAL("__EXCEPTION__:message:<>", + result); } TEST(StatementExecutor, shouldTruncateReallyLongNamedFunctionThatDoesNotExistTo32) { - const char* result = StatementExecutor_Call(statementExecutor, "test_slim", "noOtherSuchMethod123456789022345678903234567890423456789052345678906234567890", args); - CHECK(strlen(result) < 120); - STRCMP_EQUAL("__EXCEPTION__:message:<>", result); + const char* result = StatementExecutor_Call( + statementExecutor, "test_slim", + "noOtherSuchMethod123456789022345678903234567890423456789052345678906234567890", args); + CHECK(strlen(result) < 120); + STRCMP_EQUAL( + "__EXCEPTION__:message:<>", + result); } TEST(StatementExecutor, shouldKnowNumberofArgumentsforNonExistantFunction) { - SlimList_AddString(args, "BlahBlah"); - const char* result = StatementExecutor_Call(statementExecutor, "test_slim", "noSuchMethod", args); - STRCMP_EQUAL("__EXCEPTION__:message:<>", result); + SlimList_AddString(args, "BlahBlah"); + const char* result = StatementExecutor_Call(statementExecutor, "test_slim", "noSuchMethod", args); + STRCMP_EQUAL("__EXCEPTION__:message:<>", result); } TEST(StatementExecutor, shouldNotAllowACallToaNonexistentInstance) { - const char* result = StatementExecutor_Call(statementExecutor, "noSuchInstance", "noArgs", args); - STRCMP_EQUAL("__EXCEPTION__:message:<>", result); + const char* result = StatementExecutor_Call(statementExecutor, "noSuchInstance", "noArgs", args); + STRCMP_EQUAL("__EXCEPTION__:message:<>", result); } TEST(StatementExecutor, shouldNotAllowAMakeOnANonexistentClass) { - const char* result = StatementExecutor_Make(statementExecutor, "instanceName", "NoSuchClass", empty); - STRCMP_EQUAL("__EXCEPTION__:message:<>", result); + const char* result = + StatementExecutor_Make(statementExecutor, "instanceName", "NoSuchClass", empty); + STRCMP_EQUAL("__EXCEPTION__:message:<>", result); } -TEST(StatementExecutor, canCallaMethodThatReturnsAValue) { - const char* result = StatementExecutor_Call(statementExecutor, "test_slim", "returnValue", args); - STRCMP_EQUAL("value", result); +TEST(StatementExecutor, canCallaMethodThatReturnsAValue) +{ + const char* result = StatementExecutor_Call(statementExecutor, "test_slim", "returnValue", args); + STRCMP_EQUAL("value", result); } TEST(StatementExecutor, canCallaMethodThatTakesASlimList) { - SlimList_AddString(args, "hello world"); - - const char* result = StatementExecutor_Call(statementExecutor, "test_slim", "echo", args); - STRCMP_EQUAL("hello world", result); + SlimList_AddString(args, "hello world"); + + const char* result = StatementExecutor_Call(statementExecutor, "test_slim", "echo", args); + STRCMP_EQUAL("hello world", result); } TEST(StatementExecutor, WhereCalledFunctionHasUnderscoresSeparatingNameParts) { - SlimList_AddString(args, "hello world"); + SlimList_AddString(args, "hello world"); - StatementExecutor_Call(statementExecutor, "test_slim", "setArg", args); - const char* result = StatementExecutor_Call(statementExecutor, "test_slim", "getArgFromFunctionWithUnderscores", empty); - STRCMP_EQUAL("hello world", result); + StatementExecutor_Call(statementExecutor, "test_slim", "setArg", args); + const char* result = StatementExecutor_Call(statementExecutor, "test_slim", + "getArgFromFunctionWithUnderscores", empty); + STRCMP_EQUAL("hello world", result); } TEST(StatementExecutor, canCallTwoInstancesOfTheSameFixture) { - SlimList* args2 = SlimList_Create(); - SlimList_AddString(args, "one"); - SlimList_AddString(args2, "two"); - - StatementExecutor_Make(statementExecutor, "test_slim2", "TestSlim", empty); - StatementExecutor_Call(statementExecutor, "test_slim", "setArg", args); - StatementExecutor_Call(statementExecutor, "test_slim2", "setArg", args2); - const char* one = StatementExecutor_Call(statementExecutor, "test_slim", "getArg", empty); - const char* two = StatementExecutor_Call(statementExecutor, "test_slim2", "getArg", empty); - STRCMP_EQUAL("one", one); - STRCMP_EQUAL("two", two); - SlimList_Destroy(args2); + SlimList* args2 = SlimList_Create(); + SlimList_AddString(args, "one"); + SlimList_AddString(args2, "two"); + + StatementExecutor_Make(statementExecutor, "test_slim2", "TestSlim", empty); + StatementExecutor_Call(statementExecutor, "test_slim", "setArg", args); + StatementExecutor_Call(statementExecutor, "test_slim2", "setArg", args2); + const char* one = StatementExecutor_Call(statementExecutor, "test_slim", "getArg", empty); + const char* two = StatementExecutor_Call(statementExecutor, "test_slim2", "getArg", empty); + STRCMP_EQUAL("one", one); + STRCMP_EQUAL("two", two); + SlimList_Destroy(args2); } TEST(StatementExecutor, canCreateTwoDifferentFixtures) { - SlimList* args2 = SlimList_Create(); - SlimList_AddString(args, "one"); - SlimList_AddString(args2, "two"); - - StatementExecutor_Make(statementExecutor, "test_slim2", "TestSlimAgain", empty); - StatementExecutor_Call(statementExecutor, "test_slim", "setArg", args); - StatementExecutor_Call(statementExecutor, "test_slim2", "setArgAgain", args2); - const char* one = StatementExecutor_Call(statementExecutor, "test_slim", "getArg", empty); - const char* two = StatementExecutor_Call(statementExecutor, "test_slim2", "getArgAgain", empty); - STRCMP_EQUAL("one", one); - STRCMP_EQUAL("two", two); - SlimList_Destroy(args2); + SlimList* args2 = SlimList_Create(); + SlimList_AddString(args, "one"); + SlimList_AddString(args2, "two"); + + StatementExecutor_Make(statementExecutor, "test_slim2", "TestSlimAgain", empty); + StatementExecutor_Call(statementExecutor, "test_slim", "setArg", args); + StatementExecutor_Call(statementExecutor, "test_slim2", "setArgAgain", args2); + const char* one = StatementExecutor_Call(statementExecutor, "test_slim", "getArg", empty); + const char* two = StatementExecutor_Call(statementExecutor, "test_slim2", "getArgAgain", empty); + STRCMP_EQUAL("one", one); + STRCMP_EQUAL("two", two); + SlimList_Destroy(args2); } TEST(StatementExecutor, canReplaceSymbolsWithTheirValue) { - StatementExecutor_SetSymbol(statementExecutor, "v", "bob"); - SlimList_AddString(args, "hi $v."); - const char* result = StatementExecutor_Call(statementExecutor, "test_slim", "echo", args); - LONGS_EQUAL(strlen("hi bob."), strlen(result)) - STRCMP_EQUAL("hi bob.", result) + StatementExecutor_SetSymbol(statementExecutor, "v", "bob"); + SlimList_AddString(args, "hi $v."); + const char* result = StatementExecutor_Call(statementExecutor, "test_slim", "echo", args); + LONGS_EQUAL(strlen("hi bob."), strlen(result)) + STRCMP_EQUAL("hi bob.", result) } TEST(StatementExecutor, canReplaceSymbolsInTheMiddle) { - StatementExecutor_SetSymbol(statementExecutor, "v", "bob"); - SlimList_AddString(args, "hi $v whats up."); - STRCMP_EQUAL("hi bob whats up.", StatementExecutor_Call(statementExecutor, "test_slim", "echo", args)) + StatementExecutor_SetSymbol(statementExecutor, "v", "bob"); + SlimList_AddString(args, "hi $v whats up."); + STRCMP_EQUAL("hi bob whats up.", + StatementExecutor_Call(statementExecutor, "test_slim", "echo", args)) } TEST(StatementExecutor, canReplaceSymbolsWithOtherNonAlphaNumeric) { - StatementExecutor_SetSymbol(statementExecutor, "v2", "bob"); - SlimList_AddString(args, "$v2=why"); - STRCMP_EQUAL("bob=why", StatementExecutor_Call(statementExecutor, "test_slim", "echo", args)) + StatementExecutor_SetSymbol(statementExecutor, "v2", "bob"); + SlimList_AddString(args, "$v2=why"); + STRCMP_EQUAL("bob=why", StatementExecutor_Call(statementExecutor, "test_slim", "echo", args)) } TEST(StatementExecutor, canReplaceMultipleSymbolsWithTheirValue) { - StatementExecutor_SetSymbol(statementExecutor, "v", "bob"); - StatementExecutor_SetSymbol(statementExecutor, "e", "doug"); - SlimList_AddString(args, "hi $v. Cost: $12.32 from $e."); - STRCMP_EQUAL("hi bob. Cost: $12.32 from doug.", StatementExecutor_Call(statementExecutor, "test_slim", "echo", args)) + StatementExecutor_SetSymbol(statementExecutor, "v", "bob"); + StatementExecutor_SetSymbol(statementExecutor, "e", "doug"); + SlimList_AddString(args, "hi $v. Cost: $12.32 from $e."); + STRCMP_EQUAL("hi bob. Cost: $12.32 from doug.", + StatementExecutor_Call(statementExecutor, "test_slim", "echo", args)) } TEST(StatementExecutor, canHandlestringWithJustADollarSign) { - StatementExecutor_SetSymbol(statementExecutor, "v2", "bob"); - SlimList_AddString(args, "$"); - STRCMP_EQUAL("$", StatementExecutor_Call(statementExecutor, "test_slim", "echo", args)) + StatementExecutor_SetSymbol(statementExecutor, "v2", "bob"); + SlimList_AddString(args, "$"); + STRCMP_EQUAL("$", StatementExecutor_Call(statementExecutor, "test_slim", "echo", args)) } TEST(StatementExecutor, canHandleDollarSignAtTheEndOfTheString) { - StatementExecutor_SetSymbol(statementExecutor, "v2", "doug"); - SlimList_AddString(args, "hi $v2$"); - STRCMP_EQUAL("hi doug$", StatementExecutor_Call(statementExecutor, "test_slim", "echo", args)) -} - -TEST(StatementExecutor, canReplaceSymbolsInSubLists) -{ - StatementExecutor_SetSymbol(statementExecutor, "v2", "doug"); - SlimList* subList = SlimList_Create(); - SlimList_AddString(subList, "Hi $v2."); - SlimList_AddList(args, subList); - const char* result = StatementExecutor_Call(statementExecutor, "test_slim", "echo", args); - CHECK(result != NULL); - SlimList* returnedList = SlimList_Deserialize(result); - CHECK(NULL != returnedList); - LONGS_EQUAL(1, SlimList_GetLength(returnedList)); - const char* element = SlimList_GetStringAt(returnedList, 0); - STRCMP_EQUAL("Hi doug.", element); - SlimList_Destroy(subList); - SlimList_Destroy(returnedList); -} - -TEST(StatementExecutor, canReplaceSymbolsInSubSubLists) -{ - StatementExecutor_SetSymbol(statementExecutor, "v2", "doug"); - SlimList* subList = SlimList_Create(); - SlimList* subSubList = SlimList_Create(); - SlimList_AddString(subSubList, "Hi $v2."); - SlimList_AddList(subList, subSubList); - SlimList_AddList(args, subList); - const char* result = StatementExecutor_Call(statementExecutor, "test_slim", "echo", args); - CHECK(result != NULL); - SlimList* returnedSubList = SlimList_Deserialize(result); - CHECK(NULL != returnedSubList); - LONGS_EQUAL(1, SlimList_GetLength(returnedSubList)); - SlimList* returnedSubSubList = SlimList_GetListAt(returnedSubList, 0); - CHECK(NULL != returnedSubSubList); - LONGS_EQUAL(1, SlimList_GetLength(returnedSubSubList)); - const char* element = SlimList_GetStringAt(returnedSubSubList, 0); - CHECK(NULL != element); - STRCMP_EQUAL("Hi doug.", element); - SlimList_Destroy(subSubList); - SlimList_Destroy(subList); - SlimList_Destroy(returnedSubList); + StatementExecutor_SetSymbol(statementExecutor, "v2", "doug"); + SlimList_AddString(args, "hi $v2$"); + STRCMP_EQUAL("hi doug$", StatementExecutor_Call(statementExecutor, "test_slim", "echo", args)) +} + +TEST(StatementExecutor, canReplaceSymbolsInSubLists) +{ + StatementExecutor_SetSymbol(statementExecutor, "v2", "doug"); + SlimList* subList = SlimList_Create(); + SlimList_AddString(subList, "Hi $v2."); + SlimList_AddList(args, subList); + const char* result = StatementExecutor_Call(statementExecutor, "test_slim", "echo", args); + CHECK(result != NULL); + SlimList* returnedList = SlimList_Deserialize(result); + CHECK(NULL != returnedList); + LONGS_EQUAL(1, SlimList_GetLength(returnedList)); + const char* element = SlimList_GetStringAt(returnedList, 0); + STRCMP_EQUAL("Hi doug.", element); + SlimList_Destroy(subList); + SlimList_Destroy(returnedList); +} + +TEST(StatementExecutor, canReplaceSymbolsInSubSubLists) +{ + StatementExecutor_SetSymbol(statementExecutor, "v2", "doug"); + SlimList* subList = SlimList_Create(); + SlimList* subSubList = SlimList_Create(); + SlimList_AddString(subSubList, "Hi $v2."); + SlimList_AddList(subList, subSubList); + SlimList_AddList(args, subList); + const char* result = StatementExecutor_Call(statementExecutor, "test_slim", "echo", args); + CHECK(result != NULL); + SlimList* returnedSubList = SlimList_Deserialize(result); + CHECK(NULL != returnedSubList); + LONGS_EQUAL(1, SlimList_GetLength(returnedSubList)); + SlimList* returnedSubSubList = SlimList_GetListAt(returnedSubList, 0); + CHECK(NULL != returnedSubSubList); + LONGS_EQUAL(1, SlimList_GetLength(returnedSubSubList)); + const char* element = SlimList_GetStringAt(returnedSubSubList, 0); + CHECK(NULL != element); + STRCMP_EQUAL("Hi doug.", element); + SlimList_Destroy(subSubList); + SlimList_Destroy(subList); + SlimList_Destroy(returnedSubList); } TEST(StatementExecutor, canCreateFixtureWithSymbolAsClassName) { - StatementExecutor_SetSymbol(statementExecutor, "fixtureName", "Test_Slim"); - const char* makeResponse = StatementExecutor_Make(statementExecutor, "instanceName", "$fixtureName", empty); - STRCMP_EQUAL("OK", makeResponse); + StatementExecutor_SetSymbol(statementExecutor, "fixtureName", "Test_Slim"); + const char* makeResponse = + StatementExecutor_Make(statementExecutor, "instanceName", "$fixtureName", empty); + STRCMP_EQUAL("OK", makeResponse); } TEST(StatementExecutor, shouldNotAllowAMakeOnANonexistentClassReferencedBySymbol) { - StatementExecutor_SetSymbol(statementExecutor, "fixtureName", "NoSuchClass"); - const char* makeResponse = StatementExecutor_Make(statementExecutor, "instanceName", "$fixtureName", empty); - STRCMP_EQUAL("__EXCEPTION__:message:<>", makeResponse); + StatementExecutor_SetSymbol(statementExecutor, "fixtureName", "NoSuchClass"); + const char* makeResponse = + StatementExecutor_Make(statementExecutor, "instanceName", "$fixtureName", empty); + STRCMP_EQUAL("__EXCEPTION__:message:<>", makeResponse); } TEST(StatementExecutor, canCreateFixtureWithSymbolInClassName) { - StatementExecutor_SetSymbol(statementExecutor, "test", "Test"); - const char* makeResponse = StatementExecutor_Make(statementExecutor, "instanceName", "$test_Slim", empty); - STRCMP_EQUAL("OK", makeResponse); + StatementExecutor_SetSymbol(statementExecutor, "test", "Test"); + const char* makeResponse = + StatementExecutor_Make(statementExecutor, "instanceName", "$test_Slim", empty); + STRCMP_EQUAL("OK", makeResponse); } TEST(StatementExecutor, canCreateFixtureWithMultipleSymbolsInClassName) { - StatementExecutor_SetSymbol(statementExecutor, "test", "Test"); - StatementExecutor_SetSymbol(statementExecutor, "slim", "Slim"); - const char* makeResponse = StatementExecutor_Make(statementExecutor, "instanceName", "$test_$slim", empty); - STRCMP_EQUAL("OK", makeResponse); + StatementExecutor_SetSymbol(statementExecutor, "test", "Test"); + StatementExecutor_SetSymbol(statementExecutor, "slim", "Slim"); + const char* makeResponse = + StatementExecutor_Make(statementExecutor, "instanceName", "$test_$slim", empty); + STRCMP_EQUAL("OK", makeResponse); } -TEST(StatementExecutor, canCreateFixtureWithArguments) +TEST(StatementExecutor, canCreateFixtureWithArguments) { - SlimList* constructionArgs = SlimList_Create(); - SlimList_AddString(constructionArgs, "hi"); - StatementExecutor_Make(statementExecutor, "test_slim", "TestSlim", constructionArgs); - const char* result = StatementExecutor_Call(statementExecutor, "test_slim", "getConstructionArg", empty); - STRCMP_EQUAL("hi", result); - - SlimList_Destroy(constructionArgs); + SlimList* constructionArgs = SlimList_Create(); + SlimList_AddString(constructionArgs, "hi"); + StatementExecutor_Make(statementExecutor, "test_slim", "TestSlim", constructionArgs); + const char* result = + StatementExecutor_Call(statementExecutor, "test_slim", "getConstructionArg", empty); + STRCMP_EQUAL("hi", result); + + SlimList_Destroy(constructionArgs); } -TEST(StatementExecutor, canCreateFixtureWithArgumentsThatHaveSymbols) +TEST(StatementExecutor, canCreateFixtureWithArgumentsThatHaveSymbols) { - StatementExecutor_SetSymbol(statementExecutor, "name", "doug"); - SlimList* constructionArgs = SlimList_Create(); - SlimList_AddString(constructionArgs, "hi $name"); - StatementExecutor_Make(statementExecutor, "test_slim", "TestSlim", constructionArgs); - const char* result = StatementExecutor_Call(statementExecutor, "test_slim", "getConstructionArg", empty); - STRCMP_EQUAL("hi doug", result); - - SlimList_Destroy(constructionArgs); + StatementExecutor_SetSymbol(statementExecutor, "name", "doug"); + SlimList* constructionArgs = SlimList_Create(); + SlimList_AddString(constructionArgs, "hi $name"); + StatementExecutor_Make(statementExecutor, "test_slim", "TestSlim", constructionArgs); + const char* result = + StatementExecutor_Call(statementExecutor, "test_slim", "getConstructionArg", empty); + STRCMP_EQUAL("hi doug", result); + + SlimList_Destroy(constructionArgs); } -TEST(StatementExecutor, canCreateFixtureWithArgumentsThatHaveMultipleSymbols) +TEST(StatementExecutor, canCreateFixtureWithArgumentsThatHaveMultipleSymbols) { - StatementExecutor_SetSymbol(statementExecutor, "fname", "doug"); - StatementExecutor_SetSymbol(statementExecutor, "lname", "bradbury"); - - SlimList* constructionArgs = SlimList_Create(); - SlimList_AddString(constructionArgs, "hi $fname $lname"); - StatementExecutor_Make(statementExecutor, "test_slim", "TestSlim", constructionArgs); - const char* result = StatementExecutor_Call(statementExecutor, "test_slim", "getConstructionArg", empty); - STRCMP_EQUAL("hi doug bradbury", result); - - SlimList_Destroy(constructionArgs); + StatementExecutor_SetSymbol(statementExecutor, "fname", "doug"); + StatementExecutor_SetSymbol(statementExecutor, "lname", "bradbury"); + + SlimList* constructionArgs = SlimList_Create(); + SlimList_AddString(constructionArgs, "hi $fname $lname"); + StatementExecutor_Make(statementExecutor, "test_slim", "TestSlim", constructionArgs); + const char* result = + StatementExecutor_Call(statementExecutor, "test_slim", "getConstructionArg", empty); + STRCMP_EQUAL("hi doug bradbury", result); + + SlimList_Destroy(constructionArgs); } -TEST(StatementExecutor, fixtureConstructionFailsWithUserErrorMessage) +TEST(StatementExecutor, fixtureConstructionFailsWithUserErrorMessage) { - SlimList* constructionArgs = SlimList_Create(); - SlimList_AddString(constructionArgs, "hi doug"); - SlimList_AddString(constructionArgs, "ho doug"); - - const char* result = StatementExecutor_Make(statementExecutor, "test_slim", "TestSlim", constructionArgs); - STRCMP_EQUAL("__EXCEPTION__:message:<>", result); - - SlimList_Destroy(constructionArgs); + SlimList* constructionArgs = SlimList_Create(); + SlimList_AddString(constructionArgs, "hi doug"); + SlimList_AddString(constructionArgs, "ho doug"); + + const char* result = + StatementExecutor_Make(statementExecutor, "test_slim", "TestSlim", constructionArgs); + STRCMP_EQUAL("__EXCEPTION__:message:<>", result); + + SlimList_Destroy(constructionArgs); } TEST(StatementExecutor, fixtureReferencedBySymbolConstructionFailsWithUserErrorMessage) { - StatementExecutor_SetSymbol(statementExecutor, "fixtureName", "Test_Slim"); - SlimList_AddString(args, "arg0"); - SlimList_AddString(args, "arg1"); - const char* makeResponse = StatementExecutor_Make(statementExecutor, "instanceName", "$fixtureName", args); - STRCMP_EQUAL("__EXCEPTION__:message:<>", makeResponse); + StatementExecutor_SetSymbol(statementExecutor, "fixtureName", "Test_Slim"); + SlimList_AddString(args, "arg0"); + SlimList_AddString(args, "arg1"); + const char* makeResponse = + StatementExecutor_Make(statementExecutor, "instanceName", "$fixtureName", args); + STRCMP_EQUAL("__EXCEPTION__:message:<>", + makeResponse); } -TEST(StatementExecutor, fixtureCanReturnError) +TEST(StatementExecutor, fixtureCanReturnError) { - const char* result = StatementExecutor_Call(statementExecutor, "test_slim", "returnError", args); - STRCMP_EQUAL("__EXCEPTION__:message:<>", result); + const char* result = StatementExecutor_Call(statementExecutor, "test_slim", "returnError", args); + STRCMP_EQUAL("__EXCEPTION__:message:<>", result); } -TEST(StatementExecutor, canCallFixtureDeclaredBackwards) +TEST(StatementExecutor, canCallFixtureDeclaredBackwards) { - StatementExecutor_Make(statementExecutor, "backwardsTestSlim", "TestSlimDeclaredLate", empty); - SlimList_AddString(args, "hi doug"); - const char* result = StatementExecutor_Call(statementExecutor, "backwardsTestSlim", "echo", args); - STRCMP_EQUAL("hi doug", result); + StatementExecutor_Make(statementExecutor, "backwardsTestSlim", "TestSlimDeclaredLate", empty); + SlimList_AddString(args, "hi doug"); + const char* result = StatementExecutor_Call(statementExecutor, "backwardsTestSlim", "echo", args); + STRCMP_EQUAL("hi doug", result); } -TEST(StatementExecutor, canCallFixtureNotDeclared) +TEST(StatementExecutor, canCallFixtureNotDeclared) { - StatementExecutor_Make(statementExecutor, "undeclaredTestSlim", "TestSlimUndeclared", empty); - SlimList_AddString(args, "hi doug"); - const char* result = StatementExecutor_Call(statementExecutor, "undeclaredTestSlim", "echo", args); - STRCMP_EQUAL("hi doug", result); + StatementExecutor_Make(statementExecutor, "undeclaredTestSlim", "TestSlimUndeclared", empty); + SlimList_AddString(args, "hi doug"); + const char* result = + StatementExecutor_Call(statementExecutor, "undeclaredTestSlim", "echo", args); + STRCMP_EQUAL("hi doug", result); } TEST(StatementExecutor, canHaveNullResult) { - const char* result = StatementExecutor_Call(statementExecutor, "test_slim", "null", args); - POINTERS_EQUAL(0, result); + const char* result = StatementExecutor_Call(statementExecutor, "test_slim", "null", args); + POINTERS_EQUAL(0, result); } TEST_GROUP(StatementExecutorWithLibraryInstances) { - StatementExecutor *statementExecutor; - SlimList* noArgs; + StatementExecutor* statementExecutor; + SlimList* noArgs; - void setup() - { - statementExecutor = StatementExecutor_Create(); - noArgs = SlimList_Create(); - StatementExecutor_AddFixture(statementExecutor, &RegisterMockFixtureWith1Method); - StatementExecutor_AddFixture(statementExecutor, &RegisterMockFixtureWith2Methods); - StatementExecutor_AddFixture(statementExecutor, &RegisterMockFixtureWith3Methods); - } + void setup() + { + statementExecutor = StatementExecutor_Create(); + noArgs = SlimList_Create(); + StatementExecutor_AddFixture(statementExecutor, &RegisterMockFixtureWith1Method); + StatementExecutor_AddFixture(statementExecutor, &RegisterMockFixtureWith2Methods); + StatementExecutor_AddFixture(statementExecutor, &RegisterMockFixtureWith3Methods); + } + + void teardown() + { + mock().clear(); + SlimList_Destroy(noArgs); + StatementExecutor_Destroy(statementExecutor); + } - void teardown() + struct MockFixture + { + char* method1(SlimList* args) { - mock().clear(); - SlimList_Destroy(noArgs); - StatementExecutor_Destroy(statementExecutor); + return const_cast(mock() + .actualCall("method1") + .onObject(this) + .withParameter("args", args) + .returnStringValue()); } - struct MockFixture - { - char* method1(SlimList* args) - { - return const_cast(mock().actualCall("method1") - .onObject(this) - .withParameter("args", args) - .returnStringValue()); - } - - char* method2(SlimList* args) - { - return const_cast(mock().actualCall("method2") - .onObject(this) - .withParameter("args", args) - .returnStringValue()); - } - - char* method3(SlimList* args) - { - return const_cast(mock().actualCall("method3") - .onObject(this) - .withParameter("args", args) - .returnStringValue()); - } - }; - - static void* createMockFixture(StatementExecutor*, SlimList*) + char* method2(SlimList* args) { - return mock().actualCall("createMockFixture") - .returnPointerValue(); + return const_cast(mock() + .actualCall("method2") + .onObject(this) + .withParameter("args", args) + .returnStringValue()); } - static void destroyMockFixture(void* mockFixture) + char* method3(SlimList* args) { - delete reinterpret_cast(mockFixture); + return const_cast(mock() + .actualCall("method3") + .onObject(this) + .withParameter("args", args) + .returnStringValue()); } + }; - static const char* invokeMethod1(void* mockFixture, SlimList* args) - { - return reinterpret_cast(mockFixture)->method1(args); - } + static void* createMockFixture(StatementExecutor*, SlimList*) + { + return mock().actualCall("createMockFixture").returnPointerValue(); + } - static const char* invokeMethod2(void* mockFixture, SlimList* args) - { - return reinterpret_cast(mockFixture)->method2(args); - } + static void destroyMockFixture(void* mockFixture) + { + delete reinterpret_cast(mockFixture); + } - static const char* invokeMethod3(void* mockFixture, SlimList* args) - { - return reinterpret_cast(mockFixture)->method3(args); - } + static const char* invokeMethod1(void* mockFixture, SlimList* args) + { + return reinterpret_cast(mockFixture)->method1(args); + } - static void RegisterMockFixtureWith1Method(StatementExecutor* statementExecutor) - { - StatementExecutor_RegisterFixture(statementExecutor, "MockFixtureWith1Method", &createMockFixture, &destroyMockFixture); - StatementExecutor_RegisterMethod(statementExecutor, "MockFixtureWith1Method", "method1", &invokeMethod1); - } + static const char* invokeMethod2(void* mockFixture, SlimList* args) + { + return reinterpret_cast(mockFixture)->method2(args); + } - static void RegisterMockFixtureWith2Methods(StatementExecutor* statementExecutor) - { - StatementExecutor_RegisterFixture(statementExecutor, "MockFixtureWith2Methods", &createMockFixture, &destroyMockFixture); - StatementExecutor_RegisterMethod(statementExecutor, "MockFixtureWith2Methods", "method1", &invokeMethod1); - StatementExecutor_RegisterMethod(statementExecutor, "MockFixtureWith2Methods", "method2", &invokeMethod2); - } + static const char* invokeMethod3(void* mockFixture, SlimList* args) + { + return reinterpret_cast(mockFixture)->method3(args); + } - static void RegisterMockFixtureWith3Methods(StatementExecutor* statementExecutor) - { - StatementExecutor_RegisterFixture(statementExecutor, "MockFixtureWith3Methods", &createMockFixture, &destroyMockFixture); - StatementExecutor_RegisterMethod(statementExecutor, "MockFixtureWith3Methods", "method1", &invokeMethod1); - StatementExecutor_RegisterMethod(statementExecutor, "MockFixtureWith3Methods", "method2", &invokeMethod2); - StatementExecutor_RegisterMethod(statementExecutor, "MockFixtureWith3Methods", "method3", &invokeMethod3); - } + static void RegisterMockFixtureWith1Method(StatementExecutor * statementExecutor) + { + StatementExecutor_RegisterFixture(statementExecutor, "MockFixtureWith1Method", + &createMockFixture, &destroyMockFixture); + StatementExecutor_RegisterMethod(statementExecutor, "MockFixtureWith1Method", "method1", + &invokeMethod1); + } + + static void RegisterMockFixtureWith2Methods(StatementExecutor * statementExecutor) + { + StatementExecutor_RegisterFixture(statementExecutor, "MockFixtureWith2Methods", + &createMockFixture, &destroyMockFixture); + StatementExecutor_RegisterMethod(statementExecutor, "MockFixtureWith2Methods", "method1", + &invokeMethod1); + StatementExecutor_RegisterMethod(statementExecutor, "MockFixtureWith2Methods", "method2", + &invokeMethod2); + } + + static void RegisterMockFixtureWith3Methods(StatementExecutor * statementExecutor) + { + StatementExecutor_RegisterFixture(statementExecutor, "MockFixtureWith3Methods", + &createMockFixture, &destroyMockFixture); + StatementExecutor_RegisterMethod(statementExecutor, "MockFixtureWith3Methods", "method1", + &invokeMethod1); + StatementExecutor_RegisterMethod(statementExecutor, "MockFixtureWith3Methods", "method2", + &invokeMethod2); + StatementExecutor_RegisterMethod(statementExecutor, "MockFixtureWith3Methods", "method3", + &invokeMethod3); + } }; TEST(StatementExecutorWithLibraryInstances, callsMethodOnInstanceFirst) { - MockFixture* standardInstance = new MockFixture; - MockFixture* libraryInstance = new MockFixture; + MockFixture* standardInstance = new MockFixture; + MockFixture* libraryInstance = new MockFixture; - mock().expectOneCall("createMockFixture") - .andReturnValue(standardInstance); - mock().expectOneCall("createMockFixture") - .andReturnValue(libraryInstance); - mock().expectOneCall("method1") - .onObject(standardInstance) - .withParameter("args", noArgs) - .andReturnValue("OK"); + mock().expectOneCall("createMockFixture").andReturnValue(standardInstance); + mock().expectOneCall("createMockFixture").andReturnValue(libraryInstance); + mock() + .expectOneCall("method1") + .onObject(standardInstance) + .withParameter("args", noArgs) + .andReturnValue("OK"); - StatementExecutor_Make(statementExecutor, "standardInstance", "MockFixtureWith1Method", noArgs); - StatementExecutor_Make(statementExecutor, "libraryInstance", "MockFixtureWith2Methods", noArgs); - const char* result = StatementExecutor_Call(statementExecutor, "standardInstance", "method1", noArgs); + StatementExecutor_Make(statementExecutor, "standardInstance", "MockFixtureWith1Method", noArgs); + StatementExecutor_Make(statementExecutor, "libraryInstance", "MockFixtureWith2Methods", noArgs); + const char* result = + StatementExecutor_Call(statementExecutor, "standardInstance", "method1", noArgs); - STRCMP_EQUAL("OK", result); - mock().checkExpectations(); + STRCMP_EQUAL("OK", result); + mock().checkExpectations(); } TEST(StatementExecutorWithLibraryInstances, callsMethodOnLibraryInstanceWhenNotFoundOnGivenInstance) { - MockFixture* standardInstance = new MockFixture; - MockFixture* libraryInstance = new MockFixture; - - mock().expectOneCall("createMockFixture") - .andReturnValue(standardInstance); - mock().expectOneCall("createMockFixture") - .andReturnValue(libraryInstance); - mock().expectOneCall("method2") - .onObject(libraryInstance) - .withParameter("args", noArgs) - .andReturnValue("OK"); - - StatementExecutor_Make(statementExecutor, "standardInstance", "MockFixtureWith1Method", noArgs); - StatementExecutor_Make(statementExecutor, "libraryInstance", "MockFixtureWith2Methods", noArgs); - const char* result = StatementExecutor_Call(statementExecutor, "standardInstance", "method2", noArgs); - - STRCMP_EQUAL("OK", result); - mock().checkExpectations(); -} - -TEST(StatementExecutorWithLibraryInstances, callsMethodOnTopOfLibraryInstanceStackWhenNotFoundOnGivenInstance) -{ - MockFixture* standardInstance = new MockFixture; - MockFixture* libraryInstanceA = new MockFixture; - MockFixture* libraryInstanceB = new MockFixture; - - mock().expectOneCall("createMockFixture") - .andReturnValue(standardInstance); - mock().expectOneCall("createMockFixture") - .andReturnValue(libraryInstanceA); - mock().expectOneCall("createMockFixture") - .andReturnValue(libraryInstanceB); - mock().expectOneCall("method2") - .onObject(libraryInstanceB) - .withParameter("args", noArgs) - .andReturnValue("OK"); - - StatementExecutor_Make(statementExecutor, "standardInstance", "MockFixtureWith1Method", noArgs); - StatementExecutor_Make(statementExecutor, "libraryInstanceA", "MockFixtureWith3Methods", noArgs); - StatementExecutor_Make(statementExecutor, "libraryInstanceB", "MockFixtureWith2Methods", noArgs); - const char* result = StatementExecutor_Call(statementExecutor, "standardInstance", "method2", noArgs); - - STRCMP_EQUAL("OK", result); - mock().checkExpectations(); -} - -TEST(StatementExecutorWithLibraryInstances, callsMethodOnBottomOfLibraryInstanceStackWhenNotFoundOnGivenInstance) -{ - MockFixture* standardInstance = new MockFixture; - MockFixture* libraryInstanceA = new MockFixture; - MockFixture* libraryInstanceB = new MockFixture; - - mock().expectOneCall("createMockFixture") - .andReturnValue(standardInstance); - mock().expectOneCall("createMockFixture") - .andReturnValue(libraryInstanceA); - mock().expectOneCall("createMockFixture") - .andReturnValue(libraryInstanceB); - mock().expectOneCall("method3") - .onObject(libraryInstanceA) - .withParameter("args", noArgs) - .andReturnValue("OK"); - - StatementExecutor_Make(statementExecutor, "standardInstance", "MockFixtureWith1Method", noArgs); - StatementExecutor_Make(statementExecutor, "libraryInstanceA", "MockFixtureWith3Methods", noArgs); - StatementExecutor_Make(statementExecutor, "libraryInstanceB", "MockFixtureWith2Methods", noArgs); - const char* result = StatementExecutor_Call(statementExecutor, "standardInstance", "method3", noArgs); - - STRCMP_EQUAL("OK", result); - mock().checkExpectations(); -} - -TEST(StatementExecutorWithLibraryInstances, callMethodThatDoesNotExistOnGivenInstanceOrLibraryInstancesReturnsException) -{ - MockFixture* standardInstance = new MockFixture; - MockFixture* libraryInstanceA = new MockFixture; - MockFixture* libraryInstanceB = new MockFixture; - - mock().expectOneCall("createMockFixture") - .andReturnValue(standardInstance); - mock().expectOneCall("createMockFixture") - .andReturnValue(libraryInstanceA); - mock().expectOneCall("createMockFixture") - .andReturnValue(libraryInstanceB); - - StatementExecutor_Make(statementExecutor, "standardInstance", "MockFixtureWith1Method", noArgs); - StatementExecutor_Make(statementExecutor, "libraryInstanceA", "MockFixtureWith3Methods", noArgs); - StatementExecutor_Make(statementExecutor, "libraryInstanceB", "MockFixtureWith2Methods", noArgs); - const char* result = StatementExecutor_Call(statementExecutor, "standardInstance", "method4", noArgs); - - STRCMP_EQUAL("__EXCEPTION__:message:<>", result); - mock().checkExpectations(); + MockFixture* standardInstance = new MockFixture; + MockFixture* libraryInstance = new MockFixture; + + mock().expectOneCall("createMockFixture").andReturnValue(standardInstance); + mock().expectOneCall("createMockFixture").andReturnValue(libraryInstance); + mock() + .expectOneCall("method2") + .onObject(libraryInstance) + .withParameter("args", noArgs) + .andReturnValue("OK"); + + StatementExecutor_Make(statementExecutor, "standardInstance", "MockFixtureWith1Method", noArgs); + StatementExecutor_Make(statementExecutor, "libraryInstance", "MockFixtureWith2Methods", noArgs); + const char* result = + StatementExecutor_Call(statementExecutor, "standardInstance", "method2", noArgs); + + STRCMP_EQUAL("OK", result); + mock().checkExpectations(); +} + +TEST(StatementExecutorWithLibraryInstances, + callsMethodOnTopOfLibraryInstanceStackWhenNotFoundOnGivenInstance) +{ + MockFixture* standardInstance = new MockFixture; + MockFixture* libraryInstanceA = new MockFixture; + MockFixture* libraryInstanceB = new MockFixture; + + mock().expectOneCall("createMockFixture").andReturnValue(standardInstance); + mock().expectOneCall("createMockFixture").andReturnValue(libraryInstanceA); + mock().expectOneCall("createMockFixture").andReturnValue(libraryInstanceB); + mock() + .expectOneCall("method2") + .onObject(libraryInstanceB) + .withParameter("args", noArgs) + .andReturnValue("OK"); + + StatementExecutor_Make(statementExecutor, "standardInstance", "MockFixtureWith1Method", noArgs); + StatementExecutor_Make(statementExecutor, "libraryInstanceA", "MockFixtureWith3Methods", noArgs); + StatementExecutor_Make(statementExecutor, "libraryInstanceB", "MockFixtureWith2Methods", noArgs); + const char* result = + StatementExecutor_Call(statementExecutor, "standardInstance", "method2", noArgs); + + STRCMP_EQUAL("OK", result); + mock().checkExpectations(); +} + +TEST(StatementExecutorWithLibraryInstances, + callsMethodOnBottomOfLibraryInstanceStackWhenNotFoundOnGivenInstance) +{ + MockFixture* standardInstance = new MockFixture; + MockFixture* libraryInstanceA = new MockFixture; + MockFixture* libraryInstanceB = new MockFixture; + + mock().expectOneCall("createMockFixture").andReturnValue(standardInstance); + mock().expectOneCall("createMockFixture").andReturnValue(libraryInstanceA); + mock().expectOneCall("createMockFixture").andReturnValue(libraryInstanceB); + mock() + .expectOneCall("method3") + .onObject(libraryInstanceA) + .withParameter("args", noArgs) + .andReturnValue("OK"); + + StatementExecutor_Make(statementExecutor, "standardInstance", "MockFixtureWith1Method", noArgs); + StatementExecutor_Make(statementExecutor, "libraryInstanceA", "MockFixtureWith3Methods", noArgs); + StatementExecutor_Make(statementExecutor, "libraryInstanceB", "MockFixtureWith2Methods", noArgs); + const char* result = + StatementExecutor_Call(statementExecutor, "standardInstance", "method3", noArgs); + + STRCMP_EQUAL("OK", result); + mock().checkExpectations(); +} + +TEST(StatementExecutorWithLibraryInstances, + callMethodThatDoesNotExistOnGivenInstanceOrLibraryInstancesReturnsException) +{ + MockFixture* standardInstance = new MockFixture; + MockFixture* libraryInstanceA = new MockFixture; + MockFixture* libraryInstanceB = new MockFixture; + + mock().expectOneCall("createMockFixture").andReturnValue(standardInstance); + mock().expectOneCall("createMockFixture").andReturnValue(libraryInstanceA); + mock().expectOneCall("createMockFixture").andReturnValue(libraryInstanceB); + + StatementExecutor_Make(statementExecutor, "standardInstance", "MockFixtureWith1Method", noArgs); + StatementExecutor_Make(statementExecutor, "libraryInstanceA", "MockFixtureWith3Methods", noArgs); + StatementExecutor_Make(statementExecutor, "libraryInstanceB", "MockFixtureWith2Methods", noArgs); + const char* result = + StatementExecutor_Call(statementExecutor, "standardInstance", "method4", noArgs); + + STRCMP_EQUAL("__EXCEPTION__:message:<>", + result); + mock().checkExpectations(); } diff --git a/tests/CSlim/SymbolTableTest.cpp b/tests/CSlim/SymbolTableTest.cpp index 6476264..172854d 100644 --- a/tests/CSlim/SymbolTableTest.cpp +++ b/tests/CSlim/SymbolTableTest.cpp @@ -6,38 +6,31 @@ TEST_GROUP(SymbolTable) { - SymbolTable* symbolTable; - - void setup() - { - symbolTable = SymbolTable_Create(); - } - - void teardown() - { - SymbolTable_Destroy(symbolTable); - } + SymbolTable* symbolTable; + + void setup() { symbolTable = SymbolTable_Create(); } + + void teardown() { SymbolTable_Destroy(symbolTable); } }; TEST(SymbolTable, findNonExistentSymbolShouldReturnNull) { - POINTERS_EQUAL(NULL, SymbolTable_FindSymbol(symbolTable, "Hey", 3)); + POINTERS_EQUAL(NULL, SymbolTable_FindSymbol(symbolTable, "Hey", 3)); } TEST(SymbolTable, findSymbolShouldReturnSymbol) { - SymbolTable_SetSymbol(symbolTable, "Hey", "You"); - STRCMP_EQUAL("You", SymbolTable_FindSymbol(symbolTable, "Hey", 3)); + SymbolTable_SetSymbol(symbolTable, "Hey", "You"); + STRCMP_EQUAL("You", SymbolTable_FindSymbol(symbolTable, "Hey", 3)); } TEST(SymbolTable, CanGetLengthOfSymbol) { - SymbolTable_SetSymbol(symbolTable, "Hey", "1234567890"); - LONGS_EQUAL(10, SymbolTable_GetSymbolLength(symbolTable, "Hey", 3)); + SymbolTable_SetSymbol(symbolTable, "Hey", "1234567890"); + LONGS_EQUAL(10, SymbolTable_GetSymbolLength(symbolTable, "Hey", 3)); } TEST(SymbolTable, CanGetLengthOfNonExistentSymbol) { - LONGS_EQUAL(-1, SymbolTable_GetSymbolLength(symbolTable, "Hey", 3)); + LONGS_EQUAL(-1, SymbolTable_GetSymbolLength(symbolTable, "Hey", 3)); } - diff --git a/tests/CSlim/TestSlim.c b/tests/CSlim/TestSlim.c index 0841d79..45f0ddb 100644 --- a/tests/CSlim/TestSlim.c +++ b/tests/CSlim/TestSlim.c @@ -1,115 +1,127 @@ #include "TestSlim.h" +#include "compatibility.h" +#include #include #include -#include -#include "compatibility.h" //static local variables struct TestSlim { - int noArgsCalled; - const char* arg; - char constructionArg[50]; - char echoBuf[50]; + int noArgsCalled; + const char* arg; + char constructionArg[50]; + char echoBuf[50]; }; void* TestSlim_Create(StatementExecutor* executor, SlimList* args) { - if (SlimList_GetLength(args) > 1) { - StatementExecutor_ConstructorError(executor, "xxx"); - return NULL; - } + if (SlimList_GetLength(args) > 1) + { + StatementExecutor_ConstructorError(executor, "xxx"); + return NULL; + } - TestSlim* self = (TestSlim*)malloc(sizeof(TestSlim)); - memset(self, 0, sizeof(TestSlim)); + TestSlim* self = (TestSlim*)malloc(sizeof(TestSlim)); + memset(self, 0, sizeof(TestSlim)); - if (SlimList_GetLength(args) == 1) - strncpy(self->constructionArg, SlimList_GetStringAt(args, 0), 50); + if (SlimList_GetLength(args) == 1) + strncpy(self->constructionArg, SlimList_GetStringAt(args, 0), 50); - return self; + return self; } void TestSlim_Destroy(void* self) { - free(self); + free(self); } -int TestSlim_noArgsCalled(TestSlim* executor) { - return executor->noArgsCalled; +int TestSlim_noArgsCalled(TestSlim* executor) +{ + return executor->noArgsCalled; } -static const char* noArgs(void* self, SlimList* args) { - TestSlim* me = (TestSlim*)self; - me->noArgsCalled = 1; - return "/__VOID__/"; +static const char* noArgs(void* self, SlimList* args) +{ + TestSlim* me = (TestSlim*)self; + me->noArgsCalled = 1; + return "/__VOID__/"; } -static const char* returnValue(void* self, SlimList* args) { - return "value"; +static const char* returnValue(void* self, SlimList* args) +{ + return "value"; } -static const char* oneArg(void* self, SlimList* args) { - const char * value = SlimList_GetStringAt(args, 0); - return value; +static const char* oneArg(void* self, SlimList* args) +{ + const char* value = SlimList_GetStringAt(args, 0); + return value; } -static const char* add(void* self, SlimList* args) { - static char buf[50]; - snprintf(buf, 50, "%s%s", SlimList_GetStringAt(args, 0), SlimList_GetStringAt(args, 1)); - return buf; +static const char* add(void* self, SlimList* args) +{ + static char buf[50]; + snprintf(buf, 50, "%s%s", SlimList_GetStringAt(args, 0), SlimList_GetStringAt(args, 1)); + return buf; } -static const char* null(void* self, SlimList* args) { - return NULL; +static const char* null(void* self, SlimList* args) +{ + return NULL; } -static const char* setArg(void* self, SlimList* args) { - TestSlim* me = (TestSlim*)self; - me->arg = SlimList_GetStringAt(args, 0); - return "/__VOID__/"; +static const char* setArg(void* self, SlimList* args) +{ + TestSlim* me = (TestSlim*)self; + me->arg = SlimList_GetStringAt(args, 0); + return "/__VOID__/"; } -static const char* getArg(void* self, SlimList* args) { - TestSlim* me = (TestSlim*)self; - return me->arg; +static const char* getArg(void* self, SlimList* args) +{ + TestSlim* me = (TestSlim*)self; + return me->arg; } -static const char* getArg_From_Function_With_Underscores(void* self, SlimList* args) { - TestSlim* me = (TestSlim*)self; - return me->arg; +static const char* getArg_From_Function_With_Underscores(void* self, SlimList* args) +{ + TestSlim* me = (TestSlim*)self; + return me->arg; } -static const char* getConstructionArg(void* self, SlimList* args) { - TestSlim* me = (TestSlim*)self; - return me->constructionArg; +static const char* getConstructionArg(void* self, SlimList* args) +{ + TestSlim* me = (TestSlim*)self; + return me->constructionArg; } -static const char* returnError(void* self, SlimList* args) { - return StatementExecutor_FixtureError("my exception"); +static const char* returnError(void* self, SlimList* args) +{ + return StatementExecutor_FixtureError("my exception"); } void TestSlim_Register(StatementExecutor* executor) { - StatementExecutor_RegisterFixture(executor, "TestSlim", TestSlim_Create, TestSlim_Destroy); - StatementExecutor_RegisterMethod(executor, "TestSlim", "returnValue", returnValue); - StatementExecutor_RegisterMethod(executor, "TestSlim", "noArgs", noArgs); - StatementExecutor_RegisterMethod(executor, "TestSlim", "echo", oneArg); - StatementExecutor_RegisterMethod(executor, "TestSlim", "add", add); - StatementExecutor_RegisterMethod(executor, "TestSlim", "null", null); - StatementExecutor_RegisterMethod(executor, "TestSlim", "setArg", setArg); - StatementExecutor_RegisterMethod(executor, "TestSlim", "getArg", getArg); - StatementExecutor_RegisterMethod(executor, "TestSlim", "getArg_From_Function_With_Underscores", getArg_From_Function_With_Underscores); - StatementExecutor_RegisterMethod(executor, "TestSlim", "getConstructionArg", getConstructionArg); - StatementExecutor_RegisterMethod(executor, "TestSlim", "returnError", returnError); - - - StatementExecutor_RegisterFixture(executor, "TestSlimAgain", TestSlim_Create, TestSlim_Destroy); - StatementExecutor_RegisterMethod(executor, "TestSlimAgain", "setArgAgain", setArg); - StatementExecutor_RegisterMethod(executor, "TestSlimAgain", "getArgAgain", getArg); - - StatementExecutor_RegisterMethod(executor, "TestSlimDeclaredLate", "echo", oneArg); - StatementExecutor_RegisterFixture(executor, "TestSlimDeclaredLate", TestSlim_Create, TestSlim_Destroy); - - StatementExecutor_RegisterMethod(executor, "TestSlimUndeclared", "echo", oneArg); + StatementExecutor_RegisterFixture(executor, "TestSlim", TestSlim_Create, TestSlim_Destroy); + StatementExecutor_RegisterMethod(executor, "TestSlim", "returnValue", returnValue); + StatementExecutor_RegisterMethod(executor, "TestSlim", "noArgs", noArgs); + StatementExecutor_RegisterMethod(executor, "TestSlim", "echo", oneArg); + StatementExecutor_RegisterMethod(executor, "TestSlim", "add", add); + StatementExecutor_RegisterMethod(executor, "TestSlim", "null", null); + StatementExecutor_RegisterMethod(executor, "TestSlim", "setArg", setArg); + StatementExecutor_RegisterMethod(executor, "TestSlim", "getArg", getArg); + StatementExecutor_RegisterMethod(executor, "TestSlim", "getArg_From_Function_With_Underscores", + getArg_From_Function_With_Underscores); + StatementExecutor_RegisterMethod(executor, "TestSlim", "getConstructionArg", getConstructionArg); + StatementExecutor_RegisterMethod(executor, "TestSlim", "returnError", returnError); + + StatementExecutor_RegisterFixture(executor, "TestSlimAgain", TestSlim_Create, TestSlim_Destroy); + StatementExecutor_RegisterMethod(executor, "TestSlimAgain", "setArgAgain", setArg); + StatementExecutor_RegisterMethod(executor, "TestSlimAgain", "getArgAgain", getArg); + + StatementExecutor_RegisterMethod(executor, "TestSlimDeclaredLate", "echo", oneArg); + StatementExecutor_RegisterFixture(executor, "TestSlimDeclaredLate", TestSlim_Create, + TestSlim_Destroy); + + StatementExecutor_RegisterMethod(executor, "TestSlimUndeclared", "echo", oneArg); } - diff --git a/tests/CSlim/TestSlim.h b/tests/CSlim/TestSlim.h index 82cacb8..193b502 100644 --- a/tests/CSlim/TestSlim.h +++ b/tests/CSlim/TestSlim.h @@ -17,8 +17,8 @@ typedef struct TestSlim TestSlim; // #include "SlimList.h" void* TestSlim_Create(StatementExecutor* executor, SlimList* args); -void TestSlim_Destroy(void*); -void TestSlim_Register(StatementExecutor*); +void TestSlim_Destroy(void*); +void TestSlim_Register(StatementExecutor*); int TestSlim_noArgsCalled(TestSlim* executor); @@ -28,4 +28,4 @@ int TestSlim_noArgsCalled(TestSlim* executor); #endif #endif -#endif // D_TestSlim_H +#endif // D_TestSlim_H diff --git a/tests/ObjectiveC/TestSlim.h b/tests/ObjectiveC/TestSlim.h index df3d247..df69a6b 100644 --- a/tests/ObjectiveC/TestSlim.h +++ b/tests/ObjectiveC/TestSlim.h @@ -1,25 +1,26 @@ #import -@interface TestSlim : NSObject { - BOOL wasNoArgsCalled; - NSString* calledWithStringArg; - NSNumber* calledWithNSNumberArg; +@interface TestSlim : NSObject +{ + BOOL wasNoArgsCalled; + NSString* calledWithStringArg; + NSNumber* calledWithNSNumberArg; } -@property (assign) BOOL wasNoArgsCalled; -@property (nonatomic, retain) NSString* calledWithStringArg; -@property (nonatomic, retain) NSNumber* calledWithNSNumberArg; -@property (nonatomic, retain) NSString* calledWithFirstStringArg; -@property (nonatomic, retain) NSString* calledWithSecondStringArg; +@property(assign) BOOL wasNoArgsCalled; +@property(nonatomic, retain) NSString* calledWithStringArg; +@property(nonatomic, retain) NSNumber* calledWithNSNumberArg; +@property(nonatomic, retain) NSString* calledWithFirstStringArg; +@property(nonatomic, retain) NSString* calledWithSecondStringArg; --(id) initWithString: (NSString*) givenString; --(id) initWithArray: (NSArray*) givenArray; +- (id)initWithString:(NSString*)givenString; +- (id)initWithArray:(NSArray*)givenArray; --(NSString*) noArgs; --(NSString*) withStringArg:(NSString*) someString; --(void) withNSNumberArg:(NSNumber*) someNSNumber; --(NSString*) withMultipleArgs:(NSArray*) args; --(NSString*) createTestSlimWithString: (NSString*) givenString; +- (NSString*)noArgs; +- (NSString*)withStringArg:(NSString*)someString; +- (void)withNSNumberArg:(NSNumber*)someNSNumber; +- (NSString*)withMultipleArgs:(NSArray*)args; +- (NSString*)createTestSlimWithString:(NSString*)givenString; --(NSNumber*) returnsNSNumber; +- (NSNumber*)returnsNSNumber; @end diff --git a/tests/ObjectiveC/TestSlimTwo.h b/tests/ObjectiveC/TestSlimTwo.h index 14ad743..0bdf740 100644 --- a/tests/ObjectiveC/TestSlimTwo.h +++ b/tests/ObjectiveC/TestSlimTwo.h @@ -1,7 +1,7 @@ #import -@interface TestSlimTwo : NSObject { - +@interface TestSlimTwo : NSObject +{ } @end