/*====================================================================*\
FILE    : TestDbms.c
PURPOSE : Test all DBMS routines
 
HISTORY..
DATE       BUILD     AUTHOR  MODIFICATIONS
16-Apr-96  G-03-11   dmp     $$1   Created
30-Apr-96  G-03-11   dmp     $$2   pass ProMdl* not ProMdl to ProTestQcrName() 
27-May-96  G-03-15   amin    $$3   renamed ProSolidRetrieve --> ProMdlRetrieve
31-May-96  G-03-16   dmp     $$4   added "Done" button
26-Aug-96  H-01-05   Xuekai  $$5   Modify due to change to ProMdl
09-Sep-96  H-01-08   Xuekai  $$6   ProErr => ProError, obsolete protk.h
25-Sep-96  H-01-10   Xuekai  $$7   Type casting due to Opaque pointers
12-Nov-96  H-01-16   Steve   $$8   Dbms not require current obj
25-Nov-96  H-01-18   amin    $$9   ProType => ProMdlType
09-Dec-96  H-01-20   amin   $$10   ProMdldataGet -> ProMdlDataGet
18-Jan-97  H-01-21   Pavel  $$11   Added "Backup" button, modified "info" button
				    deleted PRO/D functions
21-Jan-97 H-01-24 Jerry      $$12 Conflict avoidance: changed Dbms menu item to -Dbms
15-Jun-97 H-03-14    Pavel   $$13 Changed ProSolidDisplay to ProMdlDisplay
				  Added call ProMdlDependenciesList
23-Jun-97 H-03-15    Pavel   $$14 Fixed bug 
30-Jun-97 H-03-15    Pavel   $$15 Added call ProObjectwindowCreate to fix
				  regression test
21-Sep-97 H-03-23    Pavel   $$16 Added ProMdlfileCopy Test, type casting
13-Oct-97 H-03-26    Pavel   $$17 Recreated
19-Oct-97 H-03-27    Pavel   $$18 Output Mfg Type
27-Oct-97 H-03-28    Pavel   $$19 Corrected args in TEST_CALL_REPORTs
25-Nov-97 H-03-31    Pavel   $$20 added ProMdlModificationVerify
15-Dec-97 H-03-33    Alexey  $$21 Store/restore current object while
					copying model in ProTestModelSave
09-Jan-98 H-03-37    CHI     $$22 remove args from ProFileOpen
12-Feb-98 h-03-39    Pavel   $$23 Added call of ProMdlWindowGet
03-Mar-98 H-03-39    aab     $$24 Replaced (int)type == -1 by
                                  (int)type < 1 in function ProTestModelErase
01-Jul-98 I-01-13     AKH    $$25 Add support for PT/Products Toolkit
30-Nov-98 I-01-27    akh     $$26 Fix some potential problems with report.
11-Dec-98 I-01-28    mka     $$27 Fix some potential problems with report.
01-Jun-99 I-03-12    mka     $$28 Delete unused variable
01-Nov-99 I-03-20    ags     $$29 Added ProMdlMultipleRetrieve test
24-Jan-00 J-01-02    aap     $$30 Added ProMdlEraseAll test
20-Feb-01 J-01-28    senthil $$31 ProTestMdlOpen is changed to ProTestModelOpen
\*====================================================================*/

/*--------------------------------------------------------------------*\
Pro/TOOLKIT includes
\*--------------------------------------------------------------------*/
#include <ProToolkit.h>
#include <ProObjects.h>
#include <ProMdl.h>
#include <ProSolid.h>
#include <ProMenu.h>
#include <ProMfg.h>
#include <ProUtil.h>
#include <ProSurface.h>
#include <ProMessage.h>

/*--------------------------------------------------------------------*\
Application includes
\*--------------------------------------------------------------------*/
#include "TestError.h"
#include "TestFiletypes.h"
#include "UtilTypes.h"
#include "UtilFiles.h"
#include "UtilMessage.h"
#include "UtilString.h"
#include "UtilNames.h"
#include "UtilCollect.h"
#include "UtilMenu.h"

/*--------------------------------------------------------------------*\
Application macros
\*--------------------------------------------------------------------*/

#define ERASE_OBJECT	    0
#define ERASE_NOT_DISPLAYED 1

#define DELETE_OLD 0
#define DELETE_ALL 1

#define SAVE	0
#define SAVE_AS 1
#define BACKUP  2
#define RENAME  3

/*--------------------------------------------------------------------*\
Application data types
\*--------------------------------------------------------------------*/

/*--------------------------------------------------------------------*\
Application global/external data
\*--------------------------------------------------------------------*/

/*====================================================================*\
  Function : ProUtilLogFileWrite
  Purpose  : Create info string for a model
\*====================================================================*/
static void ProUtilLogFileWrite(char *str)
{
    FILE *fp;

    fp = fopen("dbms.log", "a");
    fputs(str, fp);
    fputc('\n', fp);
    fclose(fp);
}

/*====================================================================*\
  Function : ProUtilMdlStr
  Purpose  : Create info string for a model
\*====================================================================*/
char* ProUtilMdlStr(ProMdl mdl, char *str)
{
    ProError err;
    ProType model_type;
    char tname[PRO_NAME_SIZE], mname[PRO_NAME_SIZE], mfgtypename[PRO_NAME_SIZE];
    ProName w_name;
    ProMfgType mfg_type;
    int model_id;

    err = ProMdlTypeGet(mdl, (ProMdlType*)&model_type);
    TEST_CALL_REPORT("ProMdlTypeGet()", "ProUtilMdlStr()", 
			    err, err != PRO_TK_NO_ERROR);

    err = ProMdlIdGet(mdl, &model_id);
    TEST_CALL_REPORT("ProMdlIdGet()", "ProUtilMdlStr()", 
			    err, err != PRO_TK_NO_ERROR);

    err = ProMdlNameGet(mdl, w_name);
    TEST_CALL_REPORT("ProMdlNameGet()", "ProUtilMdlStr()", 
			    err, err != PRO_TK_NO_ERROR);

    strcpy(tname, ProUtilGetMdlTypeStr((ProMdlType)model_type));
    ProWstringToString(mname, w_name);

    if (model_type == PRO_MFG)
    {
	err = ProMfgTypeGet((ProMfg)mdl, &mfg_type);
	TEST_CALL_REPORT("ProMfgTypeGet()", "ProUtilMdlStr()", 
			    err, err != PRO_TK_NO_ERROR);

	ProUtilMfgtypeStr(mfg_type, mfgtypename);
	sprintf(str, "%s (%s) %s  id = %d", tname, mfgtypename, mname, model_id);

    }
    else
	sprintf(str, "%s %s  id = %d", tname, mname, model_id);

    return (str);
}

