/* Hey EMACS -*- linux-c -*- */

/*  libcalcfiles - file format library, a part of the CalcForge project
 *  Copyright (C) 1999-2004  Romain Lievin
 *  Copyright (C) 2009  Kevin Kofler
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

/*
  This program contains a lot of routines for testing various part of the
  library as well as checking file support.
*/

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <glib.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "../src/calcfiles.h"

/*
  Compare 2 files bytes per bytes and show differences
*/
static int compare_files(const char *src, const char *dst)
{
    FILE *fs, *fd;
    int i;
    int s, d;
    
    fs = fopen(src, "rb");
    fd = fopen(dst, "rb");
    
    if( (fs == NULL) || (fd == NULL) )
    {
		printf("Unable to open these files: <%s> & <%s>.\n", src, dst);
		return -1;
    }
    
    while(!feof(fs) && !feof(fd))
    {
		if((s = fgetc(fs)) != (d = fgetc(fd)))
		{
			printf("\nFiles do not match !!!\n");
			printf("Offset: %08X %i\n", (int)ftell(fs), (int)ftell(fs));

			printf("Data  (src): %02X ", s);
			for(i=0; i<16 && !feof(fs); i++)
				printf("%02X ", fgetc(fs));
			printf("\n");

			printf("Data  (dst): %02X ", d);
			for(i=0; i<16 && !feof(fd); i++)
			printf("%02X ", fgetc(fd));
			printf("\n");

			return -1;
		}
    }
    
    printf("    Files match !\n");
   
    return 0;
}

static int test_ti73_backup_support(void);
static int test_ti73_regular_support(void);
static int test_ti73_group_support(void);
static int test_ti73_ungroup_support(void);

static int test_ti82_backup_support(void);
static int test_ti82_regular_support(void);
static int test_ti82_group_support(void);
static int test_ti82_ungroup_support(void);

static int test_ti83_backup_support(void);
static int test_ti83_regular_support(void);
static int test_ti83_group_support(void);
static int test_ti83_ungroup_support(void);

static int test_ti84p_backup_support(void);
static int test_ti84p_regular_support(void);
static int test_ti84p_group_support(void);
static int test_ti84p_ungroup_support(void);	
static int test_ti84p_flash_support(void);  

static int test_ti85_regular_support(void);

static int test_ti86_backup_support(void);
static int test_ti86_regular_support(void);
static int test_ti86_group_support(void);
static int test_ti86_ungroup_support(void);

static int test_ti89_regular_support(void);
static int test_ti89_flash_support(void);

static int test_ti92_backup_support(void);
static int test_ti92_regular_support(void);
static int test_ti92_group_support(void);
static int test_ti92_ungroup_support(void);

static int test_ti8x_cert_support();
static int test_ti9x_cert_support();

static int test_ti8x_group_merge();

static int test_tigroup();

