<?php
/**
 * classProcessesTest.php
 *
 * ProcessMaker Open Source Edition
 * Copyright (C) 2004 - 2008 Colosa Inc.23
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as
 * published by the Free Software Foundation, either version 3 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 Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 * For more information, contact Colosa Inc, 2566 Le Jeune Rd.,
 * Coral Gables, FL, 33134, USA, or email info@colosa.com.
 *
 */
  $unitFilename = $_SERVER['PWD'] . '/test/bootstrap/unit.php' ;
  require_once( $unitFilename );

  require_once( PATH_THIRDPARTY . '/lime/lime.php');
  require_once( PATH_THIRDPARTY.'lime/yaml.class.php');
 
  G::LoadThirdParty('smarty/libs','Smarty.class');
  G::LoadSystem ( 'xmlform');
  G::LoadSystem ( 'xmlDocument');
  G::LoadSystem ( 'form');
  require_once( 'propel/Propel.php' );
  require_once ( "creole/Creole.php" );
  require_once (  PATH_CORE . "config/databases.php");  

  G::LoadClass ( 'processes');


  $obj = new Processes ($dbc); 
  $t   = new lime_test( 231, new lime_output_color() );

  $className = Processes;
  $className = strtolower ( substr ($className, 0,1) ) . substr ($className, 1 );
  
  $reflect = new ReflectionClass( $className );
	$method = array ( );
	$testItems = 0;
 
  foreach ( $reflect->getMethods() as $reflectmethod )  {  
  	$params = '';
  	foreach ( $reflectmethod->getParameters() as $key => $row )   {  
  	  if ( $params != '' ) $params .= ', ';
  	  $params .= '$' . $row->name;  
  	}

 		$testItems++;
  	$methods[ $reflectmethod->getName() ] = $params;
  }

  //To change the case only the first letter of each word, TIA
  $className = ucwords($className);
  $t->diag("class $className" );

  $t->isa_ok( $obj  , $className,  "class $className created");

  //$t->is( count($methods) , 116,  "class $className have " . 116 . ' methods.' );
  $t->is( count($methods) , 120,  "class $className have " . 120 . ' methods.' );

   //checking method 'changeStatus'
  $t->can_ok( $obj,      'changeStatus',   'changeStatus() is callable' );

  //$result = $obj->changeStatus ( $sProUid);
  //$t->isa_ok( $result,      'NULL',   'call to method changeStatus ');
  $t->todo( "call to method changeStatus using $sProUid ");


  //checking method 'changeProcessParent'
  $t->can_ok( $obj,      'changeProcessParent',   'changeProcessParent() is callable' );

  //$result = $obj->changeProcessParent ( $sProUid, $sParentUid);
  //$t->isa_ok( $result,      'NULL',   'call to method changeProcessParent ');
  $t->todo( "call to method changeProcessParent using $sProUid, $sParentUid ");


  //checking method 'processExists'
  $t->can_ok( $obj,      'processExists',   'processExists() is callable' );

  //$result = $obj->processExists ( $sProUid);
  //$t->isa_ok( $result,      'NULL',   'call to method processExists ');
  $t->todo( "call to method processExists using $sProUid ");


  //checking method 'getUnusedProcessGUID'
  $t->can_ok( $obj,      'getUnusedProcessGUID',   'getUnusedProcessGUID() is callable' );

  //$result = $obj->getUnusedProcessGUID ( );
  //$t->isa_ok( $result,      'NULL',   'call to method getUnusedProcessGUID ');
  $t->todo( "call to method getUnusedProcessGUID using  ");


  //checking method 'taskExists'
  $t->can_ok( $obj,      'taskExists',   'taskExists() is callable' );

  //$result = $obj->taskExists ( $sTasUid);
  //$t->isa_ok( $result,      'NULL',   'call to method taskExists ');
  $t->todo( "call to method taskExists using $sTasUid ");


  //checking method 'getUnusedTaskGUID'
  $t->can_ok( $obj,      'getUnusedTaskGUID',   'getUnusedTaskGUID() is callable' );

  //$result = $obj->getUnusedTaskGUID ( );
  //$t->isa_ok( $result,      'NULL',   'call to method getUnusedTaskGUID ');
  $t->todo( "call to method getUnusedTaskGUID using  ");


  //checking method 'dynaformExists'
  $t->can_ok( $obj,      'dynaformExists',   'dynaformExists() is callable' );

  //$result = $obj->dynaformExists ( $sDynUid);
  //$t->isa_ok( $result,      'NULL',   'call to method dynaformExists ');
  $t->todo( "call to method dynaformExists using $sDynUid ");


  //checking method 'inputExists'
  $t->can_ok( $obj,      'inputExists',   'inputExists() is callable' );

  //$result = $obj->inputExists ( $sUid);
  //$t->isa_ok( $result,      'NULL',   'call to method inputExists ');
  $t->todo( "call to method inputExists using $sUid ");


  //checking method 'outputExists'
  $t->can_ok( $obj,      'outputExists',   'outputExists() is callable' );

  //$result = $obj->outputExists ( $sUid);
  //$t->isa_ok( $result,      'NULL',   'call to method outputExists ');
  $t->todo( "call to method outputExists using $sUid ");


  //checking method 'triggerExists'
  $t->can_ok( $obj,      'triggerExists',   'triggerExists() is callable' );

  //$result = $obj->triggerExists ( $sUid);
  //$t->isa_ok( $result,      'NULL',   'call to method triggerExists ');
  $t->todo( "call to method triggerExists using $sUid ");


  //checking method 'SubProcessExists'
  $t->can_ok( $obj,      'SubProcessExists',   'SubProcessExists() is callable' );

  //$result = $obj->SubProcessExists ( $sUid);
  //$t->isa_ok( $result,      'NULL',   'call to method SubProcessExists ');
  $t->todo( "call to method SubProcessExists using $sUid ");


  //checking method 'caseTrackerObjectExists'
  $t->can_ok( $obj,      'caseTrackerObjectExists',   'caseTrackerObjectExists() is callable' );

  //$result = $obj->caseTrackerObjectExists ( $sUid);
  //$t->isa_ok( $result,      'NULL',   'call to method caseTrackerObjectExists ');
  $t->todo( "call to method caseTrackerObjectExists using $sUid ");


  //checking method 'caseTrackerExists'
  $t->can_ok( $obj,      'caseTrackerExists',   'caseTrackerExists() is callable' );

  //$result = $obj->caseTrackerExists ( $sUid);
  //$t->isa_ok( $result,      'NULL',   'call to method caseTrackerExists ');
  $t->todo( "call to method caseTrackerExists using $sUid ");


  //checking method 'dbConnectionExists'
  $t->can_ok( $obj,      'dbConnectionExists',   'dbConnectionExists() is callable' );

  //$result = $obj->dbConnectionExists ( $sUid);
  //$t->isa_ok( $result,      'NULL',   'call to method dbConnectionExists ');
  $t->todo( "call to method dbConnectionExists using $sUid ");


  //checking method 'objectPermissionExists'
  $t->can_ok( $obj,      'objectPermissionExists',   'objectPermissionExists() is callable' );

  //$result = $obj->objectPermissionExists ( $sUid);
  //$t->isa_ok( $result,      'NULL',   'call to method objectPermissionExists ');
  $t->todo( "call to method objectPermissionExists using $sUid ");


  //checking method 'routeExists'
  $t->can_ok( $obj,      'routeExists',   'routeExists() is callable' );

  //$result = $obj->routeExists ( $sUid);
  //$t->isa_ok( $result,      'NULL',   'call to method routeExists ');
  $t->todo( "call to method routeExists using $sUid ");


  //checking method 'stageExists'
  $t->can_ok( $obj,      'stageExists',   'stageExists() is callable' );

  //$result = $obj->stageExists ( $sUid);
  //$t->isa_ok( $result,      'NULL',   'call to method stageExists ');
  $t->todo( "call to method stageExists using $sUid ");


  //checking method 'slExists'
  $t->can_ok( $obj,      'slExists',   'slExists() is callable' );

  //$result = $obj->slExists ( $sUid);
  //$t->isa_ok( $result,      'NULL',   'call to method slExists ');
  $t->todo( "call to method slExists using $sUid ");


  //checking method 'reportTableExists'
  $t->can_ok( $obj,      'reportTableExists',   'reportTableExists() is callable' );

  //$result = $obj->reportTableExists ( $sUid);
  //$t->isa_ok( $result,      'NULL',   'call to method reportTableExists ');
  $t->todo( "call to method reportTableExists using $sUid ");


  //checking method 'reportVarExists'
  $t->can_ok( $obj,      'reportVarExists',   'reportVarExists() is callable' );

  //$result = $obj->reportVarExists ( $sUid);
  //$t->isa_ok( $result,      'NULL',   'call to method reportVarExists ');
  $t->todo( "call to method reportVarExists using $sUid ");


  //checking method 'getUnusedInputGUID'
  $t->can_ok( $obj,      'getUnusedInputGUID',   'getUnusedInputGUID() is callable' );

  //$result = $obj->getUnusedInputGUID ( );
  //$t->isa_ok( $result,      'NULL',   'call to method getUnusedInputGUID ');
  $t->todo( "call to method getUnusedInputGUID using  ");


  //checking method 'getUnusedOutputGUID'
  $t->can_ok( $obj,      'getUnusedOutputGUID',   'getUnusedOutputGUID() is callable' );

  //$result = $obj->getUnusedOutputGUID ( );
  //$t->isa_ok( $result,      'NULL',   'call to method getUnusedOutputGUID ');
  $t->todo( "call to method getUnusedOutputGUID using  ");


  //checking method 'getUnusedTriggerGUID'
  $t->can_ok( $obj,      'getUnusedTriggerGUID',   'getUnusedTriggerGUID() is callable' );

  //$result = $obj->getUnusedTriggerGUID ( );
  //$t->isa_ok( $result,      'NULL',   'call to method getUnusedTriggerGUID ');
  $t->todo( "call to method getUnusedTriggerGUID using  ");


  //checking method 'getUnusedSubProcessGUID'
  $t->can_ok( $obj,      'getUnusedSubProcessGUID',   'getUnusedSubProcessGUID() is callable' );

  //$result = $obj->getUnusedSubProcessGUID ( );
  //$t->isa_ok( $result,      'NULL',   'call to method getUnusedSubProcessGUID ');
  $t->todo( "call to method getUnusedSubProcessGUID using  ");


  //checking method 'getUnusedCaseTrackerObjectGUID'
  $t->can_ok( $obj,      'getUnusedCaseTrackerObjectGUID',   'getUnusedCaseTrackerObjectGUID() is callable' );

  //$result = $obj->getUnusedCaseTrackerObjectGUID ( );
  //$t->isa_ok( $result,      'NULL',   'call to method getUnusedCaseTrackerObjectGUID ');
  $t->todo( "call to method getUnusedCaseTrackerObjectGUID using  ");


  //checking method 'getUnusedDBSourceGUID'
  $t->can_ok( $obj,      'getUnusedDBSourceGUID',   'getUnusedDBSourceGUID() is callable' );

  //$result = $obj->getUnusedDBSourceGUID ( );
  //$t->isa_ok( $result,      'NULL',   'call to method getUnusedDBSourceGUID ');
  $t->todo( "call to method getUnusedDBSourceGUID using  ");


  //checking method 'getUnusedObjectPermissionGUID'
  $t->can_ok( $obj,      'getUnusedObjectPermissionGUID',   'getUnusedObjectPermissionGUID() is callable' );

  //$result = $obj->getUnusedObjectPermissionGUID ( );
  //$t->isa_ok( $result,      'NULL',   'call to method getUnusedObjectPermissionGUID ');
  $t->todo( "call to method getUnusedObjectPermissionGUID using  ");


  //checking method 'getUnusedRouteGUID'
  $t->can_ok( $obj,      'getUnusedRouteGUID',   'getUnusedRouteGUID() is callable' );

  //$result = $obj->getUnusedRouteGUID ( );
  //$t->isa_ok( $result,      'NULL',   'call to method getUnusedRouteGUID ');
  $t->todo( "call to method getUnusedRouteGUID using  ");


  //checking method 'getUnusedStageGUID'
  $t->can_ok( $obj,      'getUnusedStageGUID',   'getUnusedStageGUID() is callable' );

  //$result = $obj->getUnusedStageGUID ( );
  //$t->isa_ok( $result,      'NULL',   'call to method getUnusedStageGUID ');
  $t->todo( "call to method getUnusedStageGUID using  ");


  //checking method 'getUnusedSLGUID'
  $t->can_ok( $obj,      'getUnusedSLGUID',   'getUnusedSLGUID() is callable' );

  //$result = $obj->getUnusedSLGUID ( );
  //$t->isa_ok( $result,      'NULL',   'call to method getUnusedSLGUID ');
  $t->todo( "call to method getUnusedSLGUID using  ");


  //checking method 'getUnusedRTGUID'
  $t->can_ok( $obj,      'getUnusedRTGUID',   'getUnusedRTGUID() is callable' );

  //$result = $obj->getUnusedRTGUID ( );
  //$t->isa_ok( $result,      'NULL',   'call to method getUnusedRTGUID ');
  $t->todo( "call to method getUnusedRTGUID using  ");


  //checking method 'getUnusedRTVGUID'
  $t->can_ok( $obj,      'getUnusedRTVGUID',   'getUnusedRTVGUID() is callable' );

  //$result = $obj->getUnusedRTVGUID ( );
  //$t->isa_ok( $result,      'NULL',   'call to method getUnusedRTVGUID ');
  $t->todo( "call to method getUnusedRTVGUID using  ");


  //checking method 'stepExists'
  $t->can_ok( $obj,      'stepExists',   'stepExists() is callable' );

  //$result = $obj->stepExists ( $sUid);
  //$t->isa_ok( $result,      'NULL',   'call to method stepExists ');
  $t->todo( "call to method stepExists using $sUid ");


  //checking method 'getUnusedStepGUID'
  $t->can_ok( $obj,      'getUnusedStepGUID',   'getUnusedStepGUID() is callable' );

  //$result = $obj->getUnusedStepGUID ( );
  //$t->isa_ok( $result,      'NULL',   'call to method getUnusedStepGUID ');
  $t->todo( "call to method getUnusedStepGUID using  ");


  //checking method 'getUnusedDynaformGUID'
  $t->can_ok( $obj,      'getUnusedDynaformGUID',   'getUnusedDynaformGUID() is callable' );

  //$result = $obj->getUnusedDynaformGUID ( );
  //$t->isa_ok( $result,      'NULL',   'call to method getUnusedDynaformGUID ');
  $t->todo( "call to method getUnusedDynaformGUID using  ");


  //checking method 'setProcessGUID'
  $t->can_ok( $obj,      'setProcessGUID',   'setProcessGUID() is callable' );

  //$result = $obj->setProcessGUID ( $oData, $sNewProUid);
  //$t->isa_ok( $result,      'NULL',   'call to method setProcessGUID ');
  $t->todo( "call to method setProcessGUID using $oData, $sNewProUid ");


  //checking method 'setProcessParent'
  $t->can_ok( $obj,      'setProcessParent',   'setProcessParent() is callable' );

  //$result = $obj->setProcessParent ( $oData, $sParentUid);
  //$t->isa_ok( $result,      'NULL',   'call to method setProcessParent ');
  $t->todo( "call to method setProcessParent using $oData, $sParentUid ");


  //checking method 'renewAllTaskGuid'
  $t->can_ok( $obj,      'renewAllTaskGuid',   'renewAllTaskGuid() is callable' );

  //$result = $obj->renewAllTaskGuid ( $oData);
  //$t->isa_ok( $result,      'NULL',   'call to method renewAllTaskGuid ');
  $t->todo( "call to method renewAllTaskGuid using $oData ");


  //checking method 'renewAllDynaformGuid'
  $t->can_ok( $obj,      'renewAllDynaformGuid',   'renewAllDynaformGuid() is callable' );

  //$result = $obj->renewAllDynaformGuid ( $oData);
  //$t->isa_ok( $result,      'NULL',   'call to method renewAllDynaformGuid ');
  $t->todo( "call to method renewAllDynaformGuid using $oData ");


  //checking method 'getProcessRow'
  $t->can_ok( $obj,      'getProcessRow',   'getProcessRow() is callable' );

  //$result = $obj->getProcessRow ( $sProUid);
  //$t->isa_ok( $result,      'NULL',   'call to method getProcessRow ');
  $t->todo( "call to method getProcessRow using $sProUid ");


  //checking method 'createProcessRow'
  $t->can_ok( $obj,      'createProcessRow',   'createProcessRow() is callable' );

  //$result = $obj->createProcessRow ( $row);
  //$t->isa_ok( $result,      'NULL',   'call to method createProcessRow ');
  $t->todo( "call to method createProcessRow using $row ");


  //checking method 'updateProcessRow'
  $t->can_ok( $obj,      'updateProcessRow',   'updateProcessRow() is callable' );

  //$result = $obj->updateProcessRow ( $row);
  //$t->isa_ok( $result,      'NULL',   'call to method updateProcessRow ');
  $t->todo( "call to method updateProcessRow using $row ");


  //checking method 'getSubProcessRow'
  $t->can_ok( $obj,      'getSubProcessRow',   'getSubProcessRow() is callable' );

  //$result = $obj->getSubProcessRow ( $sProUid);
  //$t->isa_ok( $result,      'NULL',   'call to method getSubProcessRow ');
  $t->todo( "call to method getSubProcessRow using $sProUid ");


  //checking method 'getCaseTrackerRow'
  $t->can_ok( $obj,      'getCaseTrackerRow',   'getCaseTrackerRow() is callable' );

  //$result = $obj->getCaseTrackerRow ( $sProUid);
  //$t->isa_ok( $result,      'NULL',   'call to method getCaseTrackerRow ');
  $t->todo( "call to method getCaseTrackerRow using $sProUid ");


  //checking method 'getCaseTrackerObjectRow'
  $t->can_ok( $obj,      'getCaseTrackerObjectRow',   'getCaseTrackerObjectRow() is callable' );

  //$result = $obj->getCaseTrackerObjectRow ( $sProUid);
  //$t->isa_ok( $result,      'NULL',   'call to method getCaseTrackerObjectRow ');
  $t->todo( "call to method getCaseTrackerObjectRow using $sProUid ");


  //checking method 'getStageRow'
  $t->can_ok( $obj,      'getStageRow',   'getStageRow() is callable' );

  //$result = $obj->getStageRow ( $sProUid);
  //$t->isa_ok( $result,      'NULL',   'call to method getStageRow ');
  $t->todo( "call to method getStageRow using $sProUid ");


  //checking method 'getAllLanes'
  $t->can_ok( $obj,      'getAllLanes',   'getAllLanes() is callable' );

  //$result = $obj->getAllLanes ( $sProUid);
  //$t->isa_ok( $result,      'NULL',   'call to method getAllLanes ');
  $t->todo( "call to method getAllLanes using $sProUid ");


  //checking method 'getTaskRows'
  $t->can_ok( $obj,      'getTaskRows',   'getTaskRows() is callable' );

  //$result = $obj->getTaskRows ( $sProUid);
  //$t->isa_ok( $result,      'NULL',   'call to method getTaskRows ');
  $t->todo( "call to method getTaskRows using $sProUid ");


  //checking method 'createTaskRows'
  $t->can_ok( $obj,      'createTaskRows',   'createTaskRows() is callable' );

  //$result = $obj->createTaskRows ( $aTasks);
  //$t->isa_ok( $result,      'NULL',   'call to method createTaskRows ');
  $t->todo( "call to method createTaskRows using $aTasks ");


  //checking method 'updateTaskRows'
  $t->can_ok( $obj,      'updateTaskRows',   'updateTaskRows() is callable' );

  //$result = $obj->updateTaskRows ( $aTasks);
  //$t->isa_ok( $result,      'NULL',   'call to method updateTaskRows ');
  $t->todo( "call to method updateTaskRows using $aTasks ");


  //checking method 'getRouteRows'
  $t->can_ok( $obj,      'getRouteRows',   'getRouteRows() is callable' );

  //$result = $obj->getRouteRows ( $sProUid);
  //$t->isa_ok( $result,      'NULL',   'call to method getRouteRows ');
  $t->todo( "call to method getRouteRows using $sProUid ");


  //checking method 'createRouteRows'
  $t->can_ok( $obj,      'createRouteRows',   'createRouteRows() is callable' );

  //$result = $obj->createRouteRows ( $aRoutes);
  //$t->isa_ok( $result,      'NULL',   'call to method createRouteRows ');
  $t->todo( "call to method createRouteRows using $aRoutes ");


  //checking method 'updateRouteRows'
  $t->can_ok( $obj,      'updateRouteRows',   'updateRouteRows() is callable' );

  //$result = $obj->updateRouteRows ( $aRoutes);
  //$t->isa_ok( $result,      'NULL',   'call to method updateRouteRows ');
  $t->todo( "call to method updateRouteRows using $aRoutes ");


  //checking method 'getLaneRows'
  $t->can_ok( $obj,      'getLaneRows',   'getLaneRows() is callable' );

  //$result = $obj->getLaneRows ( $sProUid);
  //$t->isa_ok( $result,      'NULL',   'call to method getLaneRows ');
  $t->todo( "call to method getLaneRows using $sProUid ");


  //checking method 'createLaneRows'
  $t->can_ok( $obj,      'createLaneRows',   'createLaneRows() is callable' );

  //$result = $obj->createLaneRows ( $aLanes);
  //$t->isa_ok( $result,      'NULL',   'call to method createLaneRows ');
  $t->todo( "call to method createLaneRows using $aLanes ");


  //checking method 'createSubProcessRows'
  $t->can_ok( $obj,      'createSubProcessRows',   'createSubProcessRows() is callable' );

  //$result = $obj->createSubProcessRows ( $SubProcess);
  //$t->isa_ok( $result,      'NULL',   'call to method createSubProcessRows ');
  $t->todo( "call to method createSubProcessRows using $SubProcess ");


  //checking method 'createCaseTrackerRows'
  $t->can_ok( $obj,      'createCaseTrackerRows',   'createCaseTrackerRows() is callable' );

  //$result = $obj->createCaseTrackerRows ( $CaseTracker);
  //$t->isa_ok( $result,      'NULL',   'call to method createCaseTrackerRows ');
  $t->todo( "call to method createCaseTrackerRows using $CaseTracker ");


  //checking method 'createCaseTrackerObjectRows'
  $t->can_ok( $obj,      'createCaseTrackerObjectRows',   'createCaseTrackerObjectRows() is callable' );

  //$result = $obj->createCaseTrackerObjectRows ( $CaseTrackerObject);
  //$t->isa_ok( $result,      'NULL',   'call to method createCaseTrackerObjectRows ');
  $t->todo( "call to method createCaseTrackerObjectRows using $CaseTrackerObject ");


  //checking method 'createObjectPermissionsRows'
  $t->can_ok( $obj,      'createObjectPermissionsRows',   'createObjectPermissionsRows() is callable' );

  //$result = $obj->createObjectPermissionsRows ( $ObjectPermissions);
  //$t->isa_ok( $result,      'NULL',   'call to method createObjectPermissionsRows ');
  $t->todo( "call to method createObjectPermissionsRows using $ObjectPermissions ");


  //checking method 'createStageRows'
  $t->can_ok( $obj,      'createStageRows',   'createStageRows() is callable' );

  //$result = $obj->createStageRows ( $Stage);
  //$t->isa_ok( $result,      'NULL',   'call to method createStageRows ');
  $t->todo( "call to method createStageRows using $Stage ");


  //checking method 'getInputRows'
  $t->can_ok( $obj,      'getInputRows',   'getInputRows() is callable' );

  //$result = $obj->getInputRows ( $sProUid);
  //$t->isa_ok( $result,      'NULL',   'call to method getInputRows ');
  $t->todo( "call to method getInputRows using $sProUid ");


  //checking method 'createInputRows'
  $t->can_ok( $obj,      'createInputRows',   'createInputRows() is callable' );

  //$result = $obj->createInputRows ( $aInput);
  //$t->isa_ok( $result,      'NULL',   'call to method createInputRows ');
  $t->todo( "call to method createInputRows using $aInput ");


  //checking method 'renewAllInputGuid'
  $t->can_ok( $obj,      'renewAllInputGuid',   'renewAllInputGuid() is callable' );

  //$result = $obj->renewAllInputGuid ( $oData);
  //$t->isa_ok( $result,      'NULL',   'call to method renewAllInputGuid ');
  $t->todo( "call to method renewAllInputGuid using $oData ");


  //checking method 'getOutputRows'
  $t->can_ok( $obj,      'getOutputRows',   'getOutputRows() is callable' );

  //$result = $obj->getOutputRows ( $sProUid);
  //$t->isa_ok( $result,      'NULL',   'call to method getOutputRows ');
  $t->todo( "call to method getOutputRows using $sProUid ");


  //checking method 'createOutputRows'
  $t->can_ok( $obj,      'createOutputRows',   'createOutputRows() is callable' );

  //$result = $obj->createOutputRows ( $aOutput);
  //$t->isa_ok( $result,      'NULL',   'call to method createOutputRows ');
  $t->todo( "call to method createOutputRows using $aOutput ");


  //checking method 'renewAllOutputGuid'
  $t->can_ok( $obj,      'renewAllOutputGuid',   'renewAllOutputGuid() is callable' );

  //$result = $obj->renewAllOutputGuid ( $oData);
  //$t->isa_ok( $result,      'NULL',   'call to method renewAllOutputGuid ');
  $t->todo( "call to method renewAllOutputGuid using $oData ");


  //checking method 'renewAllTriggerGuid'
  $t->can_ok( $obj,      'renewAllTriggerGuid',   'renewAllTriggerGuid() is callable' );

  //$result = $obj->renewAllTriggerGuid ( $oData);
  //$t->isa_ok( $result,      'NULL',   'call to method renewAllTriggerGuid ');
  $t->todo( "call to method renewAllTriggerGuid using $oData ");


  //checking method 'renewAllSubProcessGuid'
  $t->can_ok( $obj,      'renewAllSubProcessGuid',   'renewAllSubProcessGuid() is callable' );

  //$result = $obj->renewAllSubProcessGuid ( $oData);
  //$t->isa_ok( $result,      'NULL',   'call to method renewAllSubProcessGuid ');
  $t->todo( "call to method renewAllSubProcessGuid using $oData ");


  //checking method 'renewAllCaseTrackerObjectGuid'
  $t->can_ok( $obj,      'renewAllCaseTrackerObjectGuid',   'renewAllCaseTrackerObjectGuid() is callable' );

  //$result = $obj->renewAllCaseTrackerObjectGuid ( $oData);
  //$t->isa_ok( $result,      'NULL',   'call to method renewAllCaseTrackerObjectGuid ');
  $t->todo( "call to method renewAllCaseTrackerObjectGuid using $oData ");


  //checking method 'renewAllDBSourceGuid'
  $t->can_ok( $obj,      'renewAllDBSourceGuid',   'renewAllDBSourceGuid() is callable' );

  //$result = $obj->renewAllDBSourceGuid ( $oData);
  //$t->isa_ok( $result,      'NULL',   'call to method renewAllDBSourceGuid ');
  $t->todo( "call to method renewAllDBSourceGuid using $oData ");


  //checking method 'renewAllObjectPermissionGuid'
  $t->can_ok( $obj,      'renewAllObjectPermissionGuid',   'renewAllObjectPermissionGuid() is callable' );

  //$result = $obj->renewAllObjectPermissionGuid ( $oData);
  //$t->isa_ok( $result,      'NULL',   'call to method renewAllObjectPermissionGuid ');
  $t->todo( "call to method renewAllObjectPermissionGuid using $oData ");


  //checking method 'renewAllRouteGuid'
  $t->can_ok( $obj,      'renewAllRouteGuid',   'renewAllRouteGuid() is callable' );

  //$result = $obj->renewAllRouteGuid ( $oData);
  //$t->isa_ok( $result,      'NULL',   'call to method renewAllRouteGuid ');
  $t->todo( "call to method renewAllRouteGuid using $oData ");


  //checking method 'renewAllStageGuid'
  $t->can_ok( $obj,      'renewAllStageGuid',   'renewAllStageGuid() is callable' );

  //$result = $obj->renewAllStageGuid ( $oData);
  //$t->isa_ok( $result,      'NULL',   'call to method renewAllStageGuid ');
  $t->todo( "call to method renewAllStageGuid using $oData ");


  //checking method 'renewAllSwimlanesElementsGuid'
  $t->can_ok( $obj,      'renewAllSwimlanesElementsGuid',   'renewAllSwimlanesElementsGuid() is callable' );

  //$result = $obj->renewAllSwimlanesElementsGuid ( $oData);
  //$t->isa_ok( $result,      'NULL',   'call to method renewAllSwimlanesElementsGuid ');
  $t->todo( "call to method renewAllSwimlanesElementsGuid using $oData ");


  //checking method 'renewAllReportTableGuid'
  $t->can_ok( $obj,      'renewAllReportTableGuid',   'renewAllReportTableGuid() is callable' );

  //$result = $obj->renewAllReportTableGuid ( $oData);
  //$t->isa_ok( $result,      'NULL',   'call to method renewAllReportTableGuid ');
  $t->todo( "call to method renewAllReportTableGuid using $oData ");


  //checking method 'renewAllReportVarGuid'
  $t->can_ok( $obj,      'renewAllReportVarGuid',   'renewAllReportVarGuid() is callable' );

  //$result = $obj->renewAllReportVarGuid ( $oData);
  //$t->isa_ok( $result,      'NULL',   'call to method renewAllReportVarGuid ');
  $t->todo( "call to method renewAllReportVarGuid using $oData ");


  //checking method 'getStepRows'
  $t->can_ok( $obj,      'getStepRows',   'getStepRows() is callable' );

  //$result = $obj->getStepRows ( $sProUid);
  //$t->isa_ok( $result,      'NULL',   'call to method getStepRows ');
  $t->todo( "call to method getStepRows using $sProUid ");


  //checking method 'createStepRows'
  $t->can_ok( $obj,      'createStepRows',   'createStepRows() is callable' );

  //$result = $obj->createStepRows ( $aStep);
  //$t->isa_ok( $result,      'NULL',   'call to method createStepRows ');
  $t->todo( "call to method createStepRows using $aStep ");


  //checking method 'createStepSupervisorRows'
  $t->can_ok( $obj,      'createStepSupervisorRows',   'createStepSupervisorRows() is callable' );

  //$result = $obj->createStepSupervisorRows ( $aStepSupervisor);
  //$t->isa_ok( $result,      'NULL',   'call to method createStepSupervisorRows ');
  $t->todo( "call to method createStepSupervisorRows using $aStepSupervisor ");


  //checking method 'renewAllStepGuid'
  $t->can_ok( $obj,      'renewAllStepGuid',   'renewAllStepGuid() is callable' );

  //$result = $obj->renewAllStepGuid ( $oData);
  //$t->isa_ok( $result,      'NULL',   'call to method renewAllStepGuid ');
  $t->todo( "call to method renewAllStepGuid using $oData ");


  //checking method 'getDynaformRows'
  $t->can_ok( $obj,      'getDynaformRows',   'getDynaformRows() is callable' );

  //$result = $obj->getDynaformRows ( $sProUid);
  //$t->isa_ok( $result,      'NULL',   'call to method getDynaformRows ');
  $t->todo( "call to method getDynaformRows using $sProUid ");


  //checking method 'getObjectPermissionRows'
  $t->can_ok( $obj,      'getObjectPermissionRows',   'getObjectPermissionRows() is callable' );

  //$result = $obj->getObjectPermissionRows ( $sProUid);
  //$t->isa_ok( $result,      'NULL',   'call to method getObjectPermissionRows ');
  $t->todo( "call to method getObjectPermissionRows using $sProUid ");


  //checking method 'createDynaformRows'
  $t->can_ok( $obj,      'createDynaformRows',   'createDynaformRows() is callable' );

  //$result = $obj->createDynaformRows ( $aDynaform);
  //$t->isa_ok( $result,      'NULL',   'call to method createDynaformRows ');
  $t->todo( "call to method createDynaformRows using $aDynaform ");


  //checking method 'createStepTriggerRows'
  $t->can_ok( $obj,      'createStepTriggerRows',   'createStepTriggerRows() is callable' );

  //$result = $obj->createStepTriggerRows ( $aStepTrigger);
  //$t->isa_ok( $result,      'NULL',   'call to method createStepTriggerRows ');
  $t->todo( "call to method createStepTriggerRows using $aStepTrigger ");


  //checking method 'getStepTriggerRows'
  $t->can_ok( $obj,      'getStepTriggerRows',   'getStepTriggerRows() is callable' );

  //$result = $obj->getStepTriggerRows ( $aTask);
  //$t->isa_ok( $result,      'NULL',   'call to method getStepTriggerRows ');
  $t->todo( "call to method getStepTriggerRows using $aTask ");


  //checking method 'getTriggerRows'
  $t->can_ok( $obj,      'getTriggerRows',   'getTriggerRows() is callable' );

  //$result = $obj->getTriggerRows ( $sProUid);
  //$t->isa_ok( $result,      'NULL',   'call to method getTriggerRows ');
  $t->todo( "call to method getTriggerRows using $sProUid ");


  //checking method 'createTriggerRows'
  $t->can_ok( $obj,      'createTriggerRows',   'createTriggerRows() is callable' );

  //$result = $obj->createTriggerRows ( $aTrigger);
  //$t->isa_ok( $result,      'NULL',   'call to method createTriggerRows ');
  $t->todo( "call to method createTriggerRows using $aTrigger ");


  //checking method 'getGroupwfRows'
  $t->can_ok( $obj,      'getGroupwfRows',   'getGroupwfRows() is callable' );

  //$result = $obj->getGroupwfRows ( $aGroups);
  //$t->isa_ok( $result,      'NULL',   'call to method getGroupwfRows ');
  $t->todo( "call to method getGroupwfRows using $aGroups ");


  //checking method 'getDBConnectionsRows'
  $t->can_ok( $obj,      'getDBConnectionsRows',   'getDBConnectionsRows() is callable' );

  //$result = $obj->getDBConnectionsRows ( $sProUid);
  //$t->isa_ok( $result,      'NULL',   'call to method getDBConnectionsRows ');
  $t->todo( "call to method getDBConnectionsRows using $sProUid ");


  //checking method 'getStepSupervisorRows'
  $t->can_ok( $obj,      'getStepSupervisorRows',   'getStepSupervisorRows() is callable' );

  //$result = $obj->getStepSupervisorRows ( $sProUid);
  //$t->isa_ok( $result,      'NULL',   'call to method getStepSupervisorRows ');
  $t->todo( "call to method getStepSupervisorRows using $sProUid ");


  //checking method 'getReportTablesRows'
  $t->can_ok( $obj,      'getReportTablesRows',   'getReportTablesRows() is callable' );

  //$result = $obj->getReportTablesRows ( $sProUid);
  //$t->isa_ok( $result,      'NULL',   'call to method getReportTablesRows ');
  $t->todo( "call to method getReportTablesRows using $sProUid ");


  //checking method 'getReportTablesVarsRows'
  $t->can_ok( $obj,      'getReportTablesVarsRows',   'getReportTablesVarsRows() is callable' );

  //$result = $obj->getReportTablesVarsRows ( $sProUid);
  //$t->isa_ok( $result,      'NULL',   'call to method getReportTablesVarsRows ');
  $t->todo( "call to method getReportTablesVarsRows using $sProUid ");


  //checking method 'getTaskUserRows'
  $t->can_ok( $obj,      'getTaskUserRows',   'getTaskUserRows() is callable' );

  //$result = $obj->getTaskUserRows ( $aTask);
  //$t->isa_ok( $result,      'NULL',   'call to method getTaskUserRows ');
  $t->todo( "call to method getTaskUserRows using $aTask ");


  //checking method 'createTaskUserRows'
  $t->can_ok( $obj,      'createTaskUserRows',   'createTaskUserRows() is callable' );

  //$result = $obj->createTaskUserRows ( $aTaskUser);
  //$t->isa_ok( $result,      'NULL',   'call to method createTaskUserRows ');
  $t->todo( "call to method createTaskUserRows using $aTaskUser ");


  //checking method 'createGroupRow'
  $t->can_ok( $obj,      'createGroupRow',   'createGroupRow() is callable' );

  //$result = $obj->createGroupRow ( $aGroupwf);
  //$t->isa_ok( $result,      'NULL',   'call to method createGroupRow ');
  $t->todo( "call to method createGroupRow using $aGroupwf ");


  //checking method 'createDBConnectionsRows'
  $t->can_ok( $obj,      'createDBConnectionsRows',   'createDBConnectionsRows() is callable' );

  //$result = $obj->createDBConnectionsRows ( $aConnections);
  //$t->isa_ok( $result,      'NULL',   'call to method createDBConnectionsRows ');
  $t->todo( "call to method createDBConnectionsRows using $aConnections ");


  //checking method 'createReportTables'
  $t->can_ok( $obj,      'createReportTables',   'createReportTables() is callable' );

  //$result = $obj->createReportTables ( $aReportTables, $aReportTablesVars);
  //$t->isa_ok( $result,      'NULL',   'call to method createReportTables ');
  $t->todo( "call to method createReportTables using $aReportTables, $aReportTablesVars ");


  //checking method 'updateReportTables'
  $t->can_ok( $obj,      'updateReportTables',   'updateReportTables() is callable' );

  //$result = $obj->updateReportTables ( $aReportTables, $aReportTablesVars);
  //$t->isa_ok( $result,      'NULL',   'call to method updateReportTables ');
  $t->todo( "call to method updateReportTables using $aReportTables, $aReportTablesVars ");


  //checking method 'createReportTablesVars'
  $t->can_ok( $obj,      'createReportTablesVars',   'createReportTablesVars() is callable' );

  //$result = $obj->createReportTablesVars ( $aReportTablesVars);
  //$t->isa_ok( $result,      'NULL',   'call to method createReportTablesVars ');
  $t->todo( "call to method createReportTablesVars using $aReportTablesVars ");


  //checking method 'cleanupReportTablesReferences'
  $t->can_ok( $obj,      'cleanupReportTablesReferences',   'cleanupReportTablesReferences() is callable' );

  //$result = $obj->cleanupReportTablesReferences ( $aReportTables);
  //$t->isa_ok( $result,      'NULL',   'call to method cleanupReportTablesReferences ');
  $t->todo( "call to method cleanupReportTablesReferences using $aReportTables ");


  //checking method 'serializeProcess'
  $t->can_ok( $obj,      'serializeProcess',   'serializeProcess() is callable' );

  //$result = $obj->serializeProcess ( $sProUid);
  //$t->isa_ok( $result,      'NULL',   'call to method serializeProcess ');
  $t->todo( "call to method serializeProcess using $sProUid ");


  //checking method 'saveSerializedProcess'
  $t->can_ok( $obj,      'saveSerializedProcess',   'saveSerializedProcess() is callable' );

  //$result = $obj->saveSerializedProcess ( $oData);
  //$t->isa_ok( $result,      'NULL',   'call to method saveSerializedProcess ');
  $t->todo( "call to method saveSerializedProcess using $oData ");


  //checking method 'getProcessData'
  $t->can_ok( $obj,      'getProcessData',   'getProcessData() is callable' );

  //$result = $obj->getProcessData ( $pmFilename);
  //$t->isa_ok( $result,      'NULL',   'call to method getProcessData ');
  $t->todo( "call to method getProcessData using $pmFilename ");


  //checking method 'disablePreviousProcesses'
  $t->can_ok( $obj,      'disablePreviousProcesses',   'disablePreviousProcesses() is callable' );

  //$result = $obj->disablePreviousProcesses ( $sProUid);
  //$t->isa_ok( $result,      'NULL',   'call to method disablePreviousProcesses ');
  $t->todo( "call to method disablePreviousProcesses using $sProUid ");


  //checking method 'createFiles'
  $t->can_ok( $obj,      'createFiles',   'createFiles() is callable' );

  //$result = $obj->createFiles ( $oData, $pmFilename);
  //$t->isa_ok( $result,      'NULL',   'call to method createFiles ');
  $t->todo( "call to method createFiles using $oData, $pmFilename ");


  //checking method 'removeProcessRows'
  $t->can_ok( $obj,      'removeProcessRows',   'removeProcessRows() is callable' );

  //$result = $obj->removeProcessRows ( $sProUid);
  //$t->isa_ok( $result,      'NULL',   'call to method removeProcessRows ');
  $t->todo( "call to method removeProcessRows using $sProUid ");


  //checking method 'createProcessFromData'
  $t->can_ok( $obj,      'createProcessFromData',   'createProcessFromData() is callable' );

  //$result = $obj->createProcessFromData ( $oData, $pmFilename);
  //$t->isa_ok( $result,      'NULL',   'call to method createProcessFromData ');
  $t->todo( "call to method createProcessFromData using $oData, $pmFilename ");


  //checking method 'updateProcessFromData'
  $t->can_ok( $obj,      'updateProcessFromData',   'updateProcessFromData() is callable' );

  //$result = $obj->updateProcessFromData ( $oData, $pmFilename);
  //$t->isa_ok( $result,      'NULL',   'call to method updateProcessFromData ');
  $t->todo( "call to method updateProcessFromData using $oData, $pmFilename ");


  //checking method 'getStartingTaskForUser'
  $t->can_ok( $obj,      'getStartingTaskForUser',   'getStartingTaskForUser() is callable' );

  //$result = $obj->getStartingTaskForUser ( $sProUid, $sUsrUid);
  //$t->isa_ok( $result,      'NULL',   'call to method getStartingTaskForUser ');
  $t->todo( "call to method getStartingTaskForUser using $sProUid, $sUsrUid ");


  //checking method 'ws_open'
  $t->can_ok( $obj,      'ws_open',   'ws_open() is callable' );

  //$result = $obj->ws_open ( $user, $pass);
  //$t->isa_ok( $result,      'NULL',   'call to method ws_open ');
  $t->todo( "call to method ws_open using $user, $pass ");


  //checking method 'ws_open_public'
  $t->can_ok( $obj,      'ws_open_public',   'ws_open_public() is callable' );

  //$result = $obj->ws_open_public ( );
  //$t->isa_ok( $result,      'NULL',   'call to method ws_open_public ');
  $t->todo( "call to method ws_open_public using  ");


  //checking method 'ws_processList'
  $t->can_ok( $obj,      'ws_processList',   'ws_processList() is callable' );

  //$result = $obj->ws_processList ( );
  //$t->isa_ok( $result,      'NULL',   'call to method ws_processList ');
  $t->todo( "call to method ws_processList using  ");


  //checking method 'downloadFile'
  $t->can_ok( $obj,      'downloadFile',   'downloadFile() is callable' );

  //$result = $obj->downloadFile ( $file, $local_path, $newfilename);
  //$t->isa_ok( $result,      'NULL',   'call to method downloadFile ');
  $t->todo( "call to method downloadFile using $file, $local_path, $newfilename ");


  //checking method 'ws_processGetData'
  $t->can_ok( $obj,      'ws_processGetData',   'ws_processGetData() is callable' );

  //$result = $obj->ws_processGetData ( $proId);
  //$t->isa_ok( $result,      'NULL',   'call to method ws_processGetData ');
  $t->todo( "call to method ws_processGetData using $proId ");



  $t->todo (  'review all pendings methods in this class');