GridLab
Grid Application Toolkit

A simple API for Grid Applications
GAT

Menu



Main Page   Alphabetical List   Compound List   File List   Compound Members   File Members  

file_serialisation_tests.c

Go to the documentation of this file.
00001 /** @file file_serialisation_tests.c
00002  * Test GATFile serialisation code.
00003  * 
00004  * @date Thu Oct 28 2003
00005  * 
00006  * @version $Header: /export/cvs-gridlab/wp-1/Codes/GATEngine/C-reference/test/internal/file_serialisation_tests.c,v 1.17 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/file_serialisation_tests.c,v 1.17 2004/04/20 17:04:43 hartmutkaiser Exp $";
00018 
00019 /* System Header Files */
00020 
00021 #include <stdio.h>
00022 #include <stdlib.h>
00023 
00024 /* GAT Header Files */
00025 
00026 #include "GAT.h"
00027 #include "GATMemoryStream.h"
00028 
00029 #include "GATTestUtils.h"
00030 
00031 #define TARGET "./file_serialization_tests.target"
00032 
00033 /* Macros */
00034 
00035 /* Structures, unions and enums */
00036 
00037 /* Static function prototypes */
00038 static GATResult verify_direct_serialisation(GATContext context, GATFile file);
00039 static GATResult verify_generic_serialisation(GATContext context, GATFile file);
00040 
00041 /* File scope variables */
00042 
00043 /* External functions */
00044 
00045 int main (int argc, const char * const argv[])
00046 {
00047   GATResult   retcode = GAT_SUCCESS;
00048   GATContext  context = NULL;
00049   GATLocation target  = NULL;
00050   GATFile     file    = NULL;
00051 
00052   GAT_TEST_INIT  (-1);
00053   GAT_TEST_SUITE ("File Serialization");
00054 
00055   context = GATContext_Create();
00056   GAT_TEST(NULL != context);
00057   
00058   /* the following test makes sure, that there were no errors during the 
00059      creation of the GATContext object */
00060   GAT_TEST_TRACE(GATType_GATContext == GATContext_GetType(context), context);
00061 
00062   GAT_TEST_START ("File Serialization Tests");
00063 
00064   if (argc < 2) { target = GATLocation_Create(TARGET ); }
00065   else          { target = GATLocation_Create(argv[1]); }
00066   
00067   GAT_TEST_TRACE(NULL != target, context);
00068 
00069   file = GATFile_Create(context, target, NULL);
00070   GAT_TEST_TRACE(NULL != file, context);
00071 
00072   GAT_TEST_STOP ();
00073   
00074   /* test serialisation trough the direct GATFile functions */
00075   retcode = verify_direct_serialisation(context, file);
00076     
00077   /* test serialisation trough the generic GATObject functions */
00078   retcode = verify_generic_serialisation(context, file);
00079 
00080   GATFile_Destroy     (&file);
00081   GATLocation_Destroy (&target);
00082   GATContext_Destroy  (&context);
00083 
00084   GAT_TEST_FINISH ();
00085 
00086   return retcode;
00087 }
00088 
00089 /* Local functions */
00090 
00091 /* test serialisation trough the direct GATFile functions */
00092 static GATResult
00093 verify_direct_serialisation (GATContext context, GATFile file)
00094 {
00095   GATResult       retcode     = GAT_FAIL;
00096   GATFile         new_file    = NULL;
00097   GATMemoryStream stream      = GATMemoryStream_Create (0, 0, GATFalse);
00098   GATBool         isequal     = GATFalse;
00099   char           *buffer      = NULL;
00100   GATuint32       buffer_size = 0;
00101   GATuint32       i           = 0;
00102   
00103   GAT_TEST_START ("verify direct serialisation");
00104 
00105   retcode = GATFile_Serialise (file, GATMemoryStream_ToGATObject (stream), 
00106                                GATTrue);
00107   GAT_TEST_TRACE(retcode == GAT_SUCCESS, context);
00108 
00109   buffer = GATMemoryStream_GetBuffer (stream, &buffer_size, GATFalse);
00110   GAT_TEST_TRACE(NULL != buffer, context);
00111   GAT_TEST_TRACE(buffer_size > 0, context);
00112 
00113   /* reposition the stream */
00114   GATMemoryStream_Seek (stream, GATOrigin_Set, 0, 0);
00115   
00116   new_file = GATFile_DeSerialise (context, GATMemoryStream_ToGATObject (stream), 
00117                                   &retcode);
00118   GAT_TEST_TRACE(GAT_SUCCEEDED(retcode), context);
00119   GAT_TEST_TRACE(NULL != new_file, context);
00120   
00121   retcode = GATFile_Equals(file, new_file, &isequal);
00122   GAT_TEST_TRACE(GAT_SUCCEEDED(retcode), context);
00123   GAT_TEST_TRACE(GATTrue == isequal, context);
00124 
00125   GATFile_Destroy         (&new_file);
00126   GATMemoryStream_Destroy (&stream);
00127   
00128   GAT_TEST_TRACE(GAT_SUCCEEDED(retcode), context);
00129   
00130   GAT_TEST_STOP ();
00131   
00132   return retcode;
00133 }
00134 
00135 /* test serialisation trough the generic GATObject functions */
00136 static GATResult 
00137 verify_generic_serialisation(GATContext context, GATFile file)
00138 {
00139   GATResult       retcode     = GAT_FAIL;
00140   GATFile         new_file    = NULL;
00141   GATMemoryStream stream      = GATMemoryStream_Create (0, 0, GATFalse);
00142   GATBool         isequal     = GATFalse;
00143   char           *buffer      = NULL;
00144   GATuint32       buffer_size = 0;
00145   GATuint32       i           = 0;
00146   
00147   GAT_TEST_START("verify generic serialisation");
00148 
00149   retcode = GATSerialisable_Serialise (GATFile_ToGATObject (file), 
00150                                  GATMemoryStream_ToGATObject (stream), 
00151                                  GATTrue);
00152   GAT_TEST_TRACE(GAT_SUCCEEDED(retcode), context);
00153 
00154   buffer = GATMemoryStream_GetBuffer(stream, &buffer_size, GATFalse);
00155   GAT_TEST_TRACE(NULL != buffer, context);
00156   GAT_TEST_TRACE(buffer_size > 0, context);
00157 
00158   /* reposition the stream */
00159   GATMemoryStream_Seek(stream, GATOrigin_Set, 0, 0);
00160   
00161   new_file = GATObject_ToGATFile (GATSerialisable_DeSerialise (context, 
00162                                                          GATMemoryStream_ToGATObject (stream), 
00163                                                          &retcode));
00164   GAT_TEST_TRACE(GAT_SUCCEEDED(retcode), context);
00165   GAT_TEST_TRACE(NULL != new_file, context);
00166 
00167   retcode = GATFile_Equals(file, new_file, &isequal);
00168   GAT_TEST_TRACE(GAT_SUCCEEDED(retcode), context);
00169   GAT_TEST_TRACE(GATTrue  == isequal, context);
00170 
00171   GATFile_Destroy         (&new_file);
00172   GATMemoryStream_Destroy (&stream);
00173 
00174   GAT_TEST_TRACE(GAT_SUCCEEDED(retcode), context);
00175   GAT_TEST_STOP ();
00176 
00177   return retcode;
00178 }
00179