/*====================================================================*\
  Function : ProUtilMdlDisplay
  Purpose  : Display model in new window
\*====================================================================*/
ProError ProUtilMdlDisplay(ProMdl mdl)
{
    ProError err = PRO_TK_NO_ERROR;
#ifndef PT_PRODUCTS_BUILD
    ProName w_name;
    ProCharLine line, str;
    ProType type;
    int w_id;

    err = ProMdlWindowGet(mdl, &w_id);
    TEST_CALL_REPORT("ProMdlWindowGet()", "ProUtilMdlDisplay()",
					    err, (err != PRO_TK_NO_ERROR)&&
						(err!=PRO_TK_E_NOT_FOUND));
    if( err == PRO_TK_NO_ERROR )
    {
	sprintf(line, "Model %s already displayed.", ProUtilMdlStr(mdl, str));
	ProUtilMsgPrint("gen", "TEST %0s", line);
	ProUtilLogFileWrite(line);
	return (err);	
    }    
    
    err = ProMdlTypeGet(mdl, (ProMdlType*)&type);
    TEST_CALL_REPORT("ProMdlTypeGet()", "ProUtilMdlDisplay()",
					    err, err != PRO_TK_NO_ERROR);

    err = ProMdlNameGet(mdl, w_name);
    TEST_CALL_REPORT("ProMdlNameGet()", "ProUtilMdlDisplay()",
					    err, err != PRO_TK_NO_ERROR);
    err = ProObjectwindowCreate(w_name, type, &w_id);
    TEST_CALL_REPORT("ProObjectwindowCreate()", "ProUtilMdlDisplay()",
					    err, err != PRO_TK_NO_ERROR);

    err = ProMdlDisplay(mdl);
    TEST_CALL_REPORT("ProMdlDisplay()", "ProUtilMdlDisplay()", 
					    err, err != PRO_TK_NO_ERROR);

    err = ProWindowActivate(w_id);
    TEST_CALL_REPORT("ProWindowActivate()", "ProUtilMdlDisplay()", 
					    err, err != PRO_TK_NO_ERROR);

    if( err == PRO_TK_NO_ERROR )
    {
	sprintf(line, "Displayed %s", ProUtilMdlStr(mdl, str));
	ProUtilMsgPrint("gen", "TEST %0s", line);
	ProUtilLogFileWrite(line);
    }

#endif
    return (err);
}

/*====================================================================*\
  Function : ProUtilMdlInput()
  Purpose  : Ask user to input model name and type
\*====================================================================*/
ProError ProUtilMdlInput(
    char *user_prompt, 
    ProBoolean allow_def, 
    ProName model_name,
    ProMdlType *p_mdl_type)
{
    char line[PRO_PATH_SIZE], str[PRO_PATH_SIZE], tname[PRO_TYPE_SIZE];
    ProName w_name;
    ProPath buff;
    ProMdlType type;
    ProMdl mdl;
    ProError err;
    int stop =0;

    if (allow_def == PRO_B_TRUE)
    {
	err = ProMdlCurrentGet(&mdl);
	TEST_CALL_REPORT("ProMdlCurrentGet()", "ProUtilMdlInput()", 
					    err, (err != PRO_TK_NO_ERROR)&&
					    (err != PRO_TK_BAD_CONTEXT));
	if (err == PRO_TK_NO_ERROR)
	{
	    err = ProMdlNameGet(mdl, w_name);
	    TEST_CALL_REPORT("ProMdlNameGet()", "ProUtilMdlInput()", 
					    err, err != PRO_TK_NO_ERROR);
	    err = ProMdlTypeGet(mdl, &type);
	    TEST_CALL_REPORT("ProMdlTypeGet()", "ProUtilMdlInput()", 
					    err, err != PRO_TK_NO_ERROR);
	    
	    strcpy(tname, ProUtilGetMdlTypeStr(type));
	    ProWstringToString(line, w_name);
	    strcat(line, ".");
	    strcat(line, tname);
	    sprintf(str, user_prompt, line);
	}
	else
	{
	    allow_def = PRO_B_FALSE;
	    sprintf(str, user_prompt, "");
	}
    }
    else
	strcpy(str, user_prompt);
    
    do
    {

	ProUtilMsgPrint("gen", "TEST %0s", str);
	err = ProMessageStringRead(PRO_FILE_NAME_SIZE, buff); 
	TEST_CALL_REPORT("ProMessageStringRead()", "ProUtilMdlInput()", 
		err, (err != PRO_TK_NO_ERROR)&&(err!=PRO_TK_GENERAL_ERROR));
	if (err != PRO_TK_NO_ERROR)
	{
	    if (err != PRO_TK_MSG_USER_QUIT && allow_def == PRO_B_TRUE)
	    {
		ProWstringToString(line, w_name);
		break;
	    }
	    else
		return(PRO_TK_BAD_INPUTS);
	}

	ProWstringToString(str, buff);

	if( ProUtilConfirmNameType(str, line, (ProType*)&type) 
	    == PRO_TK_BAD_INPUTS)
	    continue;

    } while (stop);

    ProStringToWstring(model_name, line);
    *p_mdl_type = type;
    return (PRO_TK_NO_ERROR);
}


/*====================================================================*\
  Function : ProTestNewAction
  Purpose  : Menubutton action. Return with err
\*====================================================================*/
static int ProTestNewAction(ProAppData data, int action)
{
    ProError err;

    err = ProMenuDeleteWithStatus(action);
    TEST_CALL_REPORT("ProMenuDeleteWithStatus()",
		"ProTestNewAction()", err, err != PRO_TK_NO_ERROR);
    return (0);
}


/*====================================================================*\
  Function : ProTestUnsupported
  Purpose  : Write Message 'type unsupported'
\*====================================================================*/
static int ProTestUnsupported(ProAppData data, ProType type)
{
    char ctype[PRO_NAME_SIZE];
    ProCharLine line;

    ProUtilObjtypeStr(type, ctype);
    sprintf(line, "Model creation isn't supported yet for type %s.", ctype);
    ProUtilMsgPrint("gen", "TEST %0s", line);

    return (0);
}


/*====================================================================*\
  Function : ProTestNewMfg
  Purpose  : Show menu new tknewmfg
\*====================================================================*/
ProError ProTestNewMfg(ProName name, ProMdl *p_mdl)
{
    ProError err;
    int action;
    ProName buff;
    ProMfg mfg;
    ProMfgType mfgtype;

    err = ProMenuFileRegister("TkNewMfg", "tknewmfg.mnu", NULL);
    err = ProMenubuttonActionSet("TkNewMfg", "-Part",
	ProTestNewAction, NULL, (int)PRO_MFGTYPE_MACH_PART);
    err = ProMenubuttonActionSet("TkNewMfg", "-Assembly",
	ProTestNewAction, NULL, (int)PRO_MFGTYPE_MACH_ASSEM);
    err = ProMenubuttonActionSet("TkNewMfg", "-Sheetmetal",
	ProTestNewAction, NULL, (int)PRO_MFGTYPE_SHEET_METAL);
    err = ProMenubuttonActionSet("TkNewMfg", "-Cast",
	ProTestNewAction, NULL, (int)PRO_MFGTYPE_CAST);
    err = ProMenubuttonActionSet("TkNewMfg", "-Mold",
	ProTestNewAction, NULL, (int)PRO_MFGTYPE_MOLD);
    err = ProMenubuttonActionSet("TkNewMfg", "-CMM",
	ProTestNewAction, NULL, (int)PRO_MFGTYPE_CMM);
    err = ProMenubuttonActionSet("TkNewMfg", "Done/Return",
	(ProMenubuttonAction)ProMenuDelete, NULL, 0);
    err = ProMenubuttonActionSet("TkNewMfg", "TkNewMfg",
	(ProMenubuttonAction)ProMenuDelete, NULL, 0);

    err = ProMenuCreate(PROMENUTYPE_MAIN, "TkNewMfg", NULL);
    err = ProMenuProcess("TkNewMfg", &action);

    if (err != PRO_TK_NO_ERROR)
	return (err);

    mfgtype = (ProMfgType)action;

    if (mfgtype == PRO_MFGTYPE_MACH_PART ||
        mfgtype == PRO_MFGTYPE_SHEET_METAL)
    {
	ProUtilMsgPrint("gen", "TEST %0s", "Enter design part name: ");

	if( ProUtilStringGet(buff, NULL, PRO_FILE_NAME_SIZE) == 0)
	    return(PRO_TK_GENERAL_ERROR);
    }

    err = ProMfgCreate(name, mfgtype, buff, &mfg);
    TEST_CALL_REPORT("ProMfgCreate()", "ProMfgCreate()", 
				    err, err != PRO_TK_NO_ERROR);

    if (err == PRO_TK_NO_ERROR)
	*p_mdl = (ProMdl)mfg;

    return (PRO_TK_NO_ERROR);
}


