1 /*

     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.

     3 *

     4 * This library is free software; you can redistribute it and/or

     5 * modify it under the terms of the GNU Lesser General Public

     6 * License as published by the Free Software Foundation; either

     7 * version 2 of the License, or (at your option) any later version.

     8 *

     9 * This library is distributed in the hope that it will be useful,

    10 * but WITHOUT ANY WARRANTY; without even the implied warranty of

    11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    12 * Lesser General Public License for more details.

    13 *

    14 * You should have received a copy of the GNU Lesser General Public

    15 * License along with this library; if not, write to the

    16 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

    17 * Boston, MA 02111-1307, USA.

    18 *

    19 * Description:

    20 *

    21 */

    22 

    23 

    24 #undef G_DISABLE_ASSERT

    25 #undef G_LOG_DOMAIN

    26 

    27 #include <stdio.h>

    28 #include <string.h>

    29 #include <errno.h>

    30 #include <stdlib.h>

    31 #include "glib.h"

    32 

    33 #define BUFFER_SIZE 1024

    34 

    35 #ifdef SYMBIAN

    36 #include "mrt2_glib2_test.h"

    37 #endif /*SYMBIAN*/

    38 

    39 int iochannel_test()

    40 {

    41 	GIOChannel *gio_r, *gio_w ;

    42     GError *gerr = NULL;

    43     GString *buffer;

    44     char *filename;

    45     char *srcdir = getenv ("srcdir");

    46     const gchar encoding[] = "ISO-8859-5";

    47     GIOStatus status;

    48     GIOFlags flags;

    49 	GIOChannelError gio_error;

    50 	GIOCondition gio_condition;

    51 	const gchar *line_term;

    52 	GIOChannel *temp;

    53 	char *buf;

    54 	gsize size_read,size_written;

    55 	GIOError io_error;

    56 	gunichar thechar;

    57 	

    58 	// This call should set gio_error to G_IO_CHANNEL_ERROR_INVAL

    59 	gio_error = g_io_channel_error_from_errno(EINVAL);

    60 	

    61 	g_assert(gio_error == G_IO_CHANNEL_ERROR_INVAL);

    62 	

    63 	if (!srcdir)

    64       srcdir = "c:";

    65     filename = g_strconcat (srcdir, G_DIR_SEPARATOR_S, "iochannel-test-infile", NULL);

    66     

    67     gio_r = g_io_channel_new_file (filename, "r", &gerr);

    68     if (gerr)

    69       {

    70         g_warning ("Unable to open file %s: %s", filename, gerr->message);

    71         g_error_free (gerr);

    72         return 1;

    73       }

    74     gio_w = g_io_channel_new_file ("c:\\iochannel-test-outfile", "w", &gerr);

    75     if (gerr)

    76       {

    77         g_warning ("Unable to open file %s: %s", "iochannel-test-outfile", gerr->message);

    78         g_error_free (gerr);

    79         return 1;

    80       }

    81 

    82 	g_io_channel_set_encoding (gio_r, NULL, &gerr);

    83 	

    84 	if (gerr)

    85       {

    86         g_warning (gerr->message);

    87         g_error_free (gerr);

    88         return 1;

    89       }

    90 	

    91 	g_io_channel_set_buffered(gio_r,TRUE);

    92 	

    93 	g_assert(gio_r->use_buffer == TRUE);

    94 	

    95     g_io_channel_set_encoding (gio_r, encoding, &gerr);

    96     if (gerr)

    97       {

    98         g_warning (gerr->message);

    99         g_error_free (gerr);

   100         return 1;

   101       }

   102     

   103     g_io_channel_set_buffer_size (gio_r, BUFFER_SIZE);

   104     

   105     // check g_io_channel_get_buffer_size

   106     g_assert(g_io_channel_get_buffer_size(gio_r) == BUFFER_SIZE);

   107     

   108     // check g_io_channel_get_buffered

   109     g_assert(g_io_channel_get_buffered(gio_r) == TRUE);

   110     

   111     //g_io_channel_get_close_on_unref

   112     g_assert(g_io_channel_get_close_on_unref(gio_r) == TRUE);

   113     

   114     //check g_io_channel_get_encoding

   115     g_assert(!strcmp(g_io_channel_get_encoding(gio_r),encoding));

   116     

   117     line_term = g_io_channel_get_line_term(gio_r,NULL);

   118     

   119     //check g_io_channel_get_line_term

   120     g_assert(line_term == NULL);

   121     

   122     temp = g_io_channel_ref(gio_r);

   123     

   124     //check g_io_channel_ref

   125     g_assert(temp == gio_r && temp->ref_count == 2);

   126     

   127     g_io_channel_unref(gio_r);

   128     

   129     temp = NULL;

   130     

   131     status = g_io_channel_set_flags (gio_r, G_IO_FLAG_NONBLOCK, &gerr);

   132     if (status == G_IO_STATUS_ERROR)

   133       {

   134         g_warning (gerr->message);

   135         g_error_free (gerr);

   136         gerr = NULL;

   137       }

   138     flags = g_io_channel_get_flags (gio_r);

   139     buffer = g_string_sized_new (BUFFER_SIZE);

   140     

   141     status = g_io_channel_read_to_end(gio_r,&buf,&size_read,&gerr);

   142     

   143     // checks g_io_channel_read_to_end

   144     g_assert(status == G_IO_STATUS_NORMAL && gerr == NULL);

   145     

   146     status = g_io_channel_write_chars(gio_w,buf,size_read,&size_written,&gerr);

   147     

   148     // checks g_io_channel_write_chars

   149     g_assert(status == G_IO_STATUS_NORMAL && size_read == size_written && gerr == NULL);

   150     

   151     switch (status)

   152       {

   153         case G_IO_STATUS_NORMAL:

   154           break;

   155         case G_IO_STATUS_ERROR:

   156           g_warning (gerr->message);

   157           g_error_free (gerr);

   158           gerr = NULL;

   159           break;

   160         default:

   161           g_warning ("Abnormal exit from write loop.");

   162           break;

   163       }

   164     

   165     gio_condition = g_io_channel_get_buffer_condition(gio_w);

   166     

   167     //checks g_io_channel_get_buffer_condition

   168     g_assert(gio_condition == G_IO_OUT);

   169     

   170     do

   171       status = g_io_channel_flush (gio_w, &gerr);

   172     while (status == G_IO_STATUS_AGAIN);

   173 

   174     if (status == G_IO_STATUS_ERROR)

   175       {

   176         g_warning (gerr->message);

   177         g_error_free (gerr);

   178         gerr = NULL;

   179       }

   180 

   181 	

   182 	io_error = g_io_channel_seek(gio_r,0,G_SEEK_SET);

   183 	

   184 	// check g_io_channel_seek

   185 	g_assert(io_error == G_IO_ERROR_NONE);

   186 	

   187 	status = g_io_channel_read_unichar(gio_r,&thechar,&gerr);

   188 	

   189 	//check g_io_channel_read_unichar

   190 	g_assert(status == G_IO_STATUS_NORMAL && gerr == NULL);

   191 	

   192 	status = g_io_channel_write_unichar(gio_w,thechar,&gerr);

   193 	

   194 	//check g_io_channel_write_unichar

   195 	g_assert(status == G_IO_STATUS_NORMAL && gerr == NULL);

   196 	

   197 	g_io_channel_set_line_term(gio_r,"L",-1);

   198 	

   199 	status = g_io_channel_read_line_string (gio_r, buffer, NULL, &gerr);

   200 	

   201 	//checks g_io_channel_set_line_term

   202 	g_assert(buffer->str[strlen(buffer->str)-1] == 'L');

   203 	

   204 	do

   205       status = g_io_channel_flush (gio_w, &gerr);

   206     while (status == G_IO_STATUS_AGAIN);

   207 

   208 	

   209 	g_io_channel_unref(gio_r);

   210     g_io_channel_unref(gio_w);

   211     

   212     return 0;

   213 

   214 }

   215 

   216 int main()

   217 {

   218 	int retval;

   219 	#ifdef SYMBIAN

   220 

   221 

   222 	g_log_set_handler (NULL,  G_LOG_FLAG_FATAL| G_LOG_FLAG_RECURSION | G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_WARNING | G_LOG_LEVEL_MESSAGE | G_LOG_LEVEL_INFO | G_LOG_LEVEL_DEBUG, &mrtLogHandler, NULL);

   223 	#endif /*SYMBIAN*/

   224 	

   225 	retval = iochannel_test();

   226 	

   227 	#ifdef SYMBIAN

   228   	testResultXml("iochannel_test");

   229   	#endif /* EMULATOR */

   230   	

   231   	return retval;

   232 }