GAT Documentation

00001 /** @file GATTable_tests.c
00002  *  Source file for the GATTable_tests class.
00003  *
00004  *  @date Sun Nov 2 2003
00005  *
00006  *  @version $Header: /export/cvs-gridlab/wp-1/Codes/GATEngine/C-reference/test/internal/GATTable_tests.c,v 1.16 2004/04/20 17:04:43 hartmutkaiser Exp $
00007  *
00008  *  Copyright (C) Hartmut Kaiser
00009  *  This file is part of the GAT Engine.
00010  *  Contributed by Hartmut Kaiser <hartmutkaiser [at] t-online [dot] de>.
00011  *
00012  *  Use, modification and distribution is subject to the Gridlab Software
00013  *  License. (See accompanying file GLlicense.txt or copy at
00014  *  http://www.gridlab.org/GLlicense.txt)
00015  */
00016  
00017 static const char *rcsid = "$Header: /export/cvs-gridlab/wp-1/Codes/GATEngine/C-reference/test/internal/GATTable_tests.c,v 1.16 2004/04/20 17:04:43 hartmutkaiser Exp $";
00018 
00019 #include <string.h>
00020 
00021 #include "GAT.h"
00022 #include "GATString.h"
00023 #include "GATMemoryStream.h"
00024 
00025 #include "GATTestUtils.h"
00026 
00027 static char const *key_values[] = {
00028   "short value", 
00029   "int value", 
00030   "float value", 
00031   "double value", 
00032   "string value", 
00033   "object value"
00034 };
00035 
00036 #define _countof(x) (sizeof(x)/sizeof(x[0]))
00037 
00038 /* local function declarations */
00039 static GATTable fill_GATTable(void);
00040 static void test_GATTable_Entries(GATTable_const table);
00041 static void test_GATTable_Cloning(GATTable_const table);
00042 static void test_GATTable_Serialising(GATContext context, GATTable table);
00043 
00044 static void test_positives(GATTable_const table);
00045 static void test_entry_types(GATTable_const table);
00046 
00047 static void test_negatives_short(GATTable_const table);
00048 static void test_negatives_int(GATTable_const table);
00049 static void test_negatives_float(GATTable_const table);
00050 static void test_negatives_double(GATTable_const table);
00051 static void test_negatives_string(GATTable_const table);
00052 static void test_negatives_object(GATTable_const table);
00053 
00054 static void test_remove_short(GATTable_const table);
00055 static void test_remove_int(GATTable_const table);
00056 static void test_remove_float(GATTable_const table);
00057 static void test_remove_double(GATTable_const table);
00058 static void test_remove_string(GATTable_const table);
00059 static void test_remove_object(GATTable_const table);
00060 static void test_remove_unknown(GATTable_const table);
00061 
00062 /* test the positives */
00063 static void
00064 test_positives(GATTable_const table)
00065 {
00066   int retval = GAT_FAIL;
00067   short short_data = 0;
00068   int int_data = 0;
00069   float float_data = 0.f;
00070   double double_data = 0;
00071   char string_data[32] = { 0 };
00072   GATObject object = NULL;
00073   char const *string_value = NULL;
00074   
00075   GAT_TEST_START ("test get status");
00076 
00077   retval = GATTable_Get_short(table, "short value", &short_data);
00078   GAT_TEST(GAT_SUCCEEDED(retval) && 1 == short_data);
00079 
00080   retval = GATTable_Get_int(table, "int value", &int_data);
00081   GAT_TEST(GAT_SUCCEEDED(retval) && 2 == int_data);
00082 
00083   retval = GATTable_Get_float(table, "float value", &float_data);
00084   GAT_TEST(GAT_SUCCEEDED(retval) && 1.5f == float_data);
00085 
00086   retval = GATTable_Get_double(table, "double value", &double_data);
00087   GAT_TEST(GAT_SUCCEEDED(retval) && 2.5 == double_data);
00088 
00089   retval = GATTable_Get_String(table, "string value", string_data, 
00090     sizeof(string_data));
00091   GAT_TEST(strlen("sample") == (size_t)retval && !strcmp("sample", string_data));
00092 
00093   retval = GATTable_Get_GATObject(table, "object value", &object);
00094   GAT_TEST(GAT_SUCCEEDED(retval) && NULL != object && 
00095     GATType_GATString == GATObject_GetType(object));
00096   string_value = GATString_GetBuffer(GATObject_ToGATString(object));
00097   GAT_TEST(NULL != string_value && !strcmp(string_value, "sample string object"));
00098 
00099   GAT_TEST_STOP ();
00100 }
00101 
00102 static void
00103 test_entry_types(GATTable_const table)
00104 {
00105   GATType type = GATType_NoType;
00106   
00107   GAT_TEST_START ("test entry types");
00108 
00109   type = GATTable_Get_ElementType(table, "short value");
00110   GAT_TEST(GATType_GATint16 == type);
00111   
00112   type = GATTable_Get_ElementType(table, "int value");
00113   GAT_TEST(GATType_GATint32 == type);
00114   
00115   type = GATTable_Get_ElementType(table, "float value");
00116   GAT_TEST(GATType_GATfloat32 == type);
00117   
00118   type = GATTable_Get_ElementType(table, "double value");
00119   GAT_TEST(GATType_GATdouble64 == type);
00120   
00121   type = GATTable_Get_ElementType(table, "string value");
00122   GAT_TEST(GATType_String == type);
00123   
00124   type = GATTable_Get_ElementType(table, "object value");
00125   GAT_TEST(GATType_GATObject == type);  
00126   
00127   type = GATTable_Get_ElementType(table, "unknown value");
00128   GAT_TEST(GATType_NoType == type);  
00129 
00130   GAT_TEST_STOP ();
00131 }
00132 
00133 /* test the negatives */
00134 static void
00135 test_negatives_short(GATTable_const table)
00136 {
00137   int retval = GAT_FAIL;
00138   short short_data = 0;
00139   int int_data = 0;
00140   float float_data = 0.f;
00141   double double_data = 0.0;
00142   char string_data[32] = { 0 };
00143   GATObject object = NULL;
00144   
00145   retval = GATTable_Get_short(table, "false short value", &short_data);
00146   GAT_TEST(GAT_KEY_NOT_FOUND == retval && 0 == short_data);
00147 
00148   retval = GATTable_Get_int(table, "short value", &int_data);
00149   GAT_TEST(GAT_KEY_TYPE_ERROR == retval && 0 == int_data);
00150 
00151   retval = GATTable_Get_float(table, "short value", &float_data);
00152   GAT_TEST(GAT_KEY_TYPE_ERROR == retval && 0.f == float_data);
00153 
00154   retval = GATTable_Get_double(table, "short value", &double_data);
00155   GAT_TEST(GAT_KEY_TYPE_ERROR == retval && 0.0 == double_data);
00156 
00157   retval = GATTable_Get_String(table, "short value", string_data, 
00158     sizeof(string_data));
00159   GAT_TEST(GAT_KEY_TYPE_ERROR == retval && '\0' == string_data[0]);
00160 
00161   retval = GATTable_Get_GATObject(table, "short value", &object);
00162   GAT_TEST(GAT_KEY_TYPE_ERROR == retval && NULL == object);
00163 }
00164 
00165 static void
00166 test_negatives_int(GATTable_const table)
00167 {
00168   int retval = GAT_FAIL;
00169   short short_data = 0;
00170   int int_data = 0;
00171   float float_data = 0.f;
00172   double double_data = 0;
00173   char string_data[32] = { 0 };
00174   GATObject object = NULL;
00175   
00176   retval = GATTable_Get_short(table, "int value", &short_data);
00177   GAT_TEST(GAT_KEY_TYPE_ERROR == retval && 0 == short_data);
00178 
00179   retval = GATTable_Get_int(table, "false int value", &int_data);
00180   GAT_TEST(GAT_KEY_NOT_FOUND == retval && 0 == int_data);
00181 
00182   retval = GATTable_Get_float(table, "int value", &float_data);
00183   GAT_TEST(GAT_KEY_TYPE_ERROR == retval && 0.f == float_data);
00184 
00185   retval = GATTable_Get_double(table, "int value", &double_data);
00186   GAT_TEST(GAT_KEY_TYPE_ERROR == retval && 0.0 == double_data);
00187 
00188   retval = GATTable_Get_String(table, "int value", string_data, 
00189     sizeof(string_data));
00190   GAT_TEST(GAT_KEY_TYPE_ERROR == retval && '\0' == string_data[0]);
00191 
00192   retval = GATTable_Get_GATObject(table, "int value", &object);
00193   GAT_TEST(GAT_KEY_TYPE_ERROR == retval && NULL == object);
00194 }
00195 
00196 static void
00197 test_negatives_float(GATTable_const table)
00198 {
00199   int retval = GAT_FAIL;
00200   short short_data = 0;
00201   int int_data = 0;
00202   float float_data = 0.f;
00203   double double_data = 0;
00204   char string_data[32] = { 0 };
00205   GATObject object = NULL;
00206   
00207   retval = GATTable_Get_short(table, "float value", &short_data);
00208   GAT_TEST(GAT_KEY_TYPE_ERROR == retval && 0 == short_data);
00209 
00210   retval = GATTable_Get_int(table, "float value", &int_data);
00211   GAT_TEST(GAT_KEY_TYPE_ERROR == retval && 0 == int_data);
00212   
00213   retval = GATTable_Get_float(table, "false float value", &float_data);
00214   GAT_TEST(GAT_KEY_NOT_FOUND == retval && 0.f == float_data);
00215   
00216   retval = GATTable_Get_double(table, "float value", &double_data);
00217   GAT_TEST(GAT_KEY_TYPE_ERROR == retval && 0.0 == double_data);
00218 
00219   retval = GATTable_Get_String(table, "float value", string_data, 
00220     sizeof(string_data));
00221   GAT_TEST(GAT_KEY_TYPE_ERROR == retval && '\0' == string_data[0]);
00222 
00223   retval = GATTable_Get_GATObject(table, "float value", &object);
00224   GAT_TEST(GAT_KEY_TYPE_ERROR == retval && NULL == object);
00225 }
00226 
00227 static void
00228 test_negatives_double(GATTable_const table)
00229 {
00230   int retval = GAT_FAIL;
00231   short short_data = 0;
00232   int int_data = 0;
00233   float float_data = 0.f;
00234   double double_data = 0;
00235   char string_data[32] = { 0 };
00236   GATObject object = NULL;
00237 
00238   retval = GATTable_Get_short(table, "double value", &short_data);
00239   GAT_TEST(GAT_KEY_TYPE_ERROR == retval && 0 == short_data);
00240 
00241   retval = GATTable_Get_int(table, "double value", &int_data);
00242   GAT_TEST(GAT_KEY_TYPE_ERROR == retval && 0 == int_data);
00243 
00244   retval = GATTable_Get_float(table, "double value", &float_data);
00245   GAT_TEST(GAT_KEY_TYPE_ERROR == retval && 0.f == float_data);
00246 
00247   retval = GATTable_Get_double(table, "false double value", &double_data);
00248   GAT_TEST(GAT_KEY_NOT_FOUND == retval && 0.0 == double_data);
00249 
00250   retval = GATTable_Get_String(table, "double value", string_data, 
00251     sizeof(string_data));
00252   GAT_TEST(GAT_KEY_TYPE_ERROR == retval && '\0' == string_data[0]);
00253 
00254   retval = GATTable_Get_GATObject(table, "double value", &object);
00255   GAT_TEST(GAT_KEY_TYPE_ERROR == retval && NULL == object);
00256 }
00257 
00258 static void
00259 test_negatives_string(GATTable_const table)
00260 {
00261   int retval = GAT_FAIL;
00262   short short_data = 0;
00263   int int_data = 0;
00264   float float_data = 0.f;
00265   double double_data = 0;
00266   char string_data[32] = { 0 };
00267   GATObject object = NULL;
00268 
00269   retval = GATTable_Get_short(table, "string value", &short_data);
00270   GAT_TEST(GAT_KEY_TYPE_ERROR == retval && 0 == short_data);
00271 
00272   retval = GATTable_Get_int(table, "string value", &int_data);
00273   GAT_TEST(GAT_KEY_TYPE_ERROR == retval && 0 == int_data);
00274 
00275   retval = GATTable_Get_float(table, "string value", &float_data);
00276   GAT_TEST(GAT_KEY_TYPE_ERROR == retval && 0.f == float_data);
00277 
00278   retval = GATTable_Get_double(table, "string value", &double_data);
00279   GAT_TEST(GAT_KEY_TYPE_ERROR == retval && 0.0 == double_data);
00280   
00281   retval = GATTable_Get_String(table, "false string value", string_data, 
00282     sizeof(string_data));
00283   GAT_TEST(GAT_KEY_NOT_FOUND == retval && '\0' == string_data[0]);
00284 
00285   retval = GATTable_Get_GATObject(table, "string value", &object);
00286   GAT_TEST(GAT_KEY_TYPE_ERROR == retval && NULL == object);
00287 }
00288 
00289 static void
00290 test_negatives_object(GATTable_const table)
00291 {
00292   int retval = GAT_FAIL;
00293   short short_data = 0;
00294   int int_data = 0;
00295   float float_data = 0.f;
00296   double double_data = 0;
00297   char string_data[32] = { 0 };
00298   GATObject object = NULL;
00299 
00300   retval = GATTable_Get_short(table, "object value", &short_data);
00301   GAT_TEST(GAT_KEY_TYPE_ERROR == retval && 0 == short_data);
00302 
00303   retval = GATTable_Get_int(table, "object value", &int_data);
00304   GAT_TEST(GAT_KEY_TYPE_ERROR == retval && 0 == int_data);
00305 
00306   retval = GATTable_Get_float(table, "object value", &float_data);
00307   GAT_TEST(GAT_KEY_TYPE_ERROR == retval && 0.f == float_data);
00308 
00309   retval = GATTable_Get_double(table, "object value", &double_data);
00310   GAT_TEST(GAT_KEY_TYPE_ERROR == retval && 0.0 == double_data);
00311 
00312   retval = GATTable_Get_String(table, "object value", string_data, 
00313     sizeof(string_data));
00314   GAT_TEST(GAT_KEY_TYPE_ERROR == retval && '\0' == string_data[0]);
00315 
00316   retval = GATTable_Get_GATObject(table, "false object value", &object);
00317   GAT_TEST(GAT_KEY_NOT_FOUND == retval && NULL == object);
00318 }
00319 
00320 static GATTable 
00321 fill_GATTable(void)
00322 {
00323   int retval = GAT_FAIL;
00324   GATTable table = GATTable_Create();
00325   char const *sample_string = "sample string object";
00326   GATString string = 
00327     GATString_Create(sample_string, (GATuint32)strlen(sample_string)+1, "ASCII");
00328   GATuint32 count = 0;
00329   
00330   GAT_TEST(NULL != table);
00331   GAT_TEST(NULL != string);
00332   
00333   /* add some key value pairs, one for each possible type */
00334   retval = GATTable_Add_short(table, "short value", 1);
00335   GAT_TEST(GAT_SUCCEEDED(retval));
00336   retval = GATTable_Add_int(table, "int value", 2);
00337   GAT_TEST(GAT_SUCCEEDED(retval));
00338   retval = GATTable_Add_float(table, "float value", 1.5f);
00339   GAT_TEST(GAT_SUCCEEDED(retval));
00340   retval = GATTable_Add_double(table, "double value", 2.5);
00341   GAT_TEST(GAT_SUCCEEDED(retval));
00342   retval = GATTable_Add_String(table, "string value", "sample");
00343   GAT_TEST(GAT_SUCCEEDED(retval));
00344   retval = GATTable_Add_GATObject(table, "object value", 
00345     GATString_ToGATObject(string));
00346   GAT_TEST(GAT_SUCCEEDED(retval));
00347   
00348   /* ensure, that a key may be added only once */
00349   retval = GATTable_Add_short(table, "short value", 1);
00350   GAT_TEST(GAT_KEY_ALREADY_EXISTS == retval);
00351   retval = GATTable_Add_int(table, "int value", 2);
00352   GAT_TEST(GAT_KEY_ALREADY_EXISTS == retval);
00353   retval = GATTable_Add_float(table, "float value", 1.5f);
00354   GAT_TEST(GAT_KEY_ALREADY_EXISTS == retval);
00355   retval = GATTable_Add_double(table, "double value", 2.5);
00356   GAT_TEST(GAT_KEY_ALREADY_EXISTS == retval);
00357   retval = GATTable_Add_String(table, "string value", "sample");
00358   GAT_TEST(GAT_KEY_ALREADY_EXISTS == retval);
00359   retval = GATTable_Add_GATObject(table, "object value", 
00360     GATString_ToGATObject(string));
00361   GAT_TEST(GAT_KEY_ALREADY_EXISTS == retval);
00362 
00363   /* verify GATTable_GetKeys function */
00364   {
00365     void **keys = GATTable_GetKeys(table);
00366     void **loopvar = keys;
00367     GATuint32 i = 0, j =0;
00368     
00369     for (/**/; NULL != *loopvar; ++loopvar, ++i)
00370     {
00371       char const *key = (char const *)(*loopvar);
00372       for (j = 0; j < _countof(key_values); ++j)
00373       {
00374         if (!strcmp(key, key_values[j]))
00375         {
00376           break;  /* found key value */
00377         }
00378       }
00379       free(*loopvar);
00380       GAT_TEST(j < _countof(key_values));
00381     }
00382     free(keys);
00383     GAT_TEST(i == _countof(key_values));
00384   }
00385   
00386   count = GATTable_Size(table);
00387   GAT_TEST(count == _countof(key_values));
00388   
00389   GATString_Destroy(&string);
00390   return table;
00391 }
00392 
00393 /* verify removing an element */
00394 static void
00395 test_remove_short(GATTable_const table)
00396 {
00397   GATTable cloned_table = NULL;
00398   int retval = GAT_FAIL;
00399   
00400   retval = GATTable_Clone(table, &cloned_table);
00401   GAT_TEST(GAT_SUCCEEDED(retval));
00402 
00403   retval = GATTable_Remove(cloned_table, "short value");
00404   GAT_TEST(GAT_SUCCEEDED(retval));
00405 
00406   {
00407     short short_data = 0;
00408     int int_data = 0;
00409     float float_data = 0.f;
00410     double double_data = 0;
00411     char string_data[32] = { 0 };
00412     GATObject object = NULL;
00413     char const *string_value = NULL;
00414     
00415     retval = GATTable_Get_short(cloned_table, "short value", &short_data);
00416     GAT_TEST(GAT_KEY_NOT_FOUND == retval && 0 == short_data);
00417 
00418     retval = GATTable_Get_int(cloned_table, "int value", &int_data);
00419     GAT_TEST(GAT_SUCCEEDED(retval) && 2 == int_data);
00420 
00421     retval = GATTable_Get_float(cloned_table, "float value", &float_data);
00422     GAT_TEST(GAT_SUCCEEDED(retval) && 1.5f == float_data);
00423 
00424     retval = GATTable_Get_double(cloned_table, "double value", &double_data);
00425     GAT_TEST(GAT_SUCCEEDED(retval) && 2.5 == double_data);
00426 
00427     retval = GATTable_Get_String(cloned_table, "string value", string_data, 
00428       sizeof(string_data));
00429     GAT_TEST(strlen("sample") == (size_t)retval && 
00430       !strcmp("sample", string_data));
00431 
00432     retval = GATTable_Get_GATObject(cloned_table, "object value", &object);
00433     GAT_TEST(GAT_SUCCEEDED(retval) && NULL != object && 
00434       GATType_GATString == GATObject_GetType(object));
00435     string_value = GATString_GetBuffer(GATObject_ToGATString(object));
00436     GAT_TEST(NULL != string_value && 
00437       !strcmp(string_value, "sample string object"));
00438   }
00439   
00440   GATTable_Destroy(&cloned_table);
00441 }
00442 
00443 static void
00444 test_remove_int(GATTable_const table)
00445 {
00446   GATTable cloned_table = NULL;
00447   int retval = GAT_FAIL;
00448   
00449   retval = GATTable_Clone(table, &cloned_table);
00450   GAT_TEST(GAT_SUCCEEDED(retval));
00451 
00452   retval = GATTable_Remove(cloned_table, "int value");
00453   GAT_TEST(GAT_SUCCEEDED(retval));
00454 
00455   {
00456     short short_data = 0;
00457     int int_data = 0;
00458     float float_data = 0.f;
00459     double double_data = 0;
00460     char string_data[32] = { 0 };
00461     GATObject object = NULL;
00462     char const *string_value = NULL;
00463     
00464     retval = GATTable_Get_short(cloned_table, "short value", &short_data);
00465     GAT_TEST(GAT_SUCCEEDED(retval) && 1 == short_data);
00466 
00467     retval = GATTable_Get_int(cloned_table, "int value", &int_data);
00468     GAT_TEST(GAT_KEY_NOT_FOUND == retval && 0 == int_data);
00469 
00470     retval = GATTable_Get_float(cloned_table, "float value", &float_data);
00471     GAT_TEST(GAT_SUCCEEDED(retval) && 1.5f == float_data);
00472 
00473     retval = GATTable_Get_double(cloned_table, "double value", &double_data);
00474     GAT_TEST(GAT_SUCCEEDED(retval) && 2.5 == double_data);
00475 
00476     retval = GATTable_Get_String(cloned_table, "string value", string_data, 
00477       sizeof(string_data));
00478     GAT_TEST(strlen("sample") == (size_t)retval && 
00479       !strcmp("sample", string_data));
00480 
00481     retval = GATTable_Get_GATObject(cloned_table, "object value", &object);
00482     GAT_TEST(GAT_SUCCEEDED(retval) && NULL != object && 
00483       GATType_GATString == GATObject_GetType(object));
00484     string_value = GATString_GetBuffer(GATObject_ToGATString(object));
00485     GAT_TEST(NULL != string_value && 
00486       !strcmp(string_value, "sample string object"));
00487   }
00488   
00489   GATTable_Destroy(&cloned_table);
00490 }
00491 
00492 static void
00493 test_remove_float(GATTable_const table)
00494 {
00495   GATTable cloned_table = NULL;
00496   int retval = GAT_FAIL;
00497   
00498   retval = GATTable_Clone(table, &cloned_table);
00499   GAT_TEST(GAT_SUCCEEDED(retval));
00500 
00501   retval = GATTable_Remove(cloned_table, "float value");
00502   GAT_TEST(GAT_SUCCEEDED(retval));
00503 
00504   {
00505     short short_data = 0;
00506     int int_data = 0;
00507     float float_data = 0.f;
00508     double double_data = 0;
00509     char string_data[32] = { 0 };
00510     GATObject object = NULL;
00511     char const *string_value = NULL;
00512     
00513     retval = GATTable_Get_short(cloned_table, "short value", &short_data);
00514     GAT_TEST(GAT_SUCCEEDED(retval) && 1 == short_data);
00515 
00516     retval = GATTable_Get_int(cloned_table, "int value", &int_data);
00517     GAT_TEST(GAT_SUCCEEDED(retval) && 2 == int_data);
00518 
00519     retval = GATTable_Get_float(cloned_table, "float value", &float_data);
00520     GAT_TEST(GAT_KEY_NOT_FOUND == retval && 0.f == float_data);
00521 
00522     retval = GATTable_Get_double(cloned_table, "double value", &double_data);
00523     GAT_TEST(GAT_SUCCEEDED(retval) && 2.5 == double_data);
00524 
00525     retval = GATTable_Get_String(cloned_table, "string value", string_data, 
00526       sizeof(string_data));
00527     GAT_TEST(strlen("sample") == (size_t)retval && 
00528       !strcmp("sample", string_data));
00529 
00530     retval = GATTable_Get_GATObject(cloned_table, "object value", &object);
00531     GAT_TEST(GAT_SUCCEEDED(retval) && NULL != object && 
00532       GATType_GATString == GATObject_GetType(object));
00533     string_value = GATString_GetBuffer(GATObject_ToGATString(object));
00534     GAT_TEST(NULL != string_value && 
00535       !strcmp(string_value, "sample string object"));
00536   }
00537   
00538   GATTable_Destroy(&cloned_table);
00539 }
00540 
00541 static void
00542 test_remove_double(GATTable_const table)
00543 {
00544   GATTable cloned_table = NULL;
00545   int retval = GAT_FAIL;
00546   
00547   retval = GATTable_Clone(table, &cloned_table);
00548   GAT_TEST(GAT_SUCCEEDED(retval));
00549 
00550   retval = GATTable_Remove(cloned_table, "double value");
00551   GAT_TEST(GAT_SUCCEEDED(retval));
00552 
00553   {
00554     short short_data = 0;
00555     int int_data = 0;
00556     float float_data = 0.f;
00557     double double_data = 0;
00558     char string_data[32] = { 0 };
00559     GATObject object = NULL;
00560     char const *string_value = NULL;
00561     
00562     retval = GATTable_Get_short(cloned_table, "short value", &short_data);
00563     GAT_TEST(GAT_SUCCEEDED(retval) && 1 == short_data);
00564 
00565     retval = GATTable_Get_int(cloned_table, "int value", &int_data);
00566     GAT_TEST(GAT_SUCCEEDED(retval) && 2 == int_data);
00567 
00568     retval = GATTable_Get_float(cloned_table, "float value", &float_data);
00569     GAT_TEST(GAT_SUCCEEDED(retval) && 1.5f == float_data);
00570 
00571     retval = GATTable_Get_double(cloned_table, "double value", &double_data);
00572     GAT_TEST(GAT_KEY_NOT_FOUND == retval && 0.0 == double_data);
00573 
00574     retval = GATTable_Get_String(cloned_table, "string value", string_data, 
00575       sizeof(string_data));
00576     GAT_TEST(strlen("sample") == (size_t)retval && 
00577       !strcmp("sample", string_data));
00578 
00579     retval = GATTable_Get_GATObject(cloned_table, "object value", &object);
00580     GAT_TEST(GAT_SUCCEEDED(retval) && NULL != object && 
00581       GATType_GATString == GATObject_GetType(object));
00582     string_value = GATString_GetBuffer(GATObject_ToGATString(object));
00583     GAT_TEST(NULL != string_value && 
00584       !strcmp(string_value, "sample string object"));
00585   }
00586   
00587   GATTable_Destroy(&cloned_table);
00588 }
00589 
00590 static void
00591 test_remove_string(GATTable_const table)
00592 {
00593   GATTable cloned_table = NULL;
00594   int retval = GAT_FAIL;
00595   
00596   retval = GATTable_Clone(table, &cloned_table);
00597   GAT_TEST(GAT_SUCCEEDED(retval));
00598 
00599   retval = GATTable_Remove(cloned_table, "string value");
00600   GAT_TEST(GAT_SUCCEEDED(retval));
00601 
00602   {
00603     short short_data = 0;
00604     int int_data = 0;
00605     float float_data = 0.f;
00606     double double_data = 0;
00607     char string_data[32] = { 0 };
00608     GATObject object = NULL;
00609     char const *string_value = NULL;
00610     
00611     retval = GATTable_Get_short(cloned_table, "short value", &short_data);
00612     GAT_TEST(GAT_SUCCEEDED(retval) && 1 == short_data);
00613 
00614     retval = GATTable_Get_int(cloned_table, "int value", &int_data);
00615     GAT_TEST(GAT_SUCCEEDED(retval) && 2 == int_data);
00616 
00617     retval = GATTable_Get_float(cloned_table, "float value", &float_data);
00618     GAT_TEST(GAT_SUCCEEDED(retval) && 1.5f == float_data);
00619 
00620     retval = GATTable_Get_double(cloned_table, "double value", &double_data);
00621     GAT_TEST(GAT_SUCCEEDED(retval) && 2.5 == double_data);
00622 
00623     retval = GATTable_Get_String(cloned_table, "string value", string_data, 
00624       sizeof(string_data));
00625     GAT_TEST(GAT_KEY_NOT_FOUND == retval && '\0' == string_data[0]);
00626 
00627     retval = GATTable_Get_GATObject(cloned_table, "object value", &object);
00628     GAT_TEST(GAT_SUCCEEDED(retval) && NULL != object && 
00629       GATType_GATString == GATObject_GetType(object));
00630     string_value = GATString_GetBuffer(GATObject_ToGATString(object));
00631     GAT_TEST(NULL != string_value && 
00632       !strcmp(string_value, "sample string object"));
00633   }
00634   
00635   GATTable_Destroy(&cloned_table);
00636 }
00637 
00638 static void
00639 test_remove_object(GATTable_const table)
00640 {
00641   GATTable cloned_table = NULL;
00642   int retval = GAT_FAIL;
00643   
00644   retval = GATTable_Clone(table, &cloned_table);
00645   GAT_TEST(GAT_SUCCEEDED(retval));
00646 
00647   retval = GATTable_Remove(cloned_table, "object value");
00648   GAT_TEST(GAT_SUCCEEDED(retval));
00649 
00650   {
00651     short short_data = 0;
00652     int int_data = 0;
00653     float float_data = 0.f;
00654     double double_data = 0;
00655     char string_data[32];
00656     GATObject object = NULL;
00657     
00658     retval = GATTable_Get_short(cloned_table, "short value", &short_data);
00659     GAT_TEST(GAT_SUCCEEDED(retval) && 1 == short_data);
00660 
00661     retval = GATTable_Get_int(cloned_table, "int value", &int_data);
00662     GAT_TEST(GAT_SUCCEEDED(retval) && 2 == int_data);
00663 
00664     retval = GATTable_Get_float(cloned_table, "float value", &float_data);
00665     GAT_TEST(GAT_SUCCEEDED(retval) && 1.5f == float_data);
00666 
00667     retval = GATTable_Get_double(cloned_table, "double value", &double_data);
00668     GAT_TEST(GAT_SUCCEEDED(retval) && 2.5 == double_data);
00669 
00670     retval = GATTable_Get_String(cloned_table, "string value", string_data, 
00671       sizeof(string_data));
00672     GAT_TEST(strlen("sample") == (size_t)retval && 
00673       !strcmp("sample", string_data));
00674 
00675     retval = GATTable_Get_GATObject(cloned_table, "object value", &object);
00676     GAT_TEST(GAT_KEY_NOT_FOUND == retval && NULL == object);
00677   }
00678   
00679   GATTable_Destroy(&cloned_table);
00680 }
00681 
00682 static void
00683 test_remove_unknown(GATTable_const table)
00684 {
00685   GATTable cloned_table = NULL;
00686   int retval = GAT_FAIL;
00687   
00688   retval = GATTable_Clone(table, &cloned_table);
00689   GAT_TEST(GAT_SUCCEEDED(retval));
00690 
00691   retval = GATTable_Remove(cloned_table, "unknown value");
00692   GAT_TEST(GAT_KEY_NOT_FOUND == retval);
00693 
00694   {
00695     short short_data = 0;
00696     int int_data = 0;
00697     float float_data = 0.f;
00698     double double_data = 0;
00699     char string_data[32];
00700     GATObject object = NULL;
00701     char const *string_value = NULL;
00702     
00703     retval = GATTable_Get_short(cloned_table, "short value", &short_data);
00704     GAT_TEST(GAT_SUCCEEDED(retval) && 1 == short_data);
00705 
00706     retval = GATTable_Get_int(cloned_table, "int value", &int_data);
00707     GAT_TEST(GAT_SUCCEEDED(retval) && 2 == int_data);
00708 
00709     retval = GATTable_Get_float(cloned_table, "float value", &float_data);
00710     GAT_TEST(GAT_SUCCEEDED(retval) && 1.5f == float_data);
00711 
00712     retval = GATTable_Get_double(cloned_table, "double value", &double_data);
00713     GAT_TEST(GAT_SUCCEEDED(retval) && 2.5 == double_data);
00714 
00715     retval = GATTable_Get_String(cloned_table, "string value", string_data, 
00716       sizeof(string_data));
00717     GAT_TEST(strlen("sample") == (size_t)retval && 
00718       !strcmp("sample", string_data));
00719 
00720     retval = GATTable_Get_GATObject(cloned_table, "object value", &object);
00721     GAT_TEST(GAT_SUCCEEDED(retval) && NULL != object && 
00722       GATType_GATString == GATObject_GetType(object));
00723     string_value = GATString_GetBuffer(GATObject_ToGATString(object));
00724     GAT_TEST(NULL != string_value && 
00725       !strcmp(string_value, "sample string object"));
00726   }
00727   
00728   GATTable_Destroy(&cloned_table);
00729 }
00730 
00731 /* test table entry functions */
00732 static void 
00733 test_GATTable_Entries(GATTable_const table)
00734 {
00735   test_positives(table);
00736   test_entry_types(table);
00737   
00738   test_negatives_short(table);
00739   test_negatives_int(table);
00740   test_negatives_float(table);
00741   test_negatives_double(table);
00742   test_negatives_string(table);
00743   test_negatives_object(table);
00744   
00745   test_remove_short(table);
00746   test_remove_int(table);
00747   test_remove_float(table);
00748   test_remove_double(table);
00749   test_remove_string(table);
00750   test_remove_object(table);
00751 
00752   test_remove_unknown(table);
00753 }
00754 
00755 static void 
00756 test_GATTable_Cloning(GATTable_const table)
00757 {
00758   GATTable cloned_table = NULL;
00759   GATBool isequal = GATFalse;
00760   int retval = GAT_FAIL;
00761   
00762   retval = GATTable_Clone(table, &cloned_table);
00763   GAT_TEST(GAT_SUCCEEDED(retval));
00764   
00765   retval = GATTable_Equals(table, cloned_table, &isequal);
00766   GAT_TEST(GAT_SUCCEEDED(retval) && GATTrue == isequal);
00767   
00768   retval = GATTable_Remove(cloned_table, "short value");
00769   GAT_TEST(GAT_SUCCEEDED(retval));
00770   
00771   retval = GATTable_Equals(table, cloned_table, &isequal);
00772   GAT_TEST(GAT_SUCCEEDED(retval) && GATFalse == isequal);
00773   
00774   GATTable_Destroy(&cloned_table);
00775 }
00776 
00777 static void 
00778 test_GATTable_Serialising(GATContext context, GATTable table)
00779 {
00780   GATMemoryStream stream = GATMemoryStream_Create(0, 0, GATFalse);
00781   GATBool isequal = GATFalse;
00782   int retval = GAT_FAIL;
00783   
00784   /* verify direct serialising */
00785   {
00786     GATTable new_table = NULL;
00787     
00788     retval = GATTable_Serialise(table, 
00789       GATMemoryStream_ToGATObject(stream), GATFalse);
00790     GAT_TEST(GAT_SUCCEEDED(retval));
00791   
00792     retval = GATMemoryStream_Seek(stream, GATOrigin_Set, 0, 0);
00793     GAT_TEST(GAT_SUCCEEDED(retval));
00794 
00795     new_table = GATTable_DeSerialise(context, 
00796       GATMemoryStream_ToGATObject(stream), &retval);
00797     GAT_TEST(GAT_SUCCEEDED(retval) && NULL != new_table);
00798 
00799     retval = GATTable_Equals(table, new_table, &isequal);
00800     GAT_TEST(GAT_SUCCEEDED(retval) && GATTrue == isequal);
00801     
00802     GATTable_Destroy(&new_table);
00803   }
00804   
00805   /* rewind the stream */
00806   retval = GATMemoryStream_Seek(stream, GATOrigin_Set, 0, 0);
00807   GAT_TEST(GAT_SUCCEEDED(retval));
00808   
00809   /* verify generic serialising */
00810   {
00811     GATObject object = NULL;
00812     
00813     retval = GATSerialisable_Serialise(GATTable_ToGATObject(table), 
00814       GATMemoryStream_ToGATObject(stream), GATFalse);
00815     GAT_TEST(GAT_SUCCEEDED(retval));
00816   
00817     retval = GATMemoryStream_Seek(stream, GATOrigin_Set, 0, 0);
00818     GAT_TEST(GAT_SUCCEEDED(retval));
00819 
00820     object = GATSerialisable_DeSerialise(context, 
00821       GATMemoryStream_ToGATObject(stream), &retval);
00822     GAT_TEST(GAT_SUCCEEDED(retval) && NULL != object && 
00823       GATType_GATTable == GATObject_GetType(object));
00824 
00825     retval = GATTable_Equals(table, GATObject_ToGATTable(object), &isequal);
00826     GAT_TEST(GAT_SUCCEEDED(retval) && GATTrue == isequal);
00827     
00828     GATObject_Destroy(&object);
00829   }
00830   
00831   GATMemoryStream_Destroy(&stream);
00832 }
00833 
00834 /*
00835  *  main entry point for this tests
00836  */
00837 int main (void)
00838 {
00839   GATContext context = NULL;
00840   GATTable   table   = NULL;
00841   
00842   GAT_TEST_INIT (-1);
00843   GAT_TEST_SUITE("GAT Table");
00844 
00845   context = GATContext_Create();
00846   GAT_TEST(NULL != context);
00847   
00848   /* the following test makes sure, that there were no errors during the 
00849      creation of the GATContext object */
00850   GAT_TEST_TRACE(GATType_GATContext == GATContext_GetType(context), context);
00851 
00852   table   = fill_GATTable();
00853   
00854   /* verify cloning and comparing tables */
00855   test_GATTable_Cloning(table);
00856   
00857   /* verify table entry functions */
00858   test_GATTable_Entries(table);
00859   
00860   /* verify table serialisation */
00861   test_GATTable_Serialising(context, table);
00862   
00863   GATTable_Destroy(&table);
00864   GATContext_Destroy(&context);
00865 
00866   GAT_TEST_FINISH ();
00867 
00868   return 0;
00869 }