/*====================================================================*\
  Function : ProTestNewModel
  Purpose  : Show menu new tknew
\*====================================================================*/
int ProTestNewModel()
{
    ProError err;
    int action;
    ProLine buff;
    ProCharLine line, str;
    ProMdl  model;
    
    err = ProMenuFileRegister("TkNew", "tknew.mnu", NULL);
    err = ProMenubuttonActionSet("TkNew", "-Sketch",
	(ProMenubuttonAction)ProTestUnsupported, NULL, (int)PRO_2DSECTION);
    err = ProMenubuttonActionSet("TkNew", "-Part",
	(ProMenubuttonAction)ProTestNewAction, NULL, (int)PRO_PART);
    err = ProMenubuttonActionSet("TkNew", "-Assembly",
	(ProMenubuttonAction)ProTestNewAction, NULL, (int)PRO_ASSEMBLY);
    err = ProMenubuttonActionSet("TkNew", "-Manufacturing",
	(ProMenubuttonAction)ProTestNewAction, NULL, (int)PRO_MFG);
    err = ProMenubuttonActionSet("TkNew", "-Drawing",
	(ProMenubuttonAction)ProTestUnsupported, NULL, (int)PRO_DRAWING);
    err = ProMenubuttonActionSet("TkNew", "-Format",
	(ProMenubuttonAction)ProTestUnsupported, NULL, (int)PRO_DWGFORM);
    err = ProMenubuttonActionSet("TkNew", "-Report",
	(ProMenubuttonAction)ProTestUnsupported, NULL, (int)PRO_REPORT);
    err = ProMenubuttonActionSet("TkNew", "-Diagram",
	(ProMenubuttonAction)ProTestUnsupported, NULL, (int)PRO_DIAGRAM);
    err = ProMenubuttonActionSet("TkNew", "-Layout",
	(ProMenubuttonAction)ProTestUnsupported, NULL, (int)PRO_LAYOUT);
    err = ProMenubuttonActionSet("TkNew", "-Markup",
	(ProMenubuttonAction)ProTestUnsupported, NULL, (int)PRO_MARKUP);
    err = ProMenubuttonActionSet("TkNew", "TkNew",
	(ProMenubuttonAction)ProMenuDelete, NULL, 0);
    err = ProMenubuttonActionSet("TkNew", "Done/Return",
	(ProMenubuttonAction)ProMenuDelete, NULL, 0);

    err = ProMenuCreate(PROMENUTYPE_MAIN, "TkNew", NULL);
    err = ProMenuProcess("TkNew", &action);

    if (err != PRO_TK_NO_ERROR)
	return (0);

    ProUtilMsgPrint("gen", "TEST %0s", "Enter new model name: ");

    if( ProUtilStringGet(buff, NULL, PRO_FILE_NAME_SIZE) == 0)
	return(-1);

    if ((ProType)action == PRO_PART || (ProType)action == PRO_ASSEMBLY)
    {
	err = ProSolidCreate(buff, (ProType)action, (ProSolid *)&model);
	TEST_CALL_REPORT("ProSolidCreate()", "ProTestDbmsAction()", err,
					    err != PRO_TK_NO_ERROR);
    } else if ((ProType)action == PRO_MFG)
    {
	err = ProTestNewMfg(buff, &model);
    }

    if( err == PRO_TK_NO_ERROR )
    {
	sprintf(line, "%s has been created", ProUtilMdlStr(model, str));
	ProUtilMsgPrint("gen", "TEST %0s", line);
	ProUtilLogFileWrite(line);
	err = ProUtilMdlDisplay(model);
    }

    return (0);
}

/*====================================================================*\
  Function : ProTestModelOpen
  Purpose  : Open model window
\*====================================================================*/
int ProTestModelOpen()
{
    ProError err;
    int version;
    ProCharLine line, str;
    ProLine buff;
    ProPath *path_arr, sel_path, def_path;
    ProName *path_lab_arr, w_name, w_type;
    ProMdl  model;
    ProType type;

    ProStringToWstring(buff, "*.prt,*.asm,*.mfg,*.lay,*.sec,"
			     "*.drw,*.rep,*.frm,*.rep,*.mrk,*.dgm");
    ProStringToWstring(def_path, ".");

    /* No default dirs */
    err = ProArrayAlloc(0, sizeof(ProPath), 1, (ProArray*)&path_arr);
    TEST_CALL_REPORT("ProArrayAlloc()", "ProTestModelOpen()", 
					    err, err != PRO_TK_NO_ERROR);
    err = ProArrayAlloc(0, sizeof(ProPath), 1, (ProArray*)&path_lab_arr);
    TEST_CALL_REPORT("ProArrayAlloc()", "ProTestModelOpen()", 
					    err, err != PRO_TK_NO_ERROR);
    /* Open file */
    err = ProFileOpen(NULL, buff, path_arr, path_lab_arr, def_path, NULL,
		      sel_path);
    TEST_CALL_REPORT("ProFileOpen()", "ProTestModelOpen()", 
					    err, err != PRO_TK_NO_ERROR);

    ProWstringToString(line, sel_path);

    if (err == PRO_TK_NO_ERROR)
    {
	err = ProFilenameParse(sel_path, def_path, w_name, w_type, &version);
	TEST_CALL_REPORT("ProFilenameParse()", "ProTestModelOpen()", 
					    err, err != PRO_TK_NO_ERROR);

	err = ProPathCreate(NULL, w_name, w_type, PRO_VALUE_UNUSED, def_path);
	TEST_CALL_REPORT("ProPathCreate()", "ProTestModelOpen()", 
					    err, err != PRO_TK_NO_ERROR);

	ProWstringToString(str, def_path);
	if( ProUtilConfirmNameType(str, line, &type) != PRO_TK_BAD_INPUTS)
	{
	    err = ProMdlRetrieve(w_name, (ProMdlType)type, &model);
	    TEST_CALL_REPORT("ProMdlRetrieve()", "ProTestModelOpen()", 
					    err, err != PRO_TK_NO_ERROR);

	    if( err == PRO_TK_NO_ERROR )
	    {
		sprintf(line, "%s has been retrieved", 
		    ProUtilMdlStr(model, str));
		ProUtilMsgPrint("gen", "TEST %0s", line);
		ProUtilLogFileWrite( line);
		err = ProUtilMdlDisplay(model);
	    }
	}
    }
	
    err = ProArrayFree((ProArray*)&path_arr);
    TEST_CALL_REPORT("ProArrayFree()", "ProTestModelOpen()", 
					    err, err != PRO_TK_NO_ERROR);
    err = ProArrayFree((ProArray*)&path_lab_arr);
    TEST_CALL_REPORT("ProArrayFree()", "ProTestModelOpen()", 
					    err, err != PRO_TK_NO_ERROR);
    return(0);
}