/*
  The main function
*/
int main(int argc, char **argv)
{
	char *msg = NULL;
	char buffer[256];
	int i;
	int ret;

	// init library
	calcfiles_library_init();

	// test calcfiles.c
	printf("Library version : <%s>\n", calcfiles_version_get());
	printf("--\n");

	// test error.c
	calcfiles_error_get(515, &msg);
	printf("Error message: <%s>\n", msg);
#ifndef __WIN32__
	free(msg);
#endif
	printf("--\n");

	// test type2str.c
	printf("calcfiles_string_to_model: <%i> <%i>\n", CALC_TI92, 
	       calcfiles_string_to_model(calcfiles_model_to_string(CALC_TI92)));
	printf("calcfiles_string_to_attribute: <%i> <%i>\n", ATTRB_LOCKED, 
	       calcfiles_string_to_attribute(calcfiles_attribute_to_string(ATTRB_LOCKED)));
	printf("calcfiles_string_to_class: <%i> <%i>\n", TIFILE_SINGLE, 
	       calcfiles_string_to_class(calcfiles_class_to_string(TIFILE_SINGLE)));
	printf("--\n");

	// test filetypes.c
	for(i = CALC_TI73; i <= CALC_V200; i++)
	    printf("%s (%i) ", calcfiles_fext_of_group(i), i);
	printf("\n");

	for(i = CALC_TI73; i <= CALC_V200; i++)
            printf("%s ", calcfiles_fext_of_backup(i));
        printf("\n");

	for(i = CALC_TI73; i <= CALC_V200; i++)
            printf("%s ", calcfiles_fext_of_flash_os(i));
        printf("\n");

	for(i = CALC_TI73; i <= CALC_V200; i++)
            printf("%s ", calcfiles_fext_of_flash_app(i));
        printf("\n");
	printf("--\n");

	printf("<%s> <%s>\n", "foo.bar", calcfiles_fext_get("foo.bar"));

	ret = calcfiles_file_is_ti("misc/str.92s"); 
	printf("calcfiles_file_is_ti: %i\n", ret);

	ret = calcfiles_file_is_single("misc/str.92s");
	printf("calcfiles_file_is_single: %i\n", ret);

	ret = calcfiles_file_is_group("misc/group.92g");
        printf("calcfiles_file_is_group: %i\n", ret);

	ret = calcfiles_file_is_regular("misc/str.92s");
        printf("calcfiles_file_is_regular: %i\n", ret);

	ret = calcfiles_file_is_regular("misc/group.92g");
        printf("calcfiles_file_is_regular: %i\n", ret);

	ret = calcfiles_file_is_backup("misc/backup.83b");
	printf("calcfiles_file_is_backup: %i\n", ret);

	ret = calcfiles_file_is_flash("misc/ticabfra.89k");
        printf("calcfiles_file_is_flash: %i\n", ret);

	ret = calcfiles_file_is_flash("misc/TI73_OS160.73U");
        printf("calcfiles_file_is_flash: %i\n", ret);

	ret = calcfiles_file_is_tib("misc/ams100.tib");
        printf("calcfiles_file_is_tib: %i\n", ret);

	ret = calcfiles_file_is_tigroup("misc/test.tig");
        printf("calcfiles_file_is_tig: %i\n", ret);
	printf("--\n");

	// test typesxx.c
	printf("calcfiles_file_get_model: %s\n", 
         calcfiles_model_to_string(calcfiles_file_get_model("misc/str.92s")));

	printf("calcfiles_file_get_class: %s\n",
         calcfiles_class_to_string(calcfiles_file_get_class("misc/group.92g")));

	printf("calcfiles_file_get_type: %s\n",
	       calcfiles_file_get_type("misc/TI73_OS160.73U"));
	printf("calcfiles_file_get_icon: %s\n",
	       calcfiles_file_get_icon("misc/str.92s"));
	printf("--\n");

	// test misc.c

	printf("calcfiles_calc_is_ti8x: %i\n", calcfiles_calc_is_ti8x(CALC_TI83));
	printf("calcfiles_calc_is_ti9x: %i\n", calcfiles_calc_is_ti9x(CALC_TI89));

	printf("calcfiles_has_folder: %i\n", calcfiles_has_folder(CALC_TI92));
	printf("calcfiles_is_flash: %i\n", calcfiles_is_flash(CALC_TI73));

	printf("calcfiles_get_varname: <%s>\n", calcfiles_get_varname("fld\\var"));
	printf("calcfiles_get_fldname: <%s>\n", calcfiles_get_fldname("fld\\var"));
	calcfiles_build_fullname(CALC_TI89, buffer, "fld", "var");
	printf("calcfiles_build_fullname: <%s>\n", buffer);
	printf("--\n");

	// test filesxx.c & grouped.c

	// TI73 support
#if 0
	test_ti73_backup_support();
	test_ti73_regular_support();
	test_ti73_group_support();
	test_ti73_ungroup_support();
#endif

	// TI82 support
#if 0
	test_ti82_backup_support();
	test_ti82_regular_support();
	test_ti82_group_support();
	test_ti82_ungroup_support();
#endif

	// TI83 support
#if 0
	test_ti83_backup_support();
	test_ti83_regular_support();
	test_ti83_group_support();
	test_ti83_ungroup_support();
#endif

	// TI83+ support
#if 1
	//test_ti84p_regular_support();
	//test_ti84p_group_support();
	//test_ti84p_ungroup_support();	
	test_ti84p_flash_support();
#endif

	// TI85 support
#if 0
	test_ti85_regular_support();
#endif

	// TI86 support
#if 0
	//test_ti86_backup_support();
	test_ti86_regular_support();
	//test_ti86_group_support();
	//test_ti86_ungroup_support();
#endif

	// TI89 support
#if 0
	test_ti89_regular_support();
	test_ti89_flash_support();
#endif

	// TI92 support
#if 0
	test_ti92_backup_support();
	test_ti92_regular_support();
	test_ti92_group_support();
	test_ti92_ungroup_support();
#endif

	// TIXX certificates
#if 0
	test_ti8x_cert_support();
	//test_ti9x_cert_support();
#endif

	// Add/Del files
#if 0
	test_ti8x_group_merge();
#endif

#if 0
	test_tigroup();
#endif

	// end of test
	calcfiles_library_exit();

  return 0;
}