/*====================================================================*\
  Function : ProUtilModelToMdl
  Purpose  : Convert ProModels to ProMdls
\*====================================================================*/
ProError ProUtilModelToMdl(
    ProModel **model_list, 
    ProMdl **mdl_list, 
    int *n_mdl)
{
    ProError err;
    int i, ign=0;
    ProMdlType type;
    ProMdl mdl;
    char ctype[PRO_NAME_SIZE];

    err = ProArrayAlloc(0, sizeof(ProMdl), 1, (ProArray*)mdl_list);
    TEST_CALL_REPORT("ProArrayAlloc()", "ProUtilModelToMdl()", 
					    err, err != PRO_TK_NO_ERROR);

    for (i=0; i<n_mdl[0]; i++)
    {
	ProWstringToString(ctype, model_list[0][i].type);
	type = (ProMdlType)ProUtilGetProType(ctype);

	err = ProMdlInit(model_list[0][i].name, type, &mdl);
	TEST_CALL_REPORT("ProMdlInit()", 
		    "ProUtilModelToMdl()", err, err != PRO_TK_NO_ERROR);
	if (err != PRO_TK_NO_ERROR)
	{
	    ign++;
	    continue;
	}

	err = ProArrayObjectAdd((ProArray*)mdl_list, PRO_VALUE_UNUSED, 1, &mdl);
	TEST_CALL_REPORT("ProArrayObjectAdd()", "ProUtilModelToMdl()", 
					    err, err != PRO_TK_NO_ERROR);
    }

    err = ProArrayFree((ProArray*)model_list);
    TEST_CALL_REPORT("ProArrayFree()", "ProUtilModelToMdl()", 
					err, err != PRO_TK_NO_ERROR);
    n_mdl[0] -= ign;
    return( n_mdl[0]>0 ? PRO_TK_NO_ERROR : PRO_TK_E_NOT_FOUND);
}

/*====================================================================*\
  Function : ProTestModelErase
  Purpose  : Erase Current / Not Displayed objects from session
\*====================================================================*/
int ProTestModelErase(ProAppData data, int action)
{
    ProMdl *mdl_array, *mdl_list, model, cur_model;
    ProModel *model_list;
    ProError err;
    int n_mdl, i, j, k, *p_ids,  n_win, n;
    ProCharLine str, line;
    ProName w_name;
    ProMdlType mod_types[]={PRO_MDL_MFG, PRO_MDL_DRAWING, PRO_MDL_ASSEMBLY,
	PRO_MDL_PART, PRO_MDL_2DSECTION,  PRO_MDL_LAYOUT}, type;

    err = ProArrayAlloc(0, sizeof(ProMdl), 1, (ProArray*)&mdl_array);
    TEST_CALL_REPORT("ProArrayAlloc()", "ProTestModelErase()", 
            err, err != PRO_TK_NO_ERROR);
            
    if (action == ERASE_OBJECT)
    {
	err = ProUtilMdlInput("Enter object to erase []:", PRO_B_FALSE,
	    w_name, &type);
	if (err == PRO_TK_NO_ERROR)
	{
	    err = ProMdlInit(w_name, type, &model);
	    TEST_CALL_REPORT("ProMdlInit()", 
                "ProTestModelErase()", err, err != PRO_TK_NO_ERROR);
	}
	if (err == PRO_TK_NO_ERROR)
	{
	    err = ProMdlCurrentGet(&cur_model);
	    TEST_CALL_REPORT("ProMdlCurrentGet()", "ProTestModelErase()", 
	        err, (err != PRO_TK_NO_ERROR)&&(err != PRO_TK_BAD_CONTEXT));
	    if (err == PRO_TK_NO_ERROR && model == cur_model)
	    {
		ProUtilMsgPrint("gen", "TEST %0s", 
		    "Unable to erase current object");
		return (0);
	    }

	    /* If object open in window close window first */
	    err = ProUtilCollectWindowIds(&p_ids);

	    err = ProArraySizeGet((ProArray)p_ids, &n_win);
	    TEST_CALL_REPORT("ProArraySizeGet()", "ProTestModelErase()", 
						err, err != PRO_TK_NO_ERROR);
	    for (i=0; i<n_win; i++)
	    {
		err = ProWindowMdlGet(p_ids[i], &cur_model);
		TEST_CALL_REPORT("ProWindowMdlGet()", "ProTestModelErase()", 
						err, err != PRO_TK_NO_ERROR);

		if (cur_model == model)
		{
		    err = ProWindowDelete(p_ids[i]);
		    TEST_CALL_REPORT("ProWindowDelete()", "ProTestModelErase()", 
						err, err != PRO_TK_NO_ERROR);
		    break;
		}
	    }

	    err = ProArrayFree((ProArray*)&p_ids);
	    TEST_CALL_REPORT("ProArrayFree()", "ProTestModelErase()", 
						err, err != PRO_TK_NO_ERROR);

	}
	/* Find models and dependencies */
	err = ProArrayObjectAdd((ProArray*)&mdl_array, PRO_VALUE_UNUSED, 1,
	    &model);
	TEST_CALL_REPORT("ProArrayObjectAdd()", "ProTestModelErase()", 
					    err, err != PRO_TK_NO_ERROR);
	err = ProMdlDependenciesList(model, &model_list, &n_mdl);
	TEST_CALL_REPORT("ProMdlDependenciesList()", "ProTestModelErase()", 
					    err, (err != PRO_TK_NO_ERROR)&&
					    (err != PRO_TK_E_NOT_FOUND));
	if (err == PRO_TK_NO_ERROR)
	    err = ProUtilModelToMdl(&model_list, &mdl_list, &n_mdl);
	if (err == PRO_TK_NO_ERROR)
	{
	    err = ProArrayObjectAdd((ProArray*)&mdl_array, PRO_VALUE_UNUSED,
		n_mdl, mdl_list);
	    TEST_CALL_REPORT("ProArrayObjectAdd()", "ProTestModelErase()", 
						err, err != PRO_TK_NO_ERROR);
	    err = ProArrayFree((ProArray*)&mdl_list);
	    TEST_CALL_REPORT("ProArrayFree()", "ProTestModelErase()", 
						err, err != PRO_TK_NO_ERROR);
	}
    }
    else
    {
	/* Collect all models */
	for (i=0; i<sizeof(mod_types)/sizeof(mod_types[0]); i++)
	{
	    err = ProSessionMdlList(mod_types[i], &mdl_list, &n_mdl);
	    TEST_CALL_REPORT("ProSessionMdlList()", "ProTestModelErase()", 
					    err, (err != PRO_TK_NO_ERROR)&&
                                                 (err != PRO_TK_E_NOT_FOUND));
	    if (err != PRO_TK_NO_ERROR)
		continue;

	    err = ProArrayObjectAdd((ProArray*)&mdl_array, PRO_VALUE_UNUSED,
		n_mdl, mdl_list);
	    TEST_CALL_REPORT("ProArrayObjectAdd()", "ProTestModelErase()", 
						err, err != PRO_TK_NO_ERROR);

	    err = ProArrayFree((ProArray*)&mdl_list);
	    TEST_CALL_REPORT("ProArrayFree()", "ProTestModelErase()", 
						err, err != PRO_TK_NO_ERROR);
	}
    }

    /* Remove objects which currently displayed */
    err = ProUtilCollectWindowIds(&p_ids);

    err = ProArraySizeGet((ProArray)p_ids, &n_win);
    TEST_CALL_REPORT("ProArraySizeGet()", "ProTestModelErase()", 
						err, err != PRO_TK_NO_ERROR);
    err = ProArraySizeGet((ProArray)mdl_array, &n);
    TEST_CALL_REPORT("ProArraySizeGet()", "ProTestModelErase()", 
						err, err != PRO_TK_NO_ERROR);

    /* for each window found displayed objects and depend. */
    for (i=0; i<n_win; i++)
    {
	err = ProWindowMdlGet(p_ids[i], &model);
	TEST_CALL_REPORT("ProWindowMdlGet()", "ProTestModelErase()", 
						err, err != PRO_TK_NO_ERROR);
	if (err != PRO_TK_NO_ERROR)
	    continue;

 	if(model!=NULL) {
		err = ProMdlDependenciesList(model, &model_list, &n_mdl);
		TEST_CALL_REPORT("ProMdlDependenciesList()", "ProTestModelErase()", 
					    err, (err != PRO_TK_NO_ERROR)&&
					    (err != PRO_TK_E_NOT_FOUND));
		if (err != PRO_TK_NO_ERROR)   n_mdl = 0;		
		if (err == PRO_TK_NO_ERROR)
		        err = ProUtilModelToMdl(&model_list, &mdl_list, &n_mdl);

		for (j=0; j<n; j++)
		{
		    for (k=0; k<=n_mdl; k++)
			if (mdl_array[j] == (k<n_mdl ? mdl_list[k] : model))
			{
			    err = ProArrayObjectRemove((ProArray*)&mdl_array, j, 1);
			    TEST_CALL_REPORT("ProArrayObjectRemove()", 
				    "ProTestModelErase()", err, err != PRO_TK_NO_ERROR);
			    n--;
			    if (j>=n)
				break;
			}
		}

	} else n_mdl=0;


	if (n_mdl >0)
	{
	    err = ProArrayFree((ProArray*)&mdl_list);
	    TEST_CALL_REPORT("ProArrayFree()", "ProTestModelErase()", 
						err, err != PRO_TK_NO_ERROR);
	}
    }

    err = ProArrayFree((ProArray*)&p_ids);
    TEST_CALL_REPORT("ProArrayFree()", "ProTestModelErase()", 
					err, err != PRO_TK_NO_ERROR);

    ProUtilMsgPrint("gen", "TEST %0s", 
	"Are you sure to erase models from memory? [N]:");
    if (ProUtilYesnoGet("n"))
    {
	/* Erase all collected models */
	for (i=0; i<n; i++)
	{
	    /* Check that model still valid after erasing previous models */
	    err = ProMdlTypeGet(mdl_array[i], &type);
	    if (err != PRO_TK_NO_ERROR || (int)type < 1)
		continue;

	    sprintf(line, "%s has been cleared", 
		ProUtilMdlStr(mdl_array[i], str));

	    err = ProMdlErase(mdl_array[i]);
 	    TEST_CALL_REPORT("ProMdlErase()", "ProTestModelErase()", 
			err, (err != PRO_TK_NO_ERROR) && (err != PRO_TK_E_IN_USE));
	    if (err == PRO_TK_NO_ERROR)
	    {
		ProUtilMsgPrint("gen", "TEST %0s", line);
		ProUtilLogFileWrite( line);
	    }
	}

    }
    /* Free allocated memory */
    err = ProArrayFree((ProArray*)&mdl_array);
    TEST_CALL_REPORT("ProArrayFree()", "ProTestModelErase()", 
					err, err != PRO_TK_NO_ERROR);

   return (0);

}

/*====================================================================*\
  Function : ProTestModelEraseAll
  Purpose  : Erase objects from session, including submodels
\*====================================================================*/
int ProTestModelEraseAll(ProAppData data)
{
    ProMdl mdl;
    ProError err; 
    ProName w_name;
    ProMdlType type;
    
    err = ProUtilMdlInput("Enter object to erase []:", PRO_B_FALSE,
                          w_name, &type);
    if (err != PRO_TK_NO_ERROR)
        return err;

    err = ProMdlInit(w_name, type, &mdl);
    TEST_CALL_REPORT("ProMdlInit()", "ProTestModelEraseAll()",
                     err, err != PRO_TK_NO_ERROR);

    if (err != PRO_TK_NO_ERROR)
        return err;
        
    err = ProMdlEraseAll(mdl);
    TEST_CALL_REPORT("ProMdlEraseAll()", "ProTestModelEraseAll()", 
                     err, (err != PRO_TK_NO_ERROR));
    
    return err;
}

/*====================================================================*\
  Function : ProUtilCompareVersion()
  Purpose  : compare two files by version
\*====================================================================*/
int ProUtilCompareVersion(ProPath p1, ProPath p2)
{
    int ver1 =0, ver2 =0;
    ProError err;

    err = ProFilenameParse(p1, NULL, NULL, NULL, &ver1);
    TEST_CALL_REPORT("ProFilenameParse()", "ProTestModelOpen()", 
					err, err != PRO_TK_NO_ERROR);
    err = ProFilenameParse(p2, NULL, NULL, NULL, &ver2);
    TEST_CALL_REPORT("ProFilenameParse()", "ProTestModelOpen()", 
					err, err != PRO_TK_NO_ERROR);


    return (ver1-ver2);
}

/*====================================================================*\
  Function : ProUtilMdlPurge
  Purpose  : Delete old version of an model
\*====================================================================*/
ProError ProUtilMdlPurge(ProName w_name, ProMdlType type)
{
    ProError err;
    ProCharLine line, str;
    ProLine w_line;
    ProPath *file_list, *dir_list;
    ProName w_nm;
    int i, n_files;


    strcpy(line, ProUtilGetMdlTypeStr(type));
    ProWstringToString(str, w_name); 
    strcat(str, ".");
    strcat(str, line);
    ProUtilStringLower(str, str);
    ProStringToWstring(w_line, str);

    ProStringToWstring(w_nm, ".");

    err = ProArrayAlloc(0, sizeof(ProPath), 1, (ProArray*)&file_list);
    TEST_CALL_REPORT("ProArrayAlloc()", "ProUtilMdlPurge()", 
					err, err != PRO_TK_NO_ERROR);

    err = ProArrayAlloc(0, sizeof(ProPath), 1, (ProArray*)&dir_list);
    TEST_CALL_REPORT("ProArrayAlloc()", "ProUtilMdlPurge()", 
					err, err != PRO_TK_NO_ERROR);

    err = ProFilesList(w_nm, w_line, PRO_FILE_LIST_ALL,  &file_list, &dir_list);
    TEST_CALL_REPORT("ProFilesList()", "ProUtilMdlPurge()", 
					err, err != PRO_TK_NO_ERROR);
    if (err == PRO_TK_NO_ERROR)
    { 
	err = ProArraySizeGet((ProArray)file_list, &n_files);
	TEST_CALL_REPORT("ProArraySizeGet()", "ProUtilMdlPurge()", 
					    err, err != PRO_TK_NO_ERROR);
	if (n_files > 1)
	{
	    qsort(file_list, n_files, sizeof(file_list[0]), 
		(int (*)(PRO_CONST_ARG void *, PRO_CONST_ARG void *))
		ProUtilCompareVersion);
	}
	for (i=0; i<n_files-1; i++)
	{
	    ProWstringToString(str, file_list[i]);
	    remove(str);
	}
    }
    err = ProArrayFree((ProArray*)&file_list);
    TEST_CALL_REPORT("ProArrayFree()", "ProUtilMdlPurge()", 
					err, err != PRO_TK_NO_ERROR);
    err = ProArrayFree((ProArray*)&dir_list);
    TEST_CALL_REPORT("ProArrayFree()", "ProUtilMdlPurge()", 
					err, err != PRO_TK_NO_ERROR);


    return(PRO_TK_NO_ERROR);
}