/*
	About TI formatted file: we can sort calc like this:
	- TI73
	- TI82/83
	- TI83+/TI84+
	- TI85/86
	- TI92
	- TI89/92+/V200

	Testing order:
	- backup
	- regular (single and group)
	- flash
	- grouping
	- ungrouping
*/

/*********/
/* TI-73 */
/*********/

static int test_ti73_backup_support()
{
  BackupContent *content;

  printf("--> Testing TI73 backup support...\n");
  calcfiles_file_display("ti73/backup.73b");

  content = calcfiles_content_create_backup(CALC_TI73);
  calcfiles_file_read_backup("ti73/backup.73b", content);
  calcfiles_file_write_backup("ti73/backup.73b_", content);
  calcfiles_content_delete_backup(content);
  compare_files("ti73/backup.73b", "ti73/backup.73b_");

  return 0;
}

static int test_ti73_regular_support()
{
  FileContent *content;
  char *unused;

  printf("--> Testing TI73 regular support (single)...\n");
  calcfiles_file_display("ti73/romdump.73p");

  content = calcfiles_content_create_regular(CALC_TI73);
  calcfiles_file_read_regular("ti73/romdump.73p", content);
  calcfiles_file_write_regular("ti73/romdump.73p_", content, &unused);
  calcfiles_content_delete_regular(content);
  compare_files("ti73/romdump.73p", "ti73/romdump.73p_");

  printf("--> Testing TI73 regular support (group)...\n");
  calcfiles_file_display("ti73/group.73g");  

  content = calcfiles_content_create_regular(CALC_TI73);
  calcfiles_file_read_regular("ti73/group.73g", content);
  calcfiles_file_write_regular("ti73/group.73g_", content, &unused);
  calcfiles_content_delete_regular(content);
  compare_files("ti73/group.73g", "ti73/group.73g_");

  return 0;
}

static int test_ti73_group_support()
{
  //char *array[] = { "ti73/L1.73l", "ti73/bb.73l", NULL };
  char files[2][1024];
  char *array[3] = { 0 };

  strcpy(files[0], "ti73/L1L1.73l");
  strcpy(files[1], "ti73/L2L2.73l");
  array[0] = files[0];
  array[1] = files[1];
  
  printf("--> Testing TI73 grouping of files...\n");
  calcfiles_group_files(array, "ti73/L1L2.73g_");
  calcfiles_file_display("ti73/L1L2.73g_");
  compare_files("ti73/group.73g", "ti73/L1L2.73g_");
  
  return 0;
}

static int test_ti73_ungroup_support()
{
  printf("--> Testing TI73 ungrouping of files...\n");
  calcfiles_ungroup_file("ti73/group.73g", NULL);
  rename("L1.73l", "ti73/L1.73l");
  rename("L2.73l", "ti73/L2.73l");
  compare_files("ti73/L1.73l", "ti73/L1L1.73l");
  compare_files("ti73/L2.73l", "ti73/L2L2.73l");

  return 0;
}

/*********/
/* TI-82 */
/*********/

static int test_ti82_backup_support()
{
  BackupContent *content;

  printf("--> Testing TI82 backup support...\n");
  calcfiles_file_display("ti82/backup.82b");

  content = calcfiles_content_create_backup(CALC_TI82);
  calcfiles_file_read_backup("ti82/backup.82b", content);
  calcfiles_file_write_backup("ti82/backup.82b_", content);
  calcfiles_content_delete_backup(content);
  compare_files("ti82/backup.82b", "ti82/backup.82b_");

  return 0;
}