/*====================================================================*\
  Function : ProTestModelDelete
  Purpose  : delete object from memory and disk
\*====================================================================*/
int ProTestModelDelete(ProAppData data, int action)
{
    ProError err;
    ProMdl  mdl, cur_model;
    ProMdlType type;
    ProCharLine str, line;
    ProName w_name;
    int i, n_win, *p_ids;

    err = ProMdlCurrentGet(&cur_model);
    TEST_CALL_REPORT("ProMdlCurrentGet()", "ProTestModelDelete()", 
					err, (err != PRO_TK_NO_ERROR)&&
                                             (err != PRO_TK_BAD_CONTEXT));
    if (err != PRO_TK_NO_ERROR)
	cur_model = (ProMdl)NULL;
	    
    if (action == DELETE_ALL)
    {
	err = ProUtilMdlInput("Enter object to delete []:", PRO_B_FALSE,
	    w_name, &type);
	if (err == PRO_TK_NO_ERROR)
	{
	    err = ProMdlInit(w_name, type, &mdl);
	    TEST_CALL_REPORT("ProMdlInit()", "ProTestModelDelete()", 
					    err, err != PRO_TK_NO_ERROR);
	}
	if (err != PRO_TK_NO_ERROR)
	    return (-1);
	if (mdl == cur_model)
	{
	    ProUtilMsgPrint("gen", "TEST %0s", 
		"Unable to delete current object");
	    return (0);
	}

	/* If object open in window close window first */
	err = ProUtilCollectWindowIds(&p_ids);

	err = ProArraySizeGet((ProArray)p_ids, &n_win);
	TEST_CALL_REPORT("ProArraySizeGet()", "ProTestModelDelete()", 
					    err, err != PRO_TK_NO_ERROR);
	for (i=0; i<n_win; i++)
	{
	    err = ProWindowMdlGet(p_ids[i], &cur_model);
	    TEST_CALL_REPORT("ProWindowMdlGet()", "ProTestModelDelete()", 
					    err, err != PRO_TK_NO_ERROR);

	    if (cur_model == mdl)
	    {
		err = ProWindowDelete(p_ids[i]);
		TEST_CALL_REPORT("ProWindowDelete()", "ProTestModelDelete()", 
					    err, err != PRO_TK_NO_ERROR);
		break;
	    }
	}

	err = ProArrayFree((ProArray*)&p_ids);
	TEST_CALL_REPORT("ProArrayFree()", "ProTestModelDelete()", 
					    err, err != PRO_TK_NO_ERROR);

	ProUtilMsgPrint("gen", "TEST %0s", "Are you sure to delete models "
	    "from memory and work directory? [N]:");

	if (ProUtilYesnoGet("n"))
	{
	    sprintf(line, "%s has been deleted", ProUtilMdlStr(mdl, str));

	    err = ProMdlDelete(mdl);
	    TEST_CALL_REPORT("ProMdlDelete()", "ProTestModelDelete()", 
						err, err != PRO_TK_NO_ERROR);
	    if (err == PRO_TK_NO_ERROR)
	    {
	    	ProUtilMsgPrint("gen", "TEST %0s", line);
		ProUtilLogFileWrite( line);
	    }
	}
    }
    else 
    {
	if (cur_model == NULL)
	{
	    err = ProUtilMdlInput("Enter object to purge []:", PRO_B_FALSE,
		w_name, &type);
	}
	else
	{
	    mdl = cur_model;
	    err = ProMdlNameGet(mdl, w_name);
	    TEST_CALL_REPORT("ProMdlNameGet()", "ProTestModelDelete()", 
					    err, err != PRO_TK_NO_ERROR);
	    err = ProMdlTypeGet(mdl, &type);
	    TEST_CALL_REPORT("ProMdlTypeGet()", "ProTestModelDelete()", 
					    err, err != PRO_TK_NO_ERROR);
	}
	
	if (err == PRO_TK_NO_ERROR)
	    err = ProUtilMdlPurge(w_name, type);

	if (err == PRO_TK_NO_ERROR)
	{
	    ProWstringToString(str, w_name);
	    sprintf(line, "%s has been purged", str);
	    ProUtilMsgPrint("gen", "TEST %0s", line);
	    ProUtilLogFileWrite( line);
	}
    }
    return (0);
}

/*====================================================================*\
  Function : ProTestModelSave
  Purpose  : Save current model
\*====================================================================*/
int ProTestModelSave(ProAppData appdata, int action)
{
    ProError err;
    ProMdl  model, new_model, current_model;
    ProMdlType type, type1, current_type;
    ProMdldata data;
    ProLine buff;
    ProCharLine str, line;
    ProName w_name, w_name1, w_current_name;
    char name[PRO_NAME_SIZE];
    ProBoolean modif, current_exists;

    switch(action)
    {
    case SAVE:
	err = ProUtilMdlInput("Enter object to save [%s]:", PRO_B_TRUE,
	    w_name, &type);
	if (err != PRO_TK_NO_ERROR)
	    break;

	err = ProMdlInit(w_name, (ProMdlType)type, &model);
	TEST_CALL_REPORT("ProMdlInit()", "ProTestModelSave()", 
					err, err != PRO_TK_NO_ERROR);
	if (err != PRO_TK_NO_ERROR)
	    break;

    err = ProMdlModificationVerify (model, &modif);
    TEST_CALL_REPORT("ProMdlModificationVerify()", "ProTestModelSave()", 
					err, err != PRO_TK_NO_ERROR);
    if (err == PRO_TK_NO_ERROR)
	{
        sprintf (line, "%s %s since last save", ProUtilMdlStr(model, str),
            modif ? "has been changed" : "has not been changed");
        ProUtilMsgPrint("gen", "TEST %0s", line);
    }

	err = ProMdlSave(model);
	TEST_CALL_REPORT("ProMdlSave()", "ProTestModelSave()", 
					err, err != PRO_TK_NO_ERROR);
	if (err == PRO_TK_NO_ERROR)
	{
	    sprintf(line, "%s has been saved", ProUtilMdlStr(model, str));
	    ProUtilMsgPrint("gen", "TEST %0s", line);
	    ProUtilLogFileWrite( line);
	}
	break;
    case SAVE_AS:
	err = ProUtilMdlInput("Enter object to save as [%s]:", PRO_B_TRUE,
	    w_name, &type);
	if (err != PRO_TK_NO_ERROR)
	    break;

	err = ProUtilMdlInput("Enter object to save to []:", PRO_B_FALSE,
	    w_name1, &type1);
	if (err != PRO_TK_NO_ERROR)
	    break;

	err = ProMdlInit(w_name, (ProMdlType)type, &model);
	TEST_CALL_REPORT("ProMdlInit()", "ProTestModelSave()", 
					err, (err != PRO_TK_NO_ERROR)&&
                                        (err != PRO_TK_E_NOT_FOUND));

	if (err == PRO_TK_NO_ERROR)
	{
	    /* Get name and type of the current Pro/E model */
            current_exists = PRO_B_FALSE;
            err = ProMdlCurrentGet( &current_model );
            TEST_CALL_REPORT("ProMdlCurrentGet()", "ProTestModelSave()",
		err, (err != PRO_TK_NO_ERROR)&&
                     (err != PRO_TK_BAD_CONTEXT));

	    if( err  == PRO_TK_NO_ERROR )
	    {
		current_exists = PRO_B_TRUE;

                err = ProMdlNameGet( current_model, w_current_name );
                TEST_CALL_REPORT("ProMdlNameGet()", "ProTestModelSave()",
                    err, err != PRO_TK_NO_ERROR);

                err = ProMdlTypeGet( current_model, &current_type );
                TEST_CALL_REPORT("ProMdlTypeGet()", "ProTestModelSave()",
                    err, err != PRO_TK_NO_ERROR);
            }

	    /* Copy the specified model */
	    err = ProMdlCopy(model, w_name1, &new_model);
	    TEST_CALL_REPORT("ProMdlCopy()", "ProTestModelSave()", 
					err, err != PRO_TK_NO_ERROR);
	    /* Delete the copy from memory */
	    err = ProMdlErase(new_model);
	    TEST_CALL_REPORT("ProMdlErase()", "ProTestModelSave()", 
					err, err != PRO_TK_NO_ERROR);

            if( current_exists == PRO_B_TRUE )
            {
	        /* Restore current model */
	        err = ProMdlRetrieve(w_current_name, current_type, 
			&current_model); 
                TEST_CALL_REPORT("ProMdlRetrieve()", "ProTestModelSave()",
                    err, err != PRO_TK_NO_ERROR);
	    }
	}
	else
	{
	    err = ProMdlfileCopy((ProMdlType)type, w_name, w_name1);
	    TEST_CALL_REPORT("ProMdlfileCopy()", "ProTestModelSave()", 
					err, err != PRO_TK_NO_ERROR);
	}

	if (err == PRO_TK_NO_ERROR)
	{
	    ProWstringToString(str, w_name);
	    sprintf(line, "%s has been copied", str);
	    ProUtilMsgPrint("gen", "TEST %0s", line);
	    ProUtilLogFileWrite( line);
	}
	break;
    case BACKUP:		    
	err = ProUtilMdlInput("Enter object to backup [%s]:", PRO_B_TRUE,
	    w_name, &type);
	if (err != PRO_TK_NO_ERROR)
	    break;

	err = ProMdlInit(w_name, (ProMdlType)type, &model);
	TEST_CALL_REPORT("ProMdlInit()", "ProTestModelSave()", 
					err, err != PRO_TK_NO_ERROR);
	if (err != PRO_TK_NO_ERROR)
	    break;

	ProUtilMsgPrint("gen", "TEST %0s", "Enter dir to backup to [.]:");
	ProStringToWstring(w_name1, ".");
	if( ProUtilStringGet(buff, w_name1, PRO_FILE_NAME_SIZE) == 0)
	    break;

	err = ProMdlDataGet(model, &data);
	TEST_CALL_REPORT("ProMdlDataGet()", "ProTestModelSave()", 
					err, err != PRO_TK_NO_ERROR);
	ProUtilWstrcpy(data.path, buff);
	err = ProMdlBackup(model, &data);
	TEST_CALL_REPORT("ProMdlBackup()", "ProTestModelSave()", 
					err, err != PRO_TK_NO_ERROR);

	if (err == PRO_TK_NO_ERROR)
	{
	    sprintf(line, "%s has been saved", ProUtilMdlStr(model, str));
	    ProUtilMsgPrint("gen", "TEST %0s", line);
	    ProUtilLogFileWrite( line);
	}
	break;
    case RENAME:
	err = ProUtilMdlInput("Enter object to rename [%s]:", PRO_B_TRUE,
	    w_name, &type);
	if (err != PRO_TK_NO_ERROR)
	    break;

	err = ProUtilMdlInput("Enter new object name []:", PRO_B_FALSE,
	    w_name1, &type1);
	if (err != PRO_TK_NO_ERROR)
	    break;

	err = ProMdlInit(w_name, (ProMdlType)type, &model);
	TEST_CALL_REPORT("ProMdlInit()", "ProTestModelSave()", 
					err, err != PRO_TK_NO_ERROR);

	if (err == PRO_TK_NO_ERROR)
	{
	    ProUtilMdlStr(model, str);
	    err = ProMdlRename(model, w_name1);
	    TEST_CALL_REPORT("ProMdlRename()", "ProTestModelSave()", 
					err, err != PRO_TK_NO_ERROR);
	}
	if (err == PRO_TK_NO_ERROR)
	{
	    sprintf(line, "%s has been renamed to %s", str,
		ProWstringToString(name, w_name1));
	    ProUtilMsgPrint("gen", "TEST %0s", line);
	    ProUtilLogFileWrite( line);
	}
	break;
    }
    return (0);
}

/*====================================================================*\
  Function : ProTestDbmsInfo
  Purpose  : Write info file
\*====================================================================*/
int ProTestDbmsInfo()
{
    ProMdlType mod_types[]={PRO_MDL_PART, PRO_MDL_ASSEMBLY, PRO_MDL_DRAWING,
	PRO_MDL_2DSECTION,  PRO_MDL_LAYOUT};
    char *mdl_name[]={"Parts", "Assemblies", "Drawings", "Sections", "Layouts"};
    int i, j, k, n_mdl, n_dep, n_dec;
    FILE *fp;
    ProModel *model_listdp, *model_listdc;
    ProMdl *mdl_list;
    ProError err;
    ProName w_name;
    ProCharLine line1, line2;

    fp = fopen("names.inf", "w");
    if (fp == NULL)
	return (0);

    fprintf(fp, "Objects\t \t \t \tDependencies\t \tDeclared\n");

    for (i=0; i<sizeof(mod_types)/sizeof(mod_types[0]); i++)
    {
	fprintf(fp, "\n%s\n----------------\n", mdl_name[i]);

	err = ProSessionMdlList(mod_types[i], &mdl_list, &n_mdl);
	TEST_CALL_REPORT("ProSessionMdlList()", "ProTestDbmsInfo()", 
					err, (err != PRO_TK_NO_ERROR)&&
                                        (err != PRO_TK_E_NOT_FOUND));
	if (err != PRO_TK_NO_ERROR)
	    continue;

	for (j=0; j<n_mdl; j++)
	{
	    /* Write model name */
	    err = ProMdlNameGet(mdl_list[j], w_name);
	    TEST_CALL_REPORT("ProMdlNameGet()", "ProTestDbmsInfo()", 
						err, err != PRO_TK_NO_ERROR);

	    ProWstringToString(line1, w_name);
	    fprintf(fp, "    %s\n", line1);

	    err = ProMdlDependenciesList(mdl_list[j], &model_listdp, &n_dep);
	    TEST_CALL_REPORT("ProMdlDependenciesList()", "ProTestDbmsInfo()", 
						err, (err != PRO_TK_NO_ERROR)&&
                                                (err != PRO_TK_E_NOT_FOUND));
	    if (err != PRO_TK_NO_ERROR)
		n_dep = 0;

	    err = ProMdlDeclaredList(mdl_list[j], &model_listdc, &n_dec);
	    TEST_CALL_REPORT("ProMdlDeclaredList()", "ProTestDbmsInfo()", 
						err, (err != PRO_TK_NO_ERROR)&&
                                                (err != PRO_TK_E_NOT_FOUND));
	    if (err != PRO_TK_NO_ERROR)
		n_dec = 0;
	    
	    for (k=0; k<n_dec || k<n_dep; k++)
	    {
		if (k<n_dep)
		{
		    ProWstringToString(line1, model_listdp[k].name);
		    strcat(line1, ".");
		    ProWstringToString(line1 + strlen(line1), 
			model_listdp[k].type);
		}
		else
		    strcpy(line1, " ");
		if (k<n_dec)
		{
		    ProWstringToString(line2, model_listdc[k].name);
		    strcat(line2, ".");
		    ProWstringToString(line2 + strlen(line2), 
			model_listdp[k].type);
		}
		else
		    strcpy(line2, " ");

		fprintf(fp, "\t \t \t \t%-24s%s\n", line1, line2);
	    }
	    if (n_dec>0)
	    {
		err = ProArrayFree((ProArray*)&model_listdc);
		TEST_CALL_REPORT("ProArrayFree()", "ProTestDbmsInfo()", 
						err, err != PRO_TK_NO_ERROR);
	    }
	    if (n_dep>0)
	    {
		err = ProArrayFree((ProArray*)&model_listdp);
		TEST_CALL_REPORT("ProArrayFree()", "ProTestDbmsInfo()", 
						err, err != PRO_TK_NO_ERROR);
	    }
	}
	err = ProArrayFree((ProArray*)&mdl_list);
	TEST_CALL_REPORT("ProArrayFree()", "ProTestDbmsInfo()", 
					err, err != PRO_TK_NO_ERROR);
    }

    fclose(fp);
    ProStringToWstring(w_name, "names.inf");
    ProInfoWindowDisplay(w_name, NULL, NULL);
    return (0);
}