static int test_ti82_regular_support()
{
  FileContent *content;
  char *unused;

  printf("--> Testing TI82 regular support (single)...\n");
  calcfiles_file_display("ti82/math.82p");

  content = calcfiles_content_create_regular(CALC_TI82);
  calcfiles_file_read_regular("ti82/math.82p", content);
  calcfiles_file_write_regular("ti82/math.82p_", content, &unused);
  calcfiles_content_delete_regular(content);
  compare_files("ti82/math.82p", "ti82/math.82p_");

  printf("--> Testing TI82 regular support (group)...\n");
  calcfiles_file_display("ti82/group.82g"); 
  
  content = calcfiles_content_create_regular(CALC_TI82);
  calcfiles_file_read_regular("ti82/group.82g", content);
  calcfiles_file_write_regular("ti82/group.82g_", content, &unused);
  calcfiles_content_delete_regular(content);
  compare_files("ti82/group.82g", "ti82/group.82g_");

  return 0;
}

static int test_ti82_group_support()
{
  //char *array[] = { "ti82/aa.82n", "ti82/bb.82n", NULL };
  char files[2][1024];
  char *array[3] = { 0 };

  strcpy(files[0], "ti82/aa.82n");
  strcpy(files[1], "ti82/bb.82n");
  array[0] = files[0];
  array[1] = files[1];
  
  printf("--> Testing TI82 grouping of files...\n");
  calcfiles_group_files(array, "ti82/aabb.82g_");
  calcfiles_file_display("ti82/aabb.82g_");
  compare_files("ti82/group.82g", "ti82/aabb.82g_");
  
  return 0;
}

static int test_ti82_ungroup_support()
{
  printf("--> Testing TI82 ungrouping of files...\n");
  calcfiles_ungroup_file("ti82/group.82g", NULL);
  rename("A.82n", "ti82/A.82n");
  rename("B.82n", "ti82/B.82n");
  compare_files("ti82/A.82n", "ti82/aa.82n");
  compare_files("ti82/B.82n", "ti82/bb.82n");

  return 0;
}

static int test_ti82_group_ungroup_support()
{
  /*
  FileContent src1;
  FileContent **dst1;
  FileContent **src2;
  FileContent dst2;
  FileContent **ptr;

  ti8x_read_regular_file("group.82g", &src1);
  ti8x_ungroup_content(&src1, &dst1);
  src2 = dst1;
  ti8x_group_content(src2, dst2);
  ti8x_write_regular_file("group2.82g_", dst2);
  */
  return 0;
}

/*********/
/* TI-83 */
/*********/

static int test_ti83_backup_support()
{
  BackupContent *content;

  printf("--> Testing ti83 backup support...\n");
  calcfiles_file_display("ti83/backup.83b");

  content = calcfiles_content_create_backup(CALC_TI83);
  calcfiles_file_read_backup("ti83/backup.83b", content);
  calcfiles_file_write_backup("ti83/backup.83b_", content);
  calcfiles_content_delete_backup(content);
  compare_files("ti83/backup.83b", "ti83/backup.83b_");

  return 0;
}

static int test_ti83_regular_support()
{
  FileContent *content;
  char *unused;

  printf("--> Testing ti83 regular support (single)...\n");
  calcfiles_file_display("ti83/romdump.83p");

  content = calcfiles_content_create_regular(CALC_TI83);
  calcfiles_file_read_regular("ti83/romdump.83p", content);
  calcfiles_file_write_regular("ti83/romdump.83p_", content, &unused);
  calcfiles_content_delete_regular(content);
  compare_files("ti83/romdump.83p", "ti83/romdump.83p_");

  printf("--> Testing ti83 regular support (group)...\n");
  calcfiles_file_display("ti83/group.83g");  

  content = calcfiles_content_create_regular(CALC_TI83);
  calcfiles_file_read_regular("ti83/group.83g", content);
  calcfiles_file_write_regular("ti83/group.83g_", content, &unused);
  calcfiles_content_delete_regular(content);
  compare_files("ti83/group.83g", "ti83/group.83g_");

  return 0;
}

static int test_ti83_group_support()
{
  char files[2][1024];
  char *array[3] = { 0 };

  strcpy(files[0], "ti83/aa.83n");
  strcpy(files[1], "ti83/bb.83n");
  array[0] = files[0];
  array[1] = files[1];
  
  printf("--> Testing ti83 grouping of files...\n");
  calcfiles_group_files(array, "ti83/aabb.83g_");
  calcfiles_file_display("ti83/aabb.83g_");
  compare_files("ti83/group.83g", "ti83/aabb.83g_");
  
  return 0;
}