/*====================================================================*\
  Function : ProTestCurClose
  Purpose  : Close current window
\*====================================================================*/
int ProTestCurClose()
{
    ProError err;

    err = ProWindowCurrentClose();
    TEST_CALL_REPORT("ProWindowCurrentClose()", "ProTestCurClose()", 
					err, err != PRO_TK_NO_ERROR);
    return (0);
}

/*====================================================================*\
  Function : ProTestModelMultipleOpen
  Purpose  : Retrieves the models specified in the names list
\*====================================================================*/
int ProTestModelMultipleOpen ()
{
    ProError err;
    ProMdl *p_models;
    ProCharName str, type;
    ProName *p_names, name;
    ProMdldata data;
    ProBoolean display = PRO_B_TRUE;
    int n_models, i, id;
    
    static ProUtilMenuButtons disp_flag[] = { 
        {"DisplayFlag", 0, TEST_CALL_PRO_MENU_DELETE},
        {"Display", PRO_B_TRUE, 0},
        {"Not Display", PRO_B_FALSE, 0},
        {"",0,0}
    };
    
    err = ProUtilMenuIntValueSelect(disp_flag, (int*)&display);
   
                
    err = ProArrayAlloc(0, sizeof(ProName), 1, (ProArray*)&p_names);
    TEST_CALL_REPORT("ProArrayAlloc()", "ProTestRetrieve()", 
					err, err != PRO_TK_NO_ERROR);
     
    while (1)
    {
        ProUtilMsgPrint("gen", "TEST %0s", "Enter file name: ");
        if (!ProUtilStringGet (name, NULL, PRO_NAME_SIZE))
            break;
        err = ProArrayObjectAdd ((ProArray*)&p_names, PRO_VALUE_UNUSED,
                1, &name);
    } 
    err = ProArraySizeGet ((ProArray)p_names, &n_models);
    TEST_CALL_REPORT("ProArraySizeGet()", "ProTestRetrieve()", 
					err, err != PRO_TK_NO_ERROR);
    if (err == PRO_TK_NO_ERROR && n_models > 0)
    {
        err = ProMdlMultipleRetrieve (p_names, display);
        TEST_CALL_REPORT("ProMdlMultipleRetrieve()", "ProTestRetrieve()", 
					err, err != PRO_TK_NO_ERROR);
                                        
    }
    
    err = ProArrayFree ((ProArray*)&p_names);
    TEST_CALL_REPORT("ProArrayFree()", "ProTestRetrieve()", 
					err, err != PRO_TK_NO_ERROR);
    
    return (0);
    
}

/*====================================================================*\
  Function : ProTestDbms
  Purpose  : Create a menu used to test dbms functions
\*====================================================================*/
int ProTestDbms()
{
    ProError err;
    int menu_id, action;
    int ProTestSolidFunc();
    int ProTestSolidProject();

    err = ProMenuFileRegister("TkDbms", "tkdbms.mnu", &menu_id);
    err = ProMenubuttonActionSet("TkDbms", "-New",
	(ProMenubuttonAction)ProTestNewModel, NULL, 0);
    err = ProMenubuttonActionSet("TkDbms", "-Open",
	(ProMenubuttonAction)ProTestModelOpen, NULL, 0);
    err = ProMenubuttonActionSet("TkDbms", "-Erase",
	(ProMenubuttonAction)ProTestModelErase, NULL, ERASE_OBJECT);
    err = ProMenubuttonActionSet("TkDbms", "-Erase not disp",
	(ProMenubuttonAction)ProTestModelErase, NULL, ERASE_NOT_DISPLAYED);
    err = ProMenubuttonActionSet("TkDbms", "-Erase with sub",
	(ProMenubuttonAction)ProTestModelEraseAll, NULL, 0);
    err = ProMenubuttonActionSet("TkDbms", "-Delete old ver",
	(ProMenubuttonAction)ProTestModelDelete, NULL, DELETE_OLD);
    err = ProMenubuttonActionSet("TkDbms", "-Delete all ver",
	(ProMenubuttonAction)ProTestModelDelete, NULL, DELETE_ALL);
    err = ProMenubuttonActionSet("TkDbms", "-Save",
	(ProMenubuttonAction)ProTestModelSave, NULL, SAVE);
    err = ProMenubuttonActionSet("TkDbms", "-Save as",
	(ProMenubuttonAction)ProTestModelSave, NULL, SAVE_AS);
    err = ProMenubuttonActionSet("TkDbms", "-Backup",
	(ProMenubuttonAction)ProTestModelSave, NULL, BACKUP);
    err = ProMenubuttonActionSet("TkDbms", "-Rename",
	(ProMenubuttonAction)ProTestModelSave, NULL, RENAME);
    err = ProMenubuttonActionSet("TkDbms", "-Info",
	(ProMenubuttonAction)ProTestDbmsInfo, NULL, 0);
    err = ProMenubuttonActionSet("TkDbms", "-Close Cur Win",
	(ProMenubuttonAction)ProTestCurClose, NULL, 0);
    err = ProMenubuttonActionSet("TkDbms", "-SolidFunctions", 
	(ProMenubuttonAction)ProTestSolidFunc, NULL, 0);
    err = ProMenubuttonActionSet("TkDbms", "-SolidProject", 
	(ProMenubuttonAction)ProTestSolidProject, NULL, 0);
    err = ProMenubuttonActionSet("TkDbms", "-MultipleOpen", 
	(ProMenubuttonAction)ProTestModelMultipleOpen, NULL, 0);
    err = ProMenubuttonActionSet("TkDbms", "-Done",
	(ProMenubuttonAction) ProMenuDelete, NULL, 0);
    err = ProMenubuttonActionSet("TkDbms", "TkDbms",
	(ProMenubuttonAction) ProMenuDelete, NULL, 0);
    err = ProMenuCreate(PROMENUTYPE_MAIN, "TkDbms", &menu_id);
    err = ProMenuProcess("TkDbms", &action);

    return(0);
}