static int test_ti83_ungroup_support()
{
  printf("--> Testing ti83 ungrouping of files...\n");
  calcfiles_ungroup_file("ti83/group.83g", NULL);
  rename("A.83n", "ti83/A.83n");
  rename("B.83n", "ti83/B.83n");
  compare_files("ti83/A.83n", "ti83/aa.83n");
  compare_files("ti83/B.83n", "ti83/bb.83n");

  return 0;
}

static int test_ti83_group_ungroup_support()
{
  /*
  FileContent src1;
  FileContent **dst1;
  FileContent **src2;
  FileContent dst2;
  FileContent **ptr;

  ti8x_read_regular_file("group.83g", &src1);
  ti8x_ungroup_content(&src1, &dst1);
  src2 = dst1;
  ti8x_group_content(src2, dst2);
  ti8x_write_regular_file("group2.83g_", dst2);
  */
  return 0;
}

/**********/
/* TI-84+ */
/**********/

CALCFILES_EXPORT FileContent* CALCFORGE_CALL calcfiles_content_dup_regular(FileContent *content);

static int test_ti84p_regular_support()
{
  FileContent *content;
  char *unused;

  printf("--> Testing TI84+ regular support (single)...\n");
  calcfiles_file_display("ti84p/romdump.8Xp");

  content = calcfiles_content_create_regular(CALC_TI84P);
  calcfiles_file_read_regular("ti84p/romdump.8Xp", content);
  calcfiles_file_write_regular("ti84p/romdump.8Xp_", content, &unused);
  calcfiles_content_delete_regular(content);
  compare_files("ti84p/romdump.8Xp", "ti84p/romdump.8Xp_");

  printf("--> Testing TI84+ regular support (group)...\n");
  calcfiles_file_display("ti84p/group.8Xg");  

  content = calcfiles_content_create_regular(CALC_TI84P);
  calcfiles_file_read_regular("ti84p/group.8Xg", content);
  calcfiles_file_write_regular("ti84p/group.8Xg_", content, &unused);
  calcfiles_content_delete_regular(content);
  compare_files("ti84p/group.8Xg", "ti84p/group.8Xg_");

  return 0;
}

static int test_ti84p_group_support()
{
  //char *array[] = { "ti84p/aa.8Xn", "ti84p/bb.8Xn", NULL };
  char files[2][1024];
  char *array[3] = { 0 };

  strcpy(files[0], "ti84p/aa.8Xn");
  strcpy(files[1], "ti84p/bb.8Xn");
  array[0] = files[0];
  array[1] = files[1];
  
  printf("--> Testing TI84+ grouping of files...\n");
  calcfiles_group_files(array, "ti84p/aabb.8Xg_");
  calcfiles_file_display("ti84p/aabb.8Xg_");
  compare_files("ti84p/group.8Xg", "ti84p/aabb.8Xg_");
  
  return 0;
}

static int test_ti84p_ungroup_support()
{
  printf("--> Testing TI84+ ungrouping of files...\n");
  calcfiles_ungroup_file("ti84p/group.8Xg", NULL);
  rename("A.8Xn", "ti84p/A.8Xn");
  rename("B.8Xn", "ti84p/B.8Xn");
  compare_files("ti84p/A.8Xn", "ti84p/aa.8Xn");
  compare_files("ti84p/B.8Xn", "ti84p/bb.8Xn");

  return 0;
}

static int test_ti84p_flash_support()
{
  FlashContent *content;

  printf("--> Testing TI84+ flash support...\n");

  calcfiles_file_display("ti84p/LogIn_1.8Xk");	//chembio

  content = calcfiles_content_create_flash(CALC_TI84P);
  calcfiles_file_read_flash("ti84p/LogIn_1.8Xk", content);
  calcfiles_file_write_flash("ti84p/LogIn_1.8Xk_", content);
  calcfiles_content_delete_flash(content);
  compare_files("ti84p/chembio.8Xk", "ti84p/chembio.8Xk_");

  return 0;

  calcfiles_file_display("ti84p/TI84Plus_OS.8Xu");

  content = calcfiles_content_create_flash(CALC_TI84P);
  calcfiles_file_read_flash("ti84p/TI84Plus_OS.8Xu", content);
  calcfiles_file_write_flash("ti84p/TI84Plus_OS.8Xu_", content);
  calcfiles_content_delete_flash(content);
  compare_files("ti84p/TI84Plus_OS.8Xu", "ti84p/TI84Plus_OS.8Xu_");

  return 0;
}

/*********/
/* TI-85 */
/*********/

static int test_ti85_regular_support()
{
  FileContent *content;
  char *unused;

  printf("--> Testing TI85 regular support (single)...\n");
  calcfiles_file_display("ti85/AA.85n");

  content = calcfiles_content_create_regular(CALC_TI85);
  calcfiles_file_read_regular("ti85/AA.85n", content);
  calcfiles_file_write_regular("ti85/AA.85n_", content, &unused);
  calcfiles_content_delete_regular(content);
  compare_files("ti85/AA.85n", "ti85/AA.85n_");

  printf("--> Testing TI85 regular support (group)...\n");
  calcfiles_file_display("ti85/group.85g"); 
  
  content = calcfiles_content_create_regular(CALC_TI85);
  calcfiles_file_read_regular("ti85/group.85g", content);
  calcfiles_file_write_regular("ti85/group.85g_", content, &unused);
  calcfiles_content_delete_regular(content);
  compare_files("ti85/group.85g", "ti85/group.85g_");

  return 0;
}

/*********/
/* TI-86 */
/*********/

static int test_ti86_backup_support()
{
  BackupContent *content;

  printf("--> Testing TI86 backup support...\n");
  calcfiles_file_display("ti86/backup.86b");

  content = calcfiles_content_create_backup(CALC_TI86);
  calcfiles_file_read_backup("ti86/backup.86b", content);
  calcfiles_file_write_backup("ti86/backup.86b_", content);
  calcfiles_content_delete_backup(content);
  compare_files("ti86/backup.86b", "ti86/backup.86b_");

  return 0;
}

static int test_ti86_regular_support()
{
  FileContent *content;
  char *unused;

  printf("--> Testing TI86 regular support (single)...\n");
  calcfiles_file_display("ti86/prgm.86p");

  content = calcfiles_content_create_regular(CALC_TI86);
  calcfiles_file_read_regular("ti86/prgm.86p", content);
  calcfiles_file_write_regular("ti86/prgm.86p_", content, &unused);
  calcfiles_content_delete_regular(content);
  compare_files("ti86/prgm.86p", "ti86/prgm.86p_");

  printf("--> Testing TI86 regular support (group)...\n");
  calcfiles_file_display("ti86/group.86g");  

  content = calcfiles_content_create_regular(CALC_TI86);
  calcfiles_file_read_regular("ti86/group.86g", content);
  calcfiles_file_write_regular("ti86/group.86g_", content, &unused);
  calcfiles_content_delete_regular(content);
  compare_files("ti86/group.86g", "ti86/group.86g_");

  return 0;
}

static int test_ti86_regular_support_()
{
  FileContent *content;
  char *unused;

  printf("--> Testing TI86 regular support (single)...\n");
  calcfiles_file_display("ti86/ellipse.86p");

  content = calcfiles_content_create_regular(CALC_TI86);
  calcfiles_file_read_regular("ti86/ellipse.86p", content);
  calcfiles_file_write_regular("ti86/ellipse.86p_", content, &unused);
  calcfiles_content_delete_regular(content);
  compare_files("ti86/ellipse.86p", "ti86/ellipse.86p_");

  return 0;
}

static int test_ti86_group_support()
{
  //char *array[] = { "ti86/yy.86n", "ti86/xx.86n", NULL };
  char files[2][1024];
  char *array[3] = { 0 };

  strcpy(files[0], "ti86/yy.86n");
  strcpy(files[1], "ti86/xx.86n");  
  array[0] = files[0];
  array[1] = files[1];
  
  printf("--> Testing TI86 grouping of files...\n");
  calcfiles_group_files(array, "ti86/xxyy.86g_");
  calcfiles_file_display("ti86/xxyy.86g_");
  compare_files("ti86/group.86g", "ti86/xxyy.86g_");
  
  return 0;
}

static int test_ti86_ungroup_support()
{
  printf("--> Testing TI86 ungrouping of files...\n");
  calcfiles_ungroup_file("ti86/group.86g", NULL);
  rename("X.86n", "ti86/X.86n");
  rename("Y.86n", "ti86/Y.86n");
  compare_files("ti86/X.86n", "ti86/xx.86n");
  compare_files("ti86/Y.86n", "ti86/yy.86n");

  return 0;
}

/*********/
/* TI-92 */
/*********/

static int test_ti92_backup_support()
{
  BackupContent *content;

  printf("--> Testing TI92 backup support...\n");
  calcfiles_file_display("ti92/backup.92b");

  content = calcfiles_content_create_backup(CALC_TI92);
  calcfiles_file_read_backup("ti92/backup.92b", content);
  calcfiles_file_write_backup("ti92/backup.92b_", content);
  calcfiles_content_delete_backup(content);
  compare_files("ti92/backup.92b", "ti92/backup.92b_");

  return 0;
}

static int test_ti92_regular_support()
{
  FileContent *content;
  char *unused;

  printf("--> Testing TI92 regular support (single)...\n");
  calcfiles_file_display("ti92/str.92s");

  content = calcfiles_content_create_regular(CALC_TI92);
  calcfiles_file_read_regular("ti92/str.92s", content);
  calcfiles_file_write_regular("ti92/str.92s_", content, &unused);
  calcfiles_content_delete_regular(content);
  compare_files("ti92/str.92s", "ti92/str.92s_");


  printf("--> --> Testing TI92 regular support (group)...\n");
  calcfiles_file_display("ti92/group.92g");  

  content = calcfiles_content_create_regular(CALC_TI92);
  calcfiles_file_read_regular("ti92/group.92g", content);
  calcfiles_file_write_regular("ti92/group.92g_", content, &unused);
  calcfiles_content_delete_regular(content);
  compare_files("ti92/group.92g", "ti92/group.92g_");

  return 0;
}

static int test_ti92_group_support()
{
  //char *array[] = { "ti92/xx.92s", "ti92/yy.92s", NULL };
  char files[2][1024];
  char *array[3] = { 0 };

  strcpy(files[0], "ti92/xx.92s");
  strcpy(files[1], "ti92/yy.92s");
  array[0] = files[0];
  array[1] = files[1];
  
  printf("--> Testing TI92 grouping of files...\n");
  calcfiles_group_files(array, "ti92/xxyy.92g_");
  calcfiles_file_display("ti92/xxyy.92g_");
  compare_files("ti92/group.92g", "ti92/xxyy.92g_");
  
  return 0;
}

static int test_ti92_ungroup_support()
{
  printf("--> Testing TI92 ungrouping of files...\n");
  calcfiles_ungroup_file("ti92/group.92g", NULL);
  rename("X.92s", "ti92/X.92s");
  rename("Y.92s", "ti92/Y.92s");
  compare_files("ti92/X.92s", "ti92/xx.92s");
  compare_files("ti92/Y.92s", "ti92/yy.92s");

  return 0;
}

/*********/
/* TI-89 */
/*********/

static int test_ti89_regular_support()
{
  FileContent *content;
  char *unused;

  printf("--> Testing TI89 regular support (group)...\n");
  calcfiles_file_display("ti89/group.89g");

  content = calcfiles_content_create_regular(CALC_TI89);
  calcfiles_file_read_regular("ti89/group.89g", content);
  calcfiles_file_write_regular("ti89/group.89g_", content, &unused);
  calcfiles_content_delete_regular(content);
  compare_files("ti89/group.89g", "ti89/group.89g_");

  return 0;
}

static int test_ti89_flash_support()
{
  FlashContent *content;

  printf("--> Testing TI89 flash support...\n");
  calcfiles_file_display("ti89/ticabfra.89k");

  content = calcfiles_content_create_flash(CALC_TI89);
  calcfiles_file_read_flash("ti89/ticabfra.89k", content);
  calcfiles_file_write_flash("ti89/ticabfra.89k_", content);
  calcfiles_content_delete_flash(content);
  compare_files("ti89/ticabfra.89k", "ti89/ticabfra.89k_");

  return 0;
}


static int test_v200_regular_support()
{
  FileContent *content;
  char *unused;

  printf("--> Testing regular support (group)...\n");
  calcfiles_file_display("./v200/xy.v2g");

  content = calcfiles_content_create_regular(CALC_V200);
  calcfiles_file_read_regular("./v200/xy.v2g", content);
  calcfiles_file_write_regular("./v200/xy.v2g_", content, &unused);
  compare_files("./v200/xy.v2g", "./v200/xy.v2g_");

  return 0;
}

/*********/
/* TI-XX */
/*********/

static int test_ti8x_cert_support()
{
  FlashContent *content;

  printf("--> Testing TI8X certif support...\n");
  calcfiles_file_display("certs/celsheet1.8Xk");

  content = calcfiles_content_create_flash(CALC_TI84P);
  calcfiles_file_read_flash("certs/celsheet1.8Xk", content);
  calcfiles_file_write_flash("certs/celsheet1.8Xk_", content);
  calcfiles_content_delete_flash(content);
  compare_files("certs/celsheet1.8Xk", "certs/celsheet1.8Xk_");

  return 0;
}

static int test_ti9x_cert_support()
{
	FlashContent *content;

  printf("--> Testing TI9X certif support...\n");
  calcfiles_file_display("certs/ticsheet.9xk");

  content = calcfiles_content_create_flash(CALC_TI92P);
  calcfiles_file_read_flash("certs/ticsheet.9xk", content);
  calcfiles_file_write_flash("certs/ticsheet.9xk_", content);
  calcfiles_content_delete_flash(content);
  compare_files("certs/ticsheet.9xk", "certs/ticsheet.9xk_");

  return 0;
}

int test_ti8x_group_merge()
{
	VarEntry ve;

	printf("--> Testing add/del from group support (r/w)...\n");
	calcfiles_group_add_file("misc/group1.8Xg", "misc/group2.8Xg");

	strcpy(ve.name, "A");
	calcfiles_group_del_file(&ve, "misc/group2.8Xg");

	strcpy(ve.name, "B");
	calcfiles_group_del_file(&ve, "misc/group2.8Xg");

	compare_files("misc/group1.8Xg", "misc/group2.8Xg");

	return 0;
}

int test_tigroup()
{
	TigContent *content = { 0 };
	TigEntry te = { 0 };

	// SVN can't handle file like 'pépé'. You will have to rename it from pepe to pépé and
	// uncomment line below and another line.
	//char *name = g_filename_from_utf8("tig/p\xC3\xA9p\xC3\xA9.tig", -1, NULL, NULL, NULL);

	char *array[2];
	char files[2][1024];

#if 0
	printf("--> Testing TiGroup support (r/w)...\n");
	calcfiles_file_display_tigroup("tig/test.tig");
#endif
#if 0
	content = calcfiles_content_create_tigroup(CALC_NONE, 0);
	calcfiles_file_read_tigroup("tig/test2.tig", content);
	calcfiles_file_write_tigroup("tig/test2_.tig", content);
	calcfiles_content_delete_tigroup(content);
#endif
#if 0
	content = calcfiles_content_create_tigroup(CALC_NONE, 0);
	calcfiles_file_read_tigroup("tig/test.tig", content);
	
	calcfiles_file_write_tigroup("tig/test_.tig", content);
	calcfiles_content_delete_tigroup(content);

	compare_files("tig/test.tig", "tig/test_.tig");
#endif
#if 0
	printf("--> Testing add/del from TiGroup support (r/w)...\n");
	calcfiles_tigroup_add_file("tig/C.8Xn", "tig/test2.tig");
	calcfiles_tigroup_add_file("tig/D.8Xn", "tig/test2.tig");

	te.filename = strdup("C.8Xn");
	calcfiles_tigroup_del_file(&te, "tig/test2.tig");

	te.filename = strdup("D.8Xn");
	calcfiles_tigroup_del_file(&te, "tig/test2.tig");

	calcfiles_file_display_tigroup("tig/test2.tig");
	compare_files("tig/test.tig", "tig/test2.tig");
#endif
#if 0
	printf("--> Testing TiGroup support (group/ungroup)...\n");
	
	strcpy(files[0], "tig/str.89s");
	strcpy(files[1], "tig/ticabfra.89k");
	array[0] = files[0];
	array[1] = files[1];
	calcfiles_tigroup_files(array, "tig/test_.tig");
	calcfiles_file_display("tig/test_.tig");
	
	calcfiles_untigroup_file("tig/test.tig", NULL);
	rename("A.8Xn", "tig/AA.8Xn");
	rename("B.8Xn", "tig/BB.8Xn");
	compare_files("tig/A.8Xn", "tig/AA.8Xn");
	compare_files("tig/B.8Xn", "tig/BB.8Xn");	
#endif
	return 0;
}

//calcfiles_file_display("misc/str.92s");
//calcfiles_file_display(g_locale_to_utf8("misc/pépé.92s", -1, NULL, NULL, NULL));
//return 0;