TST_tpCondRet TST_EfetuarComando ( char * ComandoTeste )
{
int numLidos = -1 ,
CondRetEsp = -1 ,
pDado1 = -1 ,
pDado2 = -1 ;
/* Testar Jogar Dados */
if ( strcmp ( ComandoTeste , CMD_JOGAR_DADOS ) == 0 )
{
numLidos = LER_LerParametros ( "i" ,
&CondRetEsp ) ;
if ( numLidos != 1 )
{
return TST_CondRetParm ;
} /* if */
return TST_CompararInt ( CondRetEsp , DAD_JogarDados ( &pDado1 , &pDado2 ) ,
"Retorno diferente do esperado." ) ;
} /* Fim da ativa: Jogar Dados */
return TST_CondRetNaoConhec ;
} /* Fim função: TST Efetuar Comando */
LIS_tpCondRet VerificaLista (LIS_tppLista pLista)
{
LIS_tppLista ant = NULL;
tpElemLista * aux;
int elementosPercorridos = 1 ;
printf("verificar lista 1\n");
if( pLista == NULL )
{
return LIS_CondRetOK;
}/*if*/
aux = pLista->pOrigemLista;
printf("verificar lista 2\n");
if( aux->pAnt != NULL )
{
CNT_CONTAR ("LIS_ErroPrimeiro") ;
CNT_CONTAR (CONTADOR_FALHAS_ESTRUTURA) ; //algo antes do primeiro elemento
}/* if */
printf("verificar lista 3\n");
do
{
printf("HAHAHA: %d, %d\n",LIS_TipoEspacoElemento,CED_ObterTipoEspaco(aux));
if(TST_CompararInt(LIS_TipoEspacoElemento,CED_ObterTipoEspaco(aux),"Tipo de espaço do elemento não é elemento da lista")!=TST_CondRetOK)
{
CNT_CONTAR(CONTADOR_FALHAS_ESTRUTURA);
printf("vai retornar\n");
return LIS_CondRetErroEstrutura;
}
printf("--\n");
if(TST_CompararPonteiro(aux->pProx->pAnt,aux,"Erro no ponteiro para proximo")!=TST_CondRetOK)
{
CNT_CONTAR ("LIS_ErroProximo") ;
CNT_CONTAR (CONTADOR_FALHAS_ESTRUTURA) ;
}/*if*/
aux=aux->pProx ;
elementosPercorridos++;
} while(aux->pProx!=NULL);
printf("verificar lista 4\n");
if(elementosPercorridos!=pLista->numElem)
{
CNT_CONTAR ("LIS_ErroNumElem") ;
CNT_CONTAR (CONTADOR_FALHAS_ESTRUTURA) ; //numero de elementos percorridos é diferente do numero da cabeça da lista
}/* if */
printf("verificar lista 5\n");
if(TST_CompararPonteiro(pLista->pFimLista,aux,"Ultimo elemento nao e o esperado.")!=TST_CondRetOK)
{
CNT_CONTAR ("LIS_ErroUltimo") ;
CNT_CONTAR (CONTADOR_FALHAS_ESTRUTURA) ;
}/* if */
return LIS_CondRetOK;
}
LIS_tpCondRet verificaElemento (void * ppElem, int* f)
{
struct tagElemLista * pElem;
int falha = 0;
pElem = (tpElemLista*)(ppElem);
CNT_CONTAR("verificaElem");
// marca elemento ativo
CED_MarcarEspacoAtivo(pElem);
// verifica tipo de dado do elemento
if ( TST_CompararInt( LIS_TipoElemento ,
CED_ObterTipoEspaco( pElem) ,
"Tipo do espaço de dados não é elemento da lista." ) != TST_CondRetOK )
{
CNT_CONTAR("VerificaElemif0");
falha++;
}
else CNT_CONTAR("NaoVerificaElemTipoif0");
// marca o campo valor como ativo
CED_MarcarEspacoAtivo(pElem->pValor);
*f = falha;
return LIS_CondRetOK;
}
TST_tpCondRet InterpretarComandos( char * ComandoTeste )
{
TST_tpCondRet CondRetornada = TST_CondRetErro ;
int IntEsp = -1 ,
numLidos = -1 ;
/* Tratar comando de recuperação de falhas acumuladas */
if ( strcmp( ComandoTeste , ACEITA_ERRO_CMD ) == 0 )
{
numLidos = LER_LerParametros( "i" , &IntEsp ) ;
if ( numLidos != 1 )
{
return TST_CondRetParm ;
} /* if */
if ( IntEsp == ContaFalhas )
{
ContaFalhas = 0 ;
TST_ExibirPrefixo( "<<<" , "Falhas registradas eram esperadas e foram recuperadas." ) ;
return TST_CondRetOK ;
} /* if */
return TST_CompararInt( IntEsp , ContaFalhas ,
"Número de falhas esperadas errado." ) ;
} /* fim ativa: Tratar comando de recuperação de falhas acumuladas */
/* Interpretar comandos de leitura */
CondRetornada = LER_InterpretarComandos( ComandoTeste ) ;
if ( CondRetornada != TST_CondRetNaoExecutou )
{
return CondRetornada ;
} /* if */
/* Interpretar comandos de contagem */
CondRetornada = ICNT_EfetuarComadoContagem( ComandoTeste ) ;
if ( CondRetornada != TST_CondRetNaoExecutou )
{
return CondRetornada ;
} /* if */
/* Interpretar comandos de controle de acesso */
CondRetornada = ICED_InterpretarTesteEspaco( ComandoTeste ) ;
if ( CondRetornada != TST_CondRetNaoExecutou )
{
return CondRetornada ;
} /* if */
/* Interpretar comandos específicos do módulo a testar */
return TST_EfetuarComando( ComandoTeste ) ;
} /* Fim função: TSTG -Efetuar os comandos de teste específicos */
TST_tpCondRet TST_EfetuarComando(char * ComandoTeste)
{
int numLidos = -1,
CondRetEsp = -1,
dado1,
dado2;
/* testar jogar dados */
if (strcmp(ComandoTeste, JOGAR_DADOS_CMD) == 0)
{
numLidos = LER_LerParametros("i",
&CondRetEsp);
if (numLidos != 1) {
return TST_CondRetParm;
} /* if */
return TST_CompararInt(CondRetEsp, DAD_JogarDados(&dado1, &dado2),
"Condicao de retorno errada ao jogar dados.");
} /* Fim ativa: Testar jogar dado */
return TST_CondRetNaoConhec;
} /* Fim função: TDAD &Testar dado */
LIS_tpCondRet LIS_VerificarElemento(LIS_tppLista lista)
{
LIS_tpElemLista *elem = lista->pElemCorr;
CNT_CONTAR("Verificar elemento");
if (elem == NULL)
{
CNT_CONTAR("Elemento nulo");
TST_NotificarFalha("Tentou verificar elemento nulo.");
return LIS_CondRetErroEstrutura;
}
CNT_CONTAR("Elemento nao nulo");
if (TST_CompararInt(4, /*TAB_TipoEspacoElemento*/
CED_ObterTipoEspaco(elem),
"Tipo do espaco de dados nao é um elemento.") != TST_CondRetOK )
{
CNT_CONTAR("Tipo elemento invalido");
return LIS_CondRetErroEstrutura;
}
CNT_CONTAR("Tipo elemento valido");
if (elem->pProx == NULL && elem->pAnt == NULL)
{
CNT_CONTAR("Elemento solto");
TST_NotificarFalha("Elemento esta solto");
return LIS_CondRetErroEstrutura;
}
CNT_CONTAR("Elemento ligado");
CED_MarcarEspacoAtivo(elem);
CNT_CONTAR("Acaba verificar elemento");
return LIS_CondRetOK;
} /* Fim funcao: LIS &Verificar elemento */
TST_tpCondRet TST_EfetuarComando( char * CmdTeste )
{
int argc, Ret, ExpectedRet, iGraph, iData;
if(! strcmp( CmdTeste , GRAPHNEW_CMD) ){
argc = LER_LerParametros ( "i", &iGraph );
if ( argc != 1
|| iGraph < 0 || iGraph > MAXGRAPHS)
return TST_CondRetParm;
vGraph[iGraph] = GRA_New ( DelData );
return TST_CompararPonteiroNulo( 1 , vGraph[iGraph],
"Erro: Ponteiro para novo grafo e' nulo." );
#ifdef _DEBUG
}else if(! strcmp( CmdTeste , SHOW_MEMSPACES) ){
CED_ExibirTodosEspacos( CED_ExibirTodos );
return TST_CondRetOK;
#endif
}else if(! strcmp( CmdTeste , GRAPHDEL_CMD) ){
argc = LER_LerParametros ( "i", &iGraph );
if ( argc != 1
|| iGraph < 0 || iGraph > MAXGRAPHS)
return TST_CondRetParm;
GRA_Del ( vGraph[iGraph] );
vGraph[iGraph] = NULL;
return TST_CondRetOK;
}else if(! strcmp( CmdTeste , GRAPHCCUR_CMD) ){
argc = LER_LerParametros ( "iii", &iGraph, &iData,
&ExpectedRet);
if ( argc != 3
|| iGraph < 0 || iGraph > MAXGRAPHS
|| iData < 0 || iData > MAXDATAS )
return TST_CondRetParm;
Ret = GRA_CCurrent ( vGraph[iGraph], vData[iData] );
return TST_CompararInt( ExpectedRet , Ret ,
"Erro: Condicao de retorno errada em CCurent.");
}else if(! strcmp( CmdTeste , GRAPHNEWNODE_CMD) ){
argc = LER_LerParametros ( "iii", &iGraph, &iData,
&ExpectedRet);
if ( argc != 3
|| iGraph < 0 || iGraph > MAXGRAPHS
|| iData < 0 || iData > MAXDATAS )
return TST_CondRetParm;
Ret = GRA_NewNode ( vGraph[iGraph], vData[iData] );
return TST_CompararInt( ExpectedRet , Ret ,
"Erro: Condicao de retorno errada em NewNode.");
}else if(! strcmp( CmdTeste , GRAPHDELNODE_CMD) ){
argc = LER_LerParametros ( "i", &iGraph);
if ( argc != 1
|| iGraph < 0 || iGraph > MAXGRAPHS)
return TST_CondRetParm;
GRA_DelNode ( vGraph[iGraph] );
return TST_CondRetOK;
}else if(! strcmp( CmdTeste , GRAPHADDLINK_CMD) ){
argc = LER_LerParametros ( "iii", &iGraph, &iData,
&ExpectedRet);
if ( argc != 3
|| iGraph < 0 || iGraph > MAXGRAPHS
|| iData < 0 || iData > MAXDATAS )
return TST_CondRetParm;
Ret = GRA_AddLink ( vGraph[iGraph], vData[iData] );
return TST_CompararInt( ExpectedRet , Ret ,
"Erro: Condicao de retorno errada em AddLink.");
}else if(! strcmp( CmdTeste , GRAPHREMLINK_CMD) ){
argc = LER_LerParametros ( "iii", &iGraph, &iData,
&ExpectedRet);
if ( argc != 3
|| iGraph < 0 || iGraph > MAXGRAPHS
|| iData < 0 || iData > MAXDATAS )
return TST_CondRetParm;
Ret = GRA_RemLink ( vGraph[iGraph], vData[iData] );
return TST_CompararInt( ExpectedRet , Ret ,
"Erro: Condicao de retorno errada em RemLink.");
}else if(! strcmp( CmdTeste , GRAPHGETDATA_CMD) ){
argc = LER_LerParametros ( "ii", &iGraph, &iData);
if ( argc != 2
|| iGraph < 0 || iGraph > MAXGRAPHS
|| iData < 0 || iData > MAXDATAS )
return TST_CondRetParm;
vData[iData] = GRA_GetData ( vGraph[iGraph]);
return TST_CompararPonteiroNulo( 1 , vData[iData],
"Erro: GetData retornou NULL. Ainda assim, NULL\
foi armazenado" );
}else if (! strcmp( CmdTeste , GRAPHNODESSTART_CMD) ){
TST_tpCondRet TST_EfetuarComando( char * ComandoTeste )
{
int numLidos = -1 ,
CondRetEsp = -1 ,
CondRetObt = -1 ;
/* Inicializa para qualquer coisa */
/* Testar Criar Grafo */
if( strcmp( ComandoTeste , CRIAR_GRAFO_CMD ) == 0 )
{
numLidos = LER_LerParametros ( "i" ,
&CondRetEsp ) ;
if ( numLidos != 1 )
{
return TST_CondRetParm ;
}/* if */
CondRetObt = GRF_CriarGrafo ( &pGrafo , CHR_DestruirCaracter ) ;
return TST_CompararInt ( CondRetEsp , CondRetObt ,
"Retorno errado ao criar grafo.") ;
} /* fim ativa: Testar Criar Grafo */
/* Testar Destroi Grafo */
else if ( strcmp( ComandoTeste , DESTROI_GRAFO_CMD ) == 0 )
{
numLidos = LER_LerParametros( "i" ,
&CondRetEsp ) ;
if ( numLidos != 1 )
{
return TST_CondRetParm ;
} /* if */
GRF_DestroiGrafo ( pGrafo ) ;
CondRetObt=GRF_CondRetOK;
pGrafo = NULL ;
return TST_CompararInt( CondRetEsp , CondRetObt ,
"Retorno errado ao destruir o Grafo." );
} /* fim ativa: Testar Destroi Grafo */
/* Testar Insere Vertice */
else if ( strcmp( ComandoTeste , INSERE_VERTICE_CMD ) == 0 )
{
CHR_tppCaracter pCaracter ;
char ValorVertice ;
int ChaveVertice;
numLidos = LER_LerParametros( "ici" ,
&ChaveVertice, &ValorVertice , &CondRetEsp ) ;
if ( numLidos != 3 || ChaveVertice<0 )
{
return TST_CondRetParm ;
} /* if */
pCaracter = CHR_CriarCaracter ( ValorVertice ) ;
if ( pCaracter == NULL )
{
return TST_CondRetMemoria ;
}
CondRetObt = GRF_CriaVertice ( pGrafo , pCaracter, ChaveVertice ) ;
return TST_CompararInt( CondRetEsp , CondRetObt ,
"Retorno errado ao criar o vertice." );
} /* fim ativa: Testar Cria Vertice */
/* Testar Cria Aresta */
else if ( strcmp( ComandoTeste , CRIA_ARESTA_CMD ) == 0 )
{
int verticeA , verticeB ;
numLidos = LER_LerParametros( "iii" ,
&verticeA , &verticeB , &CondRetEsp ) ;
if ( numLidos != 3 )
{
return TST_CondRetParm ;
} /* if */
CondRetObt = GRF_CriaAresta ( pGrafo, verticeA , verticeB ) ;
return TST_CompararInt( CondRetEsp , CondRetObt ,
"Retorno errado ao criar a aresta." );
} /* fim ativa: Testar Cria Aresta */
/*Testar Remove Aresta */
else if ( strcmp( ComandoTeste, REMOVE_ARESTA_CMD) ==0)
{
int verticeA , verticeB ;
numLidos = LER_LerParametros( "iii" ,
&verticeA , &verticeB , &CondRetEsp ) ;
if ( numLidos != 3 )
{
return TST_CondRetParm ;
} /* if */
CondRetObt = GRF_RemoveAresta ( pGrafo,verticeA , verticeB) ;
return TST_CompararInt( CondRetEsp , CondRetObt ,
"Retorno errado ao remover a aresta." );
}
/* fim ativa: Testar Criar Aresta */
/* Testar Obtem Caminho */
else if ( strcmp( ComandoTeste , EXISTE_CAMINHO_CMD ) == 0 )
{
int verticeOrigem , verticeDestino ;
numLidos = LER_LerParametros( "iii" ,
&verticeOrigem , &verticeDestino , &CondRetEsp ) ;
if ( numLidos != 3 )
{
return TST_CondRetParm ;
} /* if */
CondRetObt=GRF_ObtemCaminho ( pGrafo , verticeOrigem, verticeDestino,NULL) ;
return TST_CompararInt( CondRetEsp , CondRetObt ,
"Retorno errado ao verificar se existe caminho entre os vertices." );
} /* fim ativa: Testar Obtem Caminho */
/* Testar Existe Vertice */
else if ( strcmp( ComandoTeste , EXISTE_VERTICE_CMD ) == 0 )
{
int chaveVertice ;
numLidos = LER_LerParametros( "ii" , &chaveVertice,
&CondRetEsp ) ;
if ( numLidos != 2 )
{
return TST_CondRetParm ;
} /* if */
CondRetObt = GRF_ExisteVertice ( pGrafo , chaveVertice ) ;
return TST_CompararInt( CondRetEsp , CondRetObt ,
"Retorno errado ao verificar se existe vertice." );
} /* fim ativa: Testar Existe Vertice */
/* Testar Esvazia Grafo */
else if ( strcmp( ComandoTeste , ESVAZIA_GRAFO_CMD ) == 0 )
{
numLidos = LER_LerParametros( "i" ,
&CondRetEsp ) ;
if ( numLidos != 1 )
{
return TST_CondRetParm ;
} /* if */
CondRetObt=GRF_EsvaziaGrafo ( pGrafo ) ;
return TST_CompararInt( CondRetEsp , CondRetObt ,
"Retorno errado ao esvaziar o grafo." );
} /* fim ativa: Testar Esvazia Grafo */
/* Testar Altera Corrente */
else if ( strcmp( ComandoTeste, ALTERA_CORR_CMD ) == 0 )
{
int vertice;
numLidos = LER_LerParametros( "ii", &vertice, &CondRetEsp);
if ( numLidos != 2)
{
return TST_CondRetParm;
} /*if*/
CondRetObt = GRF_AlteraCorrente ( pGrafo, vertice );
return TST_CompararInt( CondRetEsp, CondRetObt,
"Retorno errado ao alterar a corrente" );
}/* fim ativa: Testar Altera Corrente */
/* Testar Existe Aresta */
else if( strcmp( ComandoTeste, EXISTE_ARESTA_CMD ) == 0 )
{
int verticeA, verticeB;
numLidos = LER_LerParametros ( "iii", &verticeA, &verticeB, &CondRetEsp);
if( numLidos != 3 )
{
return TST_CondRetParm;
}/*if*/
CondRetObt = GRF_ExisteAresta ( pGrafo, verticeA, verticeB);
return TST_CompararInt( CondRetEsp, CondRetObt,
"Retorno errado na existe aresta");
}/* fim ativa: Testar Altera Corrente */
/* Testar Ir Vizinho*/
else if( strcmp( ComandoTeste, IR_VIZINHO_CMD ) == 0 )
{
int vertice;
numLidos = LER_LerParametros( "ii", &vertice, &CondRetEsp);
if( numLidos != 2)
{
return TST_CondRetParm;
}/*if*/
CondRetObt = GRF_IrVizinho ( pGrafo, vertice );
return TST_CompararInt( CondRetEsp , CondRetObt,
"Retorno errado ao ir vizinho");
}/* fim ativa: Testar Ir Vizinho */
/* Testar Obter Corrente*/
else if( strcmp(ComandoTeste, OBTER_CORR_CMD ) == 0)
{
int verticeEsperado, verticeObtido;
char valorEsperado;
void* temp;
char valorObtido;
TST_tpCondRet Ret;
numLidos = LER_LerParametros( "ici", &verticeEsperado, &valorEsperado, &CondRetEsp);
if( numLidos != 3)
{
return TST_CondRetParm;
}/*if*/
CondRetObt = GRF_ObterCorr ( pGrafo, &verticeObtido, &temp);
Ret = TST_CompararInt( CondRetEsp , CondRetObt,
"Retorno errado ao obter corrente");
if ( Ret != TST_CondRetOK)
{
return Ret;
}/*if*/
if ( CondRetEsp != GRF_CondRetOK )
{
return TST_CondRetOK;
}/*if*/
Ret = TST_CompararInt( verticeEsperado, verticeObtido,
"Retorno errado ao obter corrente");
if ( Ret != TST_CondRetOK)
{
return Ret;
}/*if*/
valorObtido = CHR_ObterValor((CHR_tppCaracter)temp);
return TST_CompararChar( valorEsperado, valorObtido,
"Retorno errado ao obter corrente");
}/* fim ativa: Testar Obter Corrente */
/* Testar Alterar Valor Corr*/
else if ( strcmp( ComandoTeste, ALTERA_VALOR_CORR_CMD ) == 0 )
{
char valor;
CHR_tppCaracter pCaracter;
numLidos = LER_LerParametros( "ci", &valor, &CondRetEsp);
if( numLidos != 2)
{
return TST_CondRetParm;
}/*if*/
pCaracter = CHR_CriarCaracter (valor);
CondRetObt = GRF_AlterarValorCorr ( pGrafo, (void*)pCaracter);
return TST_CompararInt ( CondRetEsp, CondRetObt,
"Retorno errado ao alterar valor corrente");
}/* fim ativa: Testar Alterar Valor Corr */
/* Testar Caminhar*/
else if( strcmp( ComandoTeste, CAMINHAR_CMD ) == 0 )
{
int vertice;
numLidos = LER_LerParametros ( "ii", &vertice, &CondRetEsp);
if( numLidos != 2 )
{
return TST_CondRetParm;
}/*if*/
CondRetObt = GRF_Caminhar( pGrafo , vertice );
return TST_CompararInt( CondRetEsp, CondRetObt,
"Retorno errado ao caminhar");
}/* fim ativa: Testar Caminhar */
return TST_CondRetNaoConhec;
} /* Fim função: TGRF &Testar Grafo */
TST_tpCondRet TST_EfetuarComando(char * ComandoTeste)
{
int numLidos = -1,
CondRetEsp = -1,
jogador,
pontuacao,
pontuacaoEsp,
jogadorEsp;
TST_tpCondRet Ret;
DAP_tpCondRet CondRet;
/* testar criar um dadopontos */
if (strcmp(ComandoTeste, CRIAR_DADOPONTOS_CMD) == 0)
{
numLidos = LER_LerParametros("i",
&CondRetEsp);
if (numLidos != 1) {
return TST_CondRetParm;
} /* if */
CondRet =DAP_CriarDadoPontos(&pDadoPontos);
return TST_CompararInt(CondRetEsp, CondRet,
"Condicao de retorno errada ao criar dadopontos.");
} /* Fim ativa: Testar criar um dadopontos */
/* Testar destruir um dadopontos */
else if (strcmp(ComandoTeste, DESTRUIR_DADOPONTOS_CMD) == 0)
{
numLidos = LER_LerParametros("i",
&CondRetEsp);
if (numLidos != 1) {
return TST_CondRetParm;
} /* if */
CondRet =DAP_DestruirDadoPontos(&pDadoPontos);
return TST_CompararInt(CondRetEsp, CondRet,
"Condicao de retorno errada ao destruir dadopontos.");
} /* Fim ativa: Testar destruir dadopontos */
/* Testar dobrar pontuacao */
else if (strcmp(ComandoTeste, DOBRAR_PONTUACAO_CMD) == 0)
{
numLidos = LER_LerParametros("ii",
&jogador, &CondRetEsp);
if (numLidos != 2) {
return TST_CondRetParm;
} /* if */
CondRet = DAP_DobrarPontuacao(&pDadoPontos, jogador);
return TST_CompararInt(CondRetEsp, CondRet,
"Condicao de retorno errada ao dobrar pontuacao.");
} /* Fim ativa: Testar dobrar pontuacao */
/* Testar obter pontuacao */
else if (strcmp(ComandoTeste, OBTER_PONTUACAO_CMD) == 0)
{
numLidos = LER_LerParametros("ii",
&pontuacaoEsp, &CondRetEsp);
if (numLidos != 2) {
return TST_CondRetParm;
} /* if */
CondRet = DAP_ObterPontuacao(pDadoPontos, &pontuacao);
Ret = TST_CompararInt(CondRetEsp, CondRet,
"Condicao de retorno errada ao obter pontuacao.");
if (Ret != TST_CondRetOK)
return Ret;
if (CondRet == DAP_CondRetDadoPontosNaoExiste)
return TST_CondRetOK;
return TST_CompararInt(pontuacaoEsp, pontuacao, "pontuacao errada");
} /* Fim ativa: Testar obter pontuacao */
/* Testar obter ultima dobra */
else if (strcmp(ComandoTeste, OBTER_ULTIMA_DOBRA_CMD) == 0)
{
numLidos = LER_LerParametros("ii",
&jogadorEsp, &CondRetEsp);
if (numLidos != 2) {
return TST_CondRetParm;
} /* if */
CondRet = DAP_ObterUltimaDobra(pDadoPontos, &jogador);
Ret = TST_CompararInt(CondRetEsp, CondRet,
"Condicao de retorno errada ao obter ultimo jogador a dobrar.");
if (Ret != TST_CondRetOK)
return Ret;
if (CondRet == DAP_CondRetDadoPontosNaoExiste)
return TST_CondRetOK;
return TST_CompararInt(jogadorEsp, jogador, "jogador errado");
} /* Fim ativa: Testar obter ultima dobra */
return TST_CondRetNaoConhec;
} /* Fim função: TDAP &Testar dadopontos */
TST_tpCondRet TST_EfetuarComando(char * ComandoTeste)
{
int inxLista = -1, numLidos = -1, CondRetEsp = -1;
TST_tpCondRet CondRet;
char StringDado[DIM_VALOR];
char * pDado;
int IntDado[DIM_VALOR_INT];
int* pDadoInt;
int ValEsp = -1;
int i;
int numElem = -1;
int inxStoredPtr;
for(i = 0; i < DIM_VT_LISTA; i++)
storedPtr[i][0] = NULL;
StringDado[0] = 0;
/* Efetuar reset de teste de lista */
if(strcmp(ComandoTeste, RESET_LISTA_CMD) == 0) {
for(i = 0; i < DIM_VT_LISTA; i++) {
vtListas[i] = NULL;
storedPtrIndex[i] = 1;
}
return TST_CondRetOK;
} /* fim ativa: Efetuar reset de teste de lista */
/* Testar CriarLista */
else if(strcmp(ComandoTeste, CRIAR_LISTA_CMD) == 0) {
numLidos = LER_LerParametros("i", &inxLista);
if((numLidos != 1) || (!ValidarInxLista(inxLista, VAZIO)))
return TST_CondRetParm;
vtListas[inxLista] = LIS_CriarLista(DestruirValor);
return TST_CompararPonteiroNulo(1, vtListas[inxLista], "Erro em ponteiro de nova lista.");
} /* fim ativa: Testar CriarLista */
/* Testar Esvaziar lista lista */
else if(strcmp(ComandoTeste, ESVAZIAR_LISTA_CMD) == 0) {
numLidos = LER_LerParametros("i", &inxLista);
if((numLidos != 1) || (!ValidarInxLista(inxLista, NAO_VAZIO)))
return TST_CondRetParm;
LIS_EsvaziarLista(vtListas[inxLista]);
return TST_CondRetOK;
} /* fim ativa: Testar Esvaziar lista lista */
/* Testar Destruir lista */
else if(strcmp(ComandoTeste, DESTRUIR_LISTA_CMD) == 0) {
numLidos = LER_LerParametros("i", &inxLista);
if((numLidos != 1) || (!ValidarInxLista(inxLista, NAO_VAZIO)))
return TST_CondRetParm;
LIS_DestruirLista(vtListas[inxLista]);
vtListas[inxLista] = NULL;
return TST_CondRetOK;
} /* fim ativa: Testar Destruir lista */
/* Testar inserir elemento antes */
else if(strcmp(ComandoTeste, INS_ELEM_ANTES_CMD) == 0) {
numLidos = LER_LerParametros("isi", &inxLista, StringDado, &CondRetEsp);
if((numLidos != 3) || (!ValidarInxLista(inxLista, NAO_VAZIO)))
return TST_CondRetParm;
if(!ValidarInxStoredPtr(storedPtrIndex[inxLista]))
return TST_CondRetMemoria;
pDado = (char *) malloc(strlen(StringDado) + 1);
if(pDado == NULL)
return TST_CondRetMemoria;
storedPtr[inxLista][storedPtrIndex[inxLista]++] = pDado;
strcpy(pDado, StringDado);
CondRet = LIS_InserirElementoAntes(vtListas[inxLista], pDado);
if(CondRet != LIS_CondRetOK)
free(pDado);
return TST_CompararInt(CondRetEsp, CondRet, "Condicao de retorno errada ao inserir antes.");
} /* fim ativa: Testar inserir elemento antes */
/* Testar inserir elemento antes INTEIRO */
else if(strcmp(ComandoTeste, INS_ELEM_ANTES_CMD_INT) == 0) {
numLidos = LER_LerParametros("iiii", &inxLista, &IntDado[0], &IntDado[1], &CondRetEsp);
if((numLidos != 4) || (!ValidarInxLista(inxLista, NAO_VAZIO)))
return TST_CondRetParm;
if(!ValidarInxStoredPtr(storedPtrIndex[inxLista]))
return TST_CondRetMemoria;
pDadoInt = (int *) malloc(DIM_VALOR_INT*sizeof(int));
if(pDadoInt == NULL)
return TST_CondRetMemoria;
storedPtr[inxLista][storedPtrIndex[inxLista]++] = pDadoInt;
for(i=0;i<DIM_VALOR_INT;i++)
pDadoInt[i]=IntDado[i];
CondRet = LIS_InserirElementoAntes(vtListas[inxLista], pDadoInt);
if(CondRet != LIS_CondRetOK)
free(pDadoInt);
return TST_CompararInt(CondRetEsp, CondRet, "Condicao de retorno errada ao inserir antes.");
} /* fim ativa: Testar inserir elemento antes INTEIRO*/
/* Testar inserir elemento apos */
else if(strcmp(ComandoTeste, INS_ELEM_APOS_CMD) == 0) {
numLidos = LER_LerParametros("isi", &inxLista, StringDado, &CondRetEsp);
if((numLidos != 3) || (!ValidarInxLista(inxLista, NAO_VAZIO)))
return TST_CondRetParm;
if(!ValidarInxStoredPtr(storedPtrIndex[inxLista]))
return TST_CondRetMemoria;
pDado = (char*)malloc(strlen(StringDado) + 1);
if(pDado == NULL)
return TST_CondRetMemoria;
storedPtr[inxLista][storedPtrIndex[inxLista]++] = pDado;
strcpy(pDado, StringDado);
CondRet = LIS_InserirElementoApos(vtListas[inxLista], pDado);
if(CondRet != LIS_CondRetOK)
free(pDado);
return TST_CompararInt(CondRetEsp, CondRet, "Condicao de retorno errada ao inserir apos.");
} /* fim ativa: Testar inserir elemento apos */
/* Testar inserir elemento apos INTEIRO*/
else if(strcmp(ComandoTeste, INS_ELEM_APOS_CMD_INT) == 0) {
numLidos = LER_LerParametros("iiii", &inxLista, &IntDado[0], &IntDado[1], &CondRetEsp);
if((numLidos != 4) || (!ValidarInxLista(inxLista, NAO_VAZIO)))
return TST_CondRetParm;
if(!ValidarInxStoredPtr(storedPtrIndex[inxLista]))
return TST_CondRetMemoria;
pDadoInt = (int *) malloc(DIM_VALOR_INT * sizeof(int));
if(pDadoInt == NULL)
return TST_CondRetMemoria;
storedPtr[inxLista][storedPtrIndex[inxLista]++] = pDadoInt;
for(i=0;i<DIM_VALOR_INT;i++)
pDadoInt[i]=IntDado[i];
CondRet = LIS_InserirElementoApos(vtListas[inxLista], pDadoInt);
if(CondRet != LIS_CondRetOK)
free(pDadoInt);
return TST_CompararInt(CondRetEsp, CondRet, "Condicao de retorno errada ao inserir apos.");
} /* fim ativa: Testar inserir elemento apos INTEIRO*/
/* Testar excluir simbolo */
else if(strcmp(ComandoTeste, EXC_ELEM_CMD) == 0) {
numLidos = LER_LerParametros("ii", &inxLista, &CondRetEsp);
if((numLidos != 2) || (!ValidarInxLista(inxLista, NAO_VAZIO)))
return TST_CondRetParm;
return TST_CompararInt(CondRetEsp, LIS_ExcluirElemento(vtListas[inxLista]),
"Condição de retorno errada ao excluir.");
} /* fim ativa: Testar excluir simbolo */
/* Testar obter valor do elemento corrente */
else if(strcmp(ComandoTeste, OBTER_VALOR_CMD) == 0) {
numLidos = LER_LerParametros("isi", &inxLista, StringDado, &ValEsp);
if((numLidos != 3) || (!ValidarInxLista(inxLista, NAO_VAZIO)))
return TST_CondRetParm;
pDado = (char *) LIS_ObterValor(vtListas[inxLista]);
if(ValEsp == 0)
return TST_CompararPonteiroNulo(0, pDado, "Valor não deveria existir.");
if(pDado == NULL)
return TST_CompararPonteiroNulo(1, pDado, "Dado tipo um deveria existir.");
return TST_CompararString(StringDado, pDado, "Valor do elemento errado.");
} /* fim ativa: Testar obter valor do elemento corrente */
/* Testar obter valor do elemento corrente INTEIRO*/
else if(strcmp(ComandoTeste, OBTER_VALOR_CMD_INT) == 0) {
numLidos = LER_LerParametros("iiii", &inxLista, &IntDado[0], &IntDado[1], &ValEsp);
if((numLidos != 4) || (!ValidarInxLista(inxLista, NAO_VAZIO)))
return TST_CondRetParm;
pDadoInt = (int *)LIS_ObterValor(vtListas[inxLista]);
if(ValEsp == 0)
return TST_CompararPonteiroNulo(0, pDadoInt, "Valor não deveria existir.");
if(pDadoInt == NULL)
return TST_CompararPonteiroNulo(1, pDadoInt, "Dado tipo um deveria existir.");
return TST_CompararEspaco(IntDado, pDadoInt, DIM_VALOR_INT * sizeof(int),
"Valor do elemento errado.");
} /* fim ativa: Testar obter valor do elemento corrente INTEIRO*/
/* Testar ir para o elemento inicial */
else if(strcmp(ComandoTeste, IR_INICIO_CMD) == 0) {
numLidos = LER_LerParametros("i", &inxLista);
if((numLidos != 1) || (!ValidarInxLista(inxLista, NAO_VAZIO)))
return TST_CondRetParm;
LIS_IrInicioLista(vtListas[inxLista]);
return TST_CondRetOK;
} /* fim ativa: Testar ir para o elemento inicial */
/* LIS &Ir para o elemento final */
else if(strcmp(ComandoTeste, IR_FIM_CMD) == 0) {
numLidos = LER_LerParametros("i", &inxLista);
if((numLidos != 1) || (!ValidarInxLista(inxLista, NAO_VAZIO)))
return TST_CondRetParm;
LIS_IrFinalLista(vtListas[inxLista]);
return TST_CondRetOK;
} /* fim ativa: LIS &Ir para o elemento final */
/* LIS &Avançar elemento */
else if(strcmp(ComandoTeste, AVANCAR_ELEM_CMD) == 0) {
numLidos = LER_LerParametros("iii", &inxLista, &numElem, &CondRetEsp);
if((numLidos != 3) || (!ValidarInxLista(inxLista, NAO_VAZIO)))
return TST_CondRetParm;
return TST_CompararInt(CondRetEsp,
LIS_AvancarElementoCorrente(vtListas[inxLista], numElem),
"Condicao de retorno errada ao avancar");
} /* fim ativa: LIS &Avançar elemento */
/* Testar Ir Indice */
else if(strcmp(ComandoTeste, IR_INDICE_CMD) == 0) {
numLidos = LER_LerParametros("iii", &inxLista, &numElem, &CondRetEsp);
if((numLidos != 3) || (!ValidarInxLista(inxLista, NAO_VAZIO)))
return TST_CondRetParm;
return TST_CompararInt(CondRetEsp, LIS_IrIndice(vtListas[inxLista], numElem),
"Condicao de retorno errada ao ir para o índice");
} /* fim ativa: Testar Ir Indice */
/* Testar Setar Valor INTEIRO*/
else if(strcmp(ComandoTeste, SETAR_VALOR_CMD_INT) == 0) {
numLidos = LER_LerParametros("iiii", &inxLista, &IntDado[0], &IntDado[1], &CondRetEsp);
if((numLidos != 4) || (!ValidarInxLista(inxLista, NAO_VAZIO)))
return TST_CondRetParm;
if(!ValidarInxStoredPtr(storedPtrIndex[inxLista]))
return TST_CondRetMemoria;
pDadoInt = (int *) malloc(DIM_VALOR_INT * sizeof(int));
if(pDadoInt == NULL)
return TST_CondRetMemoria;
storedPtr[inxLista][storedPtrIndex[inxLista]++] = pDadoInt;
for(i=0;i<DIM_VALOR_INT;i++)
pDadoInt[i]=IntDado[i];
return TST_CompararInt(CondRetEsp, LIS_SetarValor(vtListas[inxLista], pDadoInt),
"Condicao de retorno errada ao ir marcar o valor");
} /* fim ativa: LIS Setar Valor INTEIRO*/
/* Testar Procurar Valor */
else if(strcmp(ComandoTeste, PROCURAR_VALOR_CMD) == 0) {
numLidos = LER_LerParametros("iii", &inxLista, &inxStoredPtr, &CondRetEsp);
if((numLidos != 3) || (!ValidarInxLista(inxLista, NAO_VAZIO)))
return TST_CondRetParm;
if(!ValidarInxStoredPtr(inxStoredPtr))
return TST_CondRetParm;
return TST_CompararInt(CondRetEsp, LIS_ProcurarValor(vtListas[inxLista], storedPtr[inxLista][inxStoredPtr]),
"Condicao de retorno errada ao procurar valor");
} /* fim ativa: LIS Procurar Valor */
return TST_CondRetNaoConhec;
} /* Fim função: TLIS &Testar lista */
TST_tpCondRet TST_EfetuarComando( char * ComandoTeste )
{
int inxGrafo = -1 ,
numLidos = -1 ,
CondRetEsp = -1 ,
param, numErros;
char idVertice;
char idVertice2;
char StringDado[ DIM_VALOR ];
VER_tppVertice novoVertice;
TST_tpCondRet CondRet ;
void * pDado ;
char * pValor;
/* Testar criar Grafo */
if ( strcmp( ComandoTeste , CRIAR_GRAFO_CMD ) == 0 ) {
numLidos = LER_LerParametros( "ii" , &inxGrafo, &CondRetEsp ) ;
if ( ( numLidos != 2 ) || ( ValidarInxGrafo( inxGrafo , NAO_VAZIO ) ) )
{
return TST_CondRetParm ;
} /* if */
CondRet = GRA_CriarGrafo( &vtGRAFO[ inxGrafo ], DestruirValor );
return TST_CompararInt( CondRetEsp , CondRet ,
"Condicao de retorno errada ao criar grafo." ) ;
} /* fim ativa: Testar criar Grafo */
/* Testar destruir Grafo */
else if ( strcmp( ComandoTeste , DESTRUIR_GRAFO_CMD ) == 0 ) {
numLidos = LER_LerParametros( "ii" , &inxGrafo, &CondRetEsp ) ;
if ( ( numLidos != 2 ) || ( ValidarInxGrafo( inxGrafo , VAZIO ) ) )
{
return TST_CondRetParm ;
} /* if */
CondRet = GRA_DestruirGrafo( vtGRAFO[ inxGrafo ] );
vtGRAFO[ inxGrafo ] = NULL;
return TST_CompararInt( CondRetEsp , CondRet ,
"Condicao de retorno errada ao destruir grafo." ) ;
} /* fim ativa: Testar destruir Grafo */
/* Testar esvaziar Grafo */
else if ( strcmp( ComandoTeste , ESV_GRAFO_CMD ) == 0 ) {
numLidos = LER_LerParametros( "ii" , &inxGrafo, &CondRetEsp ) ;
if ( ( numLidos != 2 ) || (ValidarInxGrafo( inxGrafo , VAZIO ) ) )
{
return TST_CondRetParm ;
} /* if */
CondRet = GRA_EsvaziarGrafo( vtGRAFO[ inxGrafo ] );
return TST_CompararInt( CondRetEsp , CondRet ,
"Condicao de retorno errada ao esvaziar grafo." ) ;
} /* fim ativa: Testar esvaziar Grafo */
/* Testar obter vertice corrente em Grafo */
else if ( strcmp( ComandoTeste , CORR_GRAFO_CMD ) == 0 ) {
numLidos = LER_LerParametros( "isi" , &inxGrafo, StringDado, &CondRetEsp ) ;
if ( ( numLidos != 3 ) || ( ValidarInxGrafo( inxGrafo , VAZIO ) ) )
{
return TST_CondRetParm ;
} /* if */
CondRet = GRA_ObterValorCorrente( vtGRAFO[ inxGrafo ], &novoVertice );
if(CondRet != GRA_CondRetOK)
return TST_CompararInt( CondRetEsp , CondRet ,
"Condicao de retorno errada ao obter valor corrente." ) ;
VER_ObterValor( novoVertice, &pValor);
return TST_CompararString( StringDado , pValor ,
"Retorno errado ao obter valor corrente." ) ;
} /* fim ativa: Testar obter vertice corrente em Grafo */
/* Testar alterar vertice corrente em Grafo */
else if ( strcmp( ComandoTeste , ALTCORR_GRAFO_CMD ) == 0 ) {
numLidos = LER_LerParametros( "isi" , &inxGrafo, StringDado, &CondRetEsp ) ;
if ( ( numLidos != 3 ) || ( ValidarInxGrafo( inxGrafo , VAZIO ) ) )
{
return TST_CondRetParm ;
} /* if */
VER_CriarVertice( &novoVertice );
#ifdef _DEBUG
CED_DefinirTipoEspaco( novoVertice, ID_VER_tppVertice );
#endif
VER_AtribuirValor( novoVertice, StringDado ) ;
CondRet = GRA_AlterarValorCorrente( vtGRAFO[ inxGrafo ], novoVertice );
if(CondRet != GRA_CondRetOK)
VER_DestruirVertice(novoVertice);
return TST_CompararInt( CondRetEsp , CondRet ,
"Condicao de retorno errada ao alterar corrente." ) ;
} /* fim ativa: Testar alterar vertice corrente em Grafo */
/* Testar alterar vertice corrente para null em Grafo */
else if ( strcmp( ComandoTeste , ALTCORRNULL_GRAFO_CMD ) == 0 ) {
numLidos = LER_LerParametros( "ii" , &inxGrafo, &CondRetEsp ) ;
if ( ( numLidos != 2 ) || ( ValidarInxGrafo( inxGrafo , VAZIO ) ) )
{
return TST_CondRetParm ;
} /* if */
CondRet = GRA_AlterarValorCorrente( vtGRAFO[ inxGrafo ], NULL );
return TST_CompararInt( CondRetEsp , CondRet ,
"Condicao de retorno errada ao alterar corrente." ) ;
} /* fim ativa: Testar alterar vertice corrente em Grafo */
/* Testar ir para vertice em Grafo */
else if ( strcmp( ComandoTeste , IRVER_GRAFO_CMD ) == 0 ) {
numLidos = LER_LerParametros( "ici" , &inxGrafo, &idVertice, &CondRetEsp ) ;
if ( ( numLidos != 3 ) || ( ValidarInxGrafo( inxGrafo , VAZIO ) ) )
{
return TST_CondRetParm ;
} /* if */
CondRet = GRA_IrParaVertice( vtGRAFO[ inxGrafo ], idVertice );
return TST_CompararInt( CondRetEsp , CondRet ,
"Condicao de retorno errada ao ir para vertice." ) ;
} /* fim ativa: Testar ir para vertice em Grafo */
/* Testar andar para vertice em Grafo */
else if ( strcmp( ComandoTeste , ANDARVER_GRAFO_CMD ) == 0 ) {
numLidos = LER_LerParametros( "ici" , &inxGrafo, &idVertice, &CondRetEsp ) ;
if ( ( numLidos != 3 ) || ( ValidarInxGrafo( inxGrafo , VAZIO ) ) )
{
return TST_CondRetParm ;
} /* if */
CondRet = GRA_AndarParaVertice( vtGRAFO[ inxGrafo ], idVertice );
return TST_CompararInt( CondRetEsp , CondRet ,
"Condicao de retorno errada ao andar para vertice." ) ;
} /* fim ativa: Testar andar para vertice em Grafo */
/* Testar inserir vertice em Grafo */
else if ( strcmp( ComandoTeste , INSVER_GRAFO_CMD ) == 0 ) {
numLidos = LER_LerParametros( "isci" , &inxGrafo, StringDado, &idVertice, &CondRetEsp ) ;
if ( ( numLidos != 4 ) || ( ValidarInxGrafo( inxGrafo , VAZIO ) ) )
{
return TST_CondRetParm ;
} /* if */
VER_CriarVertice( &novoVertice );
#ifdef _DEBUG
CED_EhEspacoAtivo( novoVertice );
CED_DefinirTipoEspaco( novoVertice, ID_VER_tppVertice );
#endif
VER_AtribuirValor( novoVertice, StringDado ) ;
CondRet = GRA_InserirVertice( vtGRAFO[ inxGrafo ], novoVertice, idVertice );
return TST_CompararInt( CondRetEsp , CondRet ,
"Condicao de retorno errada ao inserir vertice." ) ;
} /* fim ativa: Testar inserir vertice em Grafo */
/* Testar inserir vertice de valor null em Grafo */
else if ( strcmp( ComandoTeste , INSVERNULL_GRAFO_CMD ) == 0 ) {
numLidos = LER_LerParametros( "ici" , &inxGrafo, &idVertice, &CondRetEsp ) ;
if ( ( numLidos != 3 ) || ( ValidarInxGrafo( inxGrafo , VAZIO ) ) )
{
return TST_CondRetParm ;
} /* if */
CondRet = GRA_InserirVertice( vtGRAFO[ inxGrafo ], NULL, idVertice );
return TST_CompararInt( CondRetEsp , CondRet ,
"Condicao de retorno errada ao inserir vertice." ) ;
} /* fim ativa: Testar inserir vertice de valor null em Grafo */
/* Testar excluir vertice corrente em Grafo */
else if ( strcmp( ComandoTeste , EXCCORR_GRAFO_CMD ) == 0 ) {
numLidos = LER_LerParametros( "ii" , &inxGrafo, &CondRetEsp) ;
if ( ( numLidos != 2 ) || ( ValidarInxGrafo( inxGrafo , VAZIO ) ) )
{
return TST_CondRetParm ;
} /* if */
CondRet = GRA_ExcluirVerticeCorrente( vtGRAFO[ inxGrafo ] );
return TST_CompararInt( CondRetEsp , CondRet ,
"Condicao de retorno errada ao excluir vertice corrente." ) ;
} /* fim ativa: Testar excluir vertice corrente em Grafo */
/* Testar inserir aresta em Grafo */
else if ( strcmp( ComandoTeste , INSAR_GRAFO_CMD ) == 0 ) {
numLidos = LER_LerParametros( "iccsi" , &inxGrafo, &idVertice, &idVertice2, StringDado, &CondRetEsp) ;
if ( ( numLidos != 5 ) || ( ValidarInxGrafo( inxGrafo , VAZIO ) ) )
{
return TST_CondRetParm ;
} /* if */
CondRet = GRA_InserirAresta( vtGRAFO[ inxGrafo ], idVertice, idVertice2, StringDado );
return TST_CompararInt( CondRetEsp , CondRet ,
"Condicao de retorno errada ao inserir aresta." ) ;
} /* fim ativa: Testar inserir aresta em Grafo */
/* Testar inserir aresta em origem no Grafo */
else if ( strcmp( ComandoTeste , INSARO_GRAFO_CMD ) == 0 ) {
numLidos = LER_LerParametros( "icsi" , &inxGrafo, &idVertice, StringDado, &CondRetEsp) ;
if ( ( numLidos != 4 ) || ( ValidarInxGrafo( inxGrafo , VAZIO ) ) )
{
return TST_CondRetParm ;
} /* if */
CondRet = GRA_InserirArestaOrigemCorrente( vtGRAFO[ inxGrafo ], idVertice, StringDado );
return TST_CompararInt( CondRetEsp , CondRet ,
"Condicao de retorno errada ao inserir aresta na origem corrente." ) ;
} /* fim ativa: Testar inserir aresta em origem no Grafo */
/* Testar excluir aresta em Grafo */
else if ( strcmp( ComandoTeste , EXCAR_GRAFO_CMD ) == 0 ) {
numLidos = LER_LerParametros( "isi" , &inxGrafo, StringDado, &CondRetEsp) ;
if ( ( numLidos != 3 ) || ( ValidarInxGrafo( inxGrafo , VAZIO ) ) )
{
return TST_CondRetParm ;
} /* if */
CondRet = GRA_ExcluirAresta( vtGRAFO[ inxGrafo ], StringDado );
return TST_CompararInt( CondRetEsp , CondRet ,
"Condicao de retorno errada ao excluir aresta." ) ;
} /* fim ativa: Testar excluir aresta em Grafo */
/* Testar adicionar origem em Grafo */
else if ( strcmp( ComandoTeste , ADDOR_GRAFO_CMD ) == 0 ) {
numLidos = LER_LerParametros( "ici" , &inxGrafo, &idVertice, &CondRetEsp) ;
if ( ( numLidos != 3 ) || ( ValidarInxGrafo( inxGrafo , VAZIO ) ) )
{
return TST_CondRetParm ;
} /* if */
CondRet = GRA_AdicionarOrigem( vtGRAFO[ inxGrafo ], idVertice );
return TST_CompararInt( CondRetEsp , CondRet ,
"Condicao de retorno errada ao adicionar origem." ) ;
} /* fim ativa: Testar adicionar origem em Grafo */
/* Testar remover origem em Grafo */
else if ( strcmp( ComandoTeste , RMVOR_GRAFO_CMD ) == 0 ) {
numLidos = LER_LerParametros( "ici" , &inxGrafo, &idVertice, &CondRetEsp) ;
if ( ( numLidos != 3 ) || ( ValidarInxGrafo( inxGrafo , VAZIO ) ) )
{
return TST_CondRetParm ;
} /* if */
CondRet = GRA_RemoverOrigem( vtGRAFO[ inxGrafo ], idVertice );
return TST_CompararInt( CondRetEsp , CondRet ,
"Condicao de retorno errada ao remover origem." ) ;
} /* fim ativa: Testar remover origem em Grafo */
#ifdef _DEBUG
/* Realizar deturpacao */
else if ( strcmp( ComandoTeste , DETURPAR_GRAFO_CMD ) == 0 ) {
numLidos = LER_LerParametros( "ii" , &inxGrafo, ¶m) ;
if ( ( numLidos != 2 ) || ( ValidarInxGrafo( inxGrafo , VAZIO ) ) )
{
return TST_CondRetParm ;
} /* if */
return TST_CompararInt( GRA_CondRetOK , GRA_Deturpar(vtGRAFO[ inxGrafo ], param),
"Erro ao deturpar." ) ;
} /* fim ativa: Realizar deturpacao */
/* Realizar verificao estrututral */
else if ( strcmp( ComandoTeste , VERIFICAR_GRAFO_CMD ) == 0 ) {
numLidos = LER_LerParametros( "ii" , &inxGrafo, ¶m) ;
if ( ( numLidos != 2 ) || ( ValidarInxGrafo( inxGrafo , VAZIO ) ) )
{
return TST_CondRetParm ;
} /* if */
GRA_VerificarEstrutura( vtGRAFO[ inxGrafo ], &numErros );
return TST_CompararInt( param , numErros ,
"Total de erros errado ao verificar estrutura." ) ;
} /* fim ativa: Realizar verificao estrututral */
#endif
} /* Fim função: TGRA &Testar grafo */
TST_tpCondRet TST_EfetuarComando( char * ComandoTeste )
{
int inxLista = -1 ,
numLidos = -1 ,
CondRetEsp = -1 ;
TST_tpCondRet CondRet ;
int CondRetObtido = LIS_CondRetOK;
int det, falhasEsperadas, falhasObtidas;
char StringDado[ DIM_VALOR ] ;
char * pDado ;
int ValEsp = -1 ;
int i,num ;
int numElem = -1 ;
StringDado[ 0 ] = 0 ;
/* Efetuar reset de teste de lista */
if ( strcmp( ComandoTeste , RESET_LISTA_CMD ) == 0 )
{
for( i = 0 ; i < DIM_VT_LISTA ; i++ )
{
vtListas[ i ] = NULL ;
} /* for */
return TST_CondRetOK ;
} /* fim ativa: Efetuar reset de teste de lista */
/* Testar CriarLista */
else if ( strcmp( ComandoTeste , CRIAR_LISTA_CMD ) == 0 )
{
numLidos = LER_LerParametros( "i" ,
&inxLista ) ;
if ( ( numLidos != 1 )
|| ( ! ValidarInxLista( inxLista , VAZIO )))
{
return TST_CondRetParm ;
} /* if */
vtListas[ inxLista ] =
LIS_CriarLista( DestruirValor ) ;
return TST_CompararPonteiroNulo( 1 , vtListas[ inxLista ] ,
"Erro em ponteiro de nova lista." ) ;
} /* fim ativa: Testar CriarLista */
/* Testar Esvaziar lista lista */
else if ( strcmp( ComandoTeste , ESVAZIAR_LISTA_CMD ) == 0 )
{
numLidos = LER_LerParametros( "i" ,
&inxLista ) ;
if ( ( numLidos != 1 )
|| ( ! ValidarInxLista( inxLista , NAO_VAZIO )))
{
return TST_CondRetParm ;
} /* if */
LIS_EsvaziarLista( vtListas[ inxLista ] ) ;
return TST_CondRetOK ;
} /* fim ativa: Testar Esvaziar lista lista */
/* Testar Destruir lista */
else if ( strcmp( ComandoTeste , DESTRUIR_LISTA_CMD ) == 0 )
{
numLidos = LER_LerParametros( "i" ,
&inxLista ) ;
if ( ( numLidos != 1 )
|| ( ! ValidarInxLista( inxLista , NAO_VAZIO )))
{
return TST_CondRetParm ;
} /* if */
LIS_DestruirLista( vtListas[ inxLista ] ) ;
vtListas[ inxLista ] = NULL ;
return TST_CondRetOK ;
} /* fim ativa: Testar Destruir lista */
/* Testar inserir elemento antes */
else if ( strcmp( ComandoTeste , INS_ELEM_ANTES_CMD ) == 0 )
{
numLidos = LER_LerParametros( "isi" ,
&inxLista , StringDado , &CondRetEsp ) ;
if ( ( numLidos != 3 )
|| ( ! ValidarInxLista( inxLista , NAO_VAZIO )) )
{
return TST_CondRetParm ;
} /* if */
pDado = ( char * ) malloc( strlen( StringDado ) + 1 ) ;
if ( pDado == NULL )
{
return TST_CondRetMemoria ;
} /* if */
strcpy( pDado , StringDado ) ;
CondRet = LIS_InserirElementoAntes( vtListas[ inxLista ] , pDado ) ;
if ( CondRet != LIS_CondRetOK )
{
free( pDado ) ;
} /* if */
return TST_CompararInt( CondRetEsp , CondRet ,
"Condicao de retorno errada ao inserir antes." ) ;
} /* fim ativa: Testar inserir elemento antes */
/* Testar inserir elemento apos */
else if ( strcmp( ComandoTeste , INS_ELEM_APOS_CMD ) == 0 )
{
numLidos = LER_LerParametros( "isi" ,
&inxLista , StringDado , &CondRetEsp ) ;
if ( ( numLidos != 3 )
|| ( ! ValidarInxLista( inxLista , NAO_VAZIO )) )
{
return TST_CondRetParm ;
} /* if */
pDado = ( char * ) malloc( strlen( StringDado ) + 1 ) ;
if ( pDado == NULL )
{
return TST_CondRetMemoria ;
} /* if */
strcpy( pDado , StringDado ) ;
CondRet = LIS_InserirElementoApos( vtListas[ inxLista ] , pDado ) ;
if ( CondRet != LIS_CondRetOK )
{
free( pDado ) ;
} /* if */
return TST_CompararInt( CondRetEsp , CondRet ,
"Condicao de retorno errada ao inserir apos." ) ;
} /* fim ativa: Testar inserir elemento apos */
/* Testar excluir simbolo */
else if ( strcmp( ComandoTeste , EXC_ELEM_CMD ) == 0 )
{
numLidos = LER_LerParametros( "ii" ,
&inxLista , &CondRetEsp ) ;
if ( ( numLidos != 2 )
|| ( ! ValidarInxLista( inxLista , NAO_VAZIO )) )
{
return TST_CondRetParm ;
} /* if */
return TST_CompararInt( CondRetEsp ,
LIS_ExcluirElemento( vtListas[ inxLista ] ) ,
"Condição de retorno errada ao excluir." ) ;
} /* fim ativa: Testar excluir simbolo */
/* Testar obter valor do elemento corrente */
else if ( strcmp( ComandoTeste , OBTER_VALOR_CMD ) == 0 )
{
numLidos = LER_LerParametros( "isi" ,
&inxLista , StringDado , &ValEsp ) ;
if ( ( numLidos != 3 )
|| ( ! ValidarInxLista( inxLista , NAO_VAZIO )) )
{
return TST_CondRetParm ;
} /* if */
pDado = ( char * ) LIS_ObterValor( vtListas[ inxLista ] ) ;
if ( ValEsp == 0 )
{
return TST_CompararPonteiroNulo( 0 , pDado ,
"Valor não deveria existir." ) ;
} /* if */
if ( pDado == NULL )
{
return TST_CompararPonteiroNulo( 1 , pDado ,
"Dado tipo um deveria existir." ) ;
} /* if */
return TST_CompararString( StringDado , pDado ,
"Valor do elemento errado." ) ;
} /* fim ativa: Testar obter valor do elemento corrente */
/* Testar ir para o elemento inicial */
else if ( strcmp( ComandoTeste , IR_INICIO_CMD ) == 0 )
{
numLidos = LER_LerParametros( "i" , &inxLista ) ;
if ( ( numLidos != 1 )
|| ( ! ValidarInxLista( inxLista , NAO_VAZIO )) )
{
return TST_CondRetParm ;
} /* if */
IrInicioLista( vtListas[ inxLista ] ) ;
return TST_CondRetOK ;
} /* fim ativa: Testar ir para o elemento inicial */
/* LIS &Ir para o elemento final */
else if ( strcmp( ComandoTeste , IR_FIM_CMD ) == 0 )
{
numLidos = LER_LerParametros( "i" , &inxLista ) ;
if ( ( numLidos != 1 )
|| ( ! ValidarInxLista( inxLista , NAO_VAZIO )) )
{
return TST_CondRetParm ;
} /* if */
IrFinalLista( vtListas[ inxLista ] ) ;
return TST_CondRetOK ;
} /* fim ativa: LIS &Ir para o elemento final */
/* LIS &Avançar elemento */
else if ( strcmp( ComandoTeste , AVANCAR_ELEM_CMD ) == 0 )
{
numLidos = LER_LerParametros( "iii" , &inxLista , &numElem ,
&CondRetEsp ) ;
if ( ( numLidos != 3 )
|| ( ! ValidarInxLista( inxLista , NAO_VAZIO )) )
{
return TST_CondRetParm ;
} /* if */
return TST_CompararInt( CondRetEsp , LIS_AvancarElementoCorrente( vtListas[ inxLista ] , numElem ) ,
"Condicao de retorno errada ao avancar" ) ;
} /* fim ativa: LIS &Avançar elemento */
/* LIS &Testar Obter Tamanho Lista */
else if (strcmp ( ComandoTeste , OBTER_TAMANHO_CMD ) == 0 )
{
numLidos = LER_LerParametros( "iii" ,&inxLista,&ValEsp, &CondRetEsp ) ;
if ( ( numLidos != 3 )||( ! ValidarInxLista( inxLista , NAO_VAZIO )) )
{
return TST_CondRetParm ;
} /* if */
CondRetObtido = LIS_ObterTamanho( vtListas[ inxLista ], &num );
CondRet = TST_CompararInt( ValEsp , num ,"Valor do elemento errado, diferente do esperado" ) ;
if ( CondRet != TST_CondRetOK )
return CondRet ;
return TST_CondRetOK;
} /* Fim testar Obter Tamanho */
#ifdef _DEBUG
/* Testar Deturpar */
else if (strcmp ( ComandoTeste , DETURPA_CMD ) == 0 )
{
numLidos = LER_LerParametros( "ii" ,&inxLista, &det) ;
if ( numLidos != 2 )
{
return TST_CondRetParm ;
} /* if */
DeturpaLista(vtListas[ inxLista ], det);
return TST_CondRetOK;
}
else if (strcmp ( ComandoTeste , VERIFICA_CMD ) == 0 )
{
numLidos = LER_LerParametros( "ii" ,&inxLista, &falhasEsperadas) ;
if ( numLidos != 2 )
{
return TST_CondRetParm ;
} /* if */
verificaLista(vtListas[ inxLista ], &falhasObtidas);
CondRet = TST_CompararInt( falhasEsperadas , falhasObtidas ,"Numero de falhas esperadas diferente de obtida" ) ;
if ( CondRet != TST_CondRetOK )
return CondRet ;
return TST_CondRetOK;
}
#endif
return TST_CondRetNaoConhec ;
} /* Fim função: TLIS &Testar lista */
TST_tpCondRet TST_EfetuarComando( char * ComandoTeste )
{
int inxTabela = -1 ,
idTipo = -1 ,
numLidos = -1 ,
CondRetEsp = -1 ;
TST_tpCondRet CondRet ;
char StringDado[ DIM_SIMB ] ;
char StringValor[ DIM_SIMB ] ;
int i ;
int tamTabela = -1 ;
int ValInt = -1 ;
tpTipo1 * pDado1 ;
char ValChar = '\0' ;
tpTipo2 * pDado2 ;
tpTipo3 * pDado3 ;
int ValIntEsp = -1 ;
char ValCharEsp = '*' ;
StringDado[ 0 ] = 0 ;
/* Efetuar reset de teste de tabela */
if ( strcmp( ComandoTeste , RESET_TAB_CMD ) == 0 )
{
for( i = 0 ; i < DIM_VT_TABELAS ; i++ )
{
vtTabelas[ i ] = NULL ;
} /* for */
return TST_CondRetOK ;
} /* fim ativa: Efetuar reset de teste de tabela */
/* Testar CriarTabela */
else if ( strcmp( ComandoTeste , CRIAR_TAB_CMD ) == 0 )
{
numLidos = LER_LerParametros( "iii" ,
&inxTabela , &tamTabela , &idTipo ) ;
if ( ( numLidos != 3 )
|| ( ! ValidarInxTabela( inxTabela , VAZIO ))
|| ( ! ValidarIdTipo( idTipo ))
|| ( tamTabela <= 1 ))
{
return TST_CondRetParm ;
} /* if */
if ( idTipo == ID_TIPO_1 )
{
vtTabelas[ inxTabela ] =
TBS_CriarTabela( tamTabela , ObterSimboloTipoUm , NULL ) ;
} else if ( idTipo == ID_TIPO_2 )
{
vtTabelas[ inxTabela ] =
TBS_CriarTabela( tamTabela , ObterSimboloTipoDois , NULL ) ;
} else
{
vtTabelas[ inxTabela ] =
TBS_CriarTabela( tamTabela , ObterSimboloTipoTres ,
LiberarDadoTipoTres ) ;
} /* if */
return TST_CompararPonteiroNulo( 1 , vtTabelas[ inxTabela ] ,
"Erro em ponteiro de nova tabela." ) ;
} /* fim ativa: Testar CriarTabela */
/* Testar Destruir tabela */
else if ( strcmp( ComandoTeste , DESTRUIR_TAB_CMD ) == 0 )
{
numLidos = LER_LerParametros( "i" ,
&inxTabela ) ;
if ( ( numLidos != 1 )
|| ( ! ValidarInxTabela( inxTabela , NAO_VAZIO )))
{
return TST_CondRetParm ;
} /* if */
TBS_DestruirTabela( vtTabelas[ inxTabela ] ) ;
vtTabelas[ inxTabela ] = NULL ;
return TST_CondRetOK ;
} /* fim ativa: Testar Destruir tabela */
/* Testar Inserir simbolo tipo um */
else if ( strcmp( ComandoTeste , INS_SIMB_UM_CMD ) == 0 )
{
numLidos = LER_LerParametros( "iisi" ,
&inxTabela , &ValInt , StringDado , &CondRetEsp ) ;
if ( ( numLidos != 4 )
|| ( ! ValidarInxTabela( inxTabela , NAO_VAZIO )) )
{
return TST_CondRetParm ;
} /* if */
pDado1 = ( tpTipo1 * ) malloc( sizeof( tpTipo1 )) ;
if ( pDado1 == NULL )
{
return TST_CondRetMemoria ;
} /* if */
pDado1->Conta = ValInt ;
strcpy( pDado1->SimboloUm , StringDado ) ;
CondRet = (TST_tpCondRet) TBS_InserirSimbolo( vtTabelas[ inxTabela ] , pDado1 ) ;
if ( CondRet != TBS_CondRetOK )
{
free( pDado1 ) ;
} /* if */
return TST_CompararInt( CondRetEsp , CondRet ,
"Condição de retorno errada em símbolo tipo um." ) ;
} /* fim ativa: Testar Inserir simbolo tipo um */
/* Testar Inserir simbolo tipo dois */
else if ( strcmp( ComandoTeste , INS_SIMB_DOIS_CMD ) == 0 )
{
numLidos = LER_LerParametros( "icsi" ,
&inxTabela , &ValChar , StringDado , &CondRetEsp ) ;
if ( ( numLidos != 4 )
|| ( ! ValidarInxTabela( inxTabela , NAO_VAZIO )) )
{
return TST_CondRetParm ;
} /* if */
pDado2 = ( tpTipo2 * ) malloc( sizeof( tpTipo2 )) ;
if ( pDado2 == NULL )
{
return TST_CondRetMemoria ;
} /* if */
pDado2->Id = ValChar ;
strcpy( pDado2->SimboloDois , StringDado ) ;
return TST_CompararInt( CondRetEsp ,
TBS_InserirSimbolo( vtTabelas[ inxTabela ] , pDado2 ) ,
"Condição de retorno errada em símbolo tipo dois." ) ;
} /* fim ativa: Testar Inserir simbolo tipo dois */
/* Testar Inserir simbolo tipo tres */
else if ( strcmp( ComandoTeste , INS_SIMB_TRES_CMD ) == 0 )
{
numLidos = LER_LerParametros( "issi" ,
&inxTabela , StringDado , StringValor , &CondRetEsp ) ;
if ( ( numLidos != 4 )
|| ( ! ValidarInxTabela( inxTabela , NAO_VAZIO )) )
{
return TST_CondRetParm ;
} /* if */
pDado3 = ( tpTipo3 * ) malloc( sizeof( tpTipo3 )) ;
if ( pDado3 == NULL )
{
return TST_CondRetMemoria ;
} /* if */
pDado3->pString = (char*) malloc( strlen( StringValor ) + 1 ) ;
strcpy( pDado3->pString , StringValor ) ;
strcpy( pDado3->SimboloTres , StringDado ) ;
return TST_CompararInt( CondRetEsp ,
TBS_InserirSimbolo( vtTabelas[ inxTabela ] , pDado3 ) ,
"Condição de retorno errada em símbolo tipo dois." ) ;
} /* fim ativa: Testar Inserir simbolo tipo tres */
/* Testar excluir simbolo */
else if ( strcmp( ComandoTeste , EXC_SIMB_CMD ) == 0 )
{
numLidos = LER_LerParametros( (char*) "isi" ,
(char*) &inxTabela , (char*) StringDado , (char*) &CondRetEsp ) ;
if ( ( numLidos != 3 )
|| ( ! ValidarInxTabela( inxTabela , NAO_VAZIO )) )
{
return TST_CondRetParm ;
} /* if */
return TST_CompararInt( CondRetEsp ,
TBS_ExcluirSimbolo( vtTabelas[ inxTabela ] , StringDado ) ,
"Condição de retorno errada ao excluir." ) ;
} /* fim ativa: Testar excluir simbolo */
/* Testar procurar símbolo tipo 1 */
else if ( strcmp( ComandoTeste , PROCURAR_SIMB_UM_CMD ) == 0 )
{
numLidos = LER_LerParametros( "isi" ,
&inxTabela , StringDado , &ValIntEsp ) ;
if ( ( numLidos != 3 )
|| ( ! ValidarInxTabela( inxTabela , NAO_VAZIO )) )
{
return TST_CondRetParm ;
} /* if */
pDado1 = ( tpTipo1 * ) TBS_ProcurarSimbolo( vtTabelas[ inxTabela ] ,
StringDado ) ;
if ( ValIntEsp == -1 )
{
return TST_CompararPonteiroNulo( 0 , pDado1 ,
"Dado tipo um não deveria existir." ) ;
} /* if */
if ( pDado1 == NULL )
{
return TST_CompararPonteiroNulo( 1 , pDado1 ,
"Dado tipo um deveria existir." ) ;
} /* if */
return TST_CompararInt( ValIntEsp , pDado1->Conta ,
"Valor tipo um errado." ) ;
} /* fim ativa: Testar procurar símbolo tipo 1 */
/* Testar procurar símbolo tipo 2 */
else if ( strcmp( ComandoTeste , PROCURAR_SIMB_DOIS_CMD ) == 0 )
{
numLidos = LER_LerParametros( "isc" ,
&inxTabela , StringDado , &ValCharEsp ) ;
if ( ( numLidos != 3 )
|| ( ! ValidarInxTabela( inxTabela , NAO_VAZIO )) )
{
return TST_CondRetParm ;
} /* if */
pDado2 = ( tpTipo2 * ) TBS_ProcurarSimbolo( vtTabelas[ inxTabela ] ,
StringDado ) ;
if ( ValCharEsp == '*' )
{
return TST_CompararPonteiroNulo( 0 , pDado2 ,
"Dado tipo dois não deveria existir." ) ;
} /* if */
if ( pDado2 == NULL )
{
return TST_CompararPonteiroNulo( 1 , pDado2 ,
"Dado tipo dois deveria existir." ) ;
} /* if */
return TST_CompararChar( ValCharEsp , pDado2->Id ,
"Valor tipo dois errado." ) ;
} /* fim ativa: Testar procurar símbolo tipo 2 */
/* Testar procurar símbolo tipo 3 */
else if ( strcmp( ComandoTeste , PROCURAR_SIMB_TRES_CMD ) == 0 )
{
numLidos = LER_LerParametros( "iss" ,
&inxTabela , StringDado , StringValor ) ;
if ( ( numLidos != 3 )
|| ( ! ValidarInxTabela( inxTabela , NAO_VAZIO )) )
{
return TST_CondRetParm ;
} /* if */
pDado3 = ( tpTipo3 * ) TBS_ProcurarSimbolo( vtTabelas[ inxTabela ] ,
StringDado ) ;
if ( pDado3 == NULL )
{
return TST_CompararPonteiroNulo( 1 , pDado3 ,
"Dado tipo três deveria existir." ) ;
} /* if */
return TST_CompararString( StringValor , pDado3->pString ,
"Valor tipo três errado." ) ;
} /* fim ativa: Testar procurar símbolo tipo 3 */
/* Testar validar Tabela de símbolos */
#ifdef _DEBUG
else if ( strcmp( ComandoTeste , VALIDAR_TAB_CMD ) == 0 )
{
numLidos = LER_LerParametros( "i" ,
&inxTabela ) ;
if ( ( numLidos != 1 )
|| ( ! ValidarInxTabela( inxTabela , NAO_VAZIO )))
{
return TST_CondRetParm ;
} /* if */
return TBS_ValidarTabela( vtTabelas[ inxTabela ] ) ;
} /* fim ativa: Testar validar Tabela de símbolos */
#endif
return TST_CondRetNaoConhec ;
} /* Fim função: TTBS &Testar tabela de símbolos */
TST_tpCondRet TST_EfetuarComando(char * ComandoTeste)
{
CAR_tpCondRet CondRetRecebida;
CAR_tpCondRet CondRetEsperada;
int numLidos = -1;
int ValEsp = -1;
int numElem = -1;
PILHA_tpPilha pPilha;
PILHA_tpPilha pPilha2;
CAR_tpCarta cCarta1;
/* Testar criarSQF */
if (strcmp(ComandoTeste, CRIAR_SQF_CMD) == 0)
{
numLidos = LER_LerParametros("i", &CondRetEsperada);
if (numLidos != 1){
return TST_CondRetParm;
} /* if */
CondRetRecebida = SQF_criarSQFinal(&sqFinal);
return TST_CompararInt(CondRetEsperada, CondRetRecebida, "Erro ao criar a SQF");
} /* fim ativa: Testar criarSQF */
/* Testar retornaPilha */
else if (strcmp(ComandoTeste, RETORNA_PILHA_CMD) == 0)
{
numLidos = LER_LerParametros("i", &CondRetEsperada);
if ((numLidos != 1)){
return TST_CondRetParm;
} /* if */
PILHA_criarPilha(&pPilha2);
CondRetRecebida = SQF_retornaPilha(sqFinal, &pPilha2);
return TST_CompararInt(CondRetEsperada, CondRetRecebida, "Erro ao retornar a pilha da SQF");
} /* fim ativa: Testar retornaPilha */
/* Testar liberarSQF */
else if (strcmp(ComandoTeste, LIBERAR_SQF_CMD) == 0)
{
numLidos = LER_LerParametros("i", &CondRetEsperada);
if ((numLidos != 1)){
return TST_CondRetParm;
} /* if */
CondRetRecebida = SQF_liberaSQFinal(sqFinal);
return TST_CompararInt(CondRetEsperada, CondRetRecebida, "Erro ao liberar a SQF");
} /* fim ativa: Testar liberarSQF */
/* Testar inicializaSQF */
else if (strcmp(ComandoTeste, EDITAR_SQF_CMD) == 0)
{
numLidos = LER_LerParametros("i", &CondRetEsperada);
if ((numLidos != 1)){
return TST_CondRetParm;
} /* if */
PILHA_criarPilha(&pPilha);
CAR_criarCarta(&cCarta1);
CAR_editarCarta(cCarta1, 'V','O', 'A');
PILHA_pushPilha(pPilha, cCarta1);
CAR_criarCarta(&cCarta1);
CAR_editarCarta(cCarta1, 'V','C', '2');
PILHA_pushPilha(pPilha, cCarta1);
CAR_criarCarta(&cCarta1);
CAR_editarCarta(cCarta1, 'V','E', '3');
PILHA_pushPilha(pPilha, cCarta1);
CondRetRecebida = SQF_inicializaSQFinal(sqFinal, pPilha);
return TST_CompararInt(CondRetEsperada, CondRetRecebida, "Erro ao editar a SQF!");
} /* fim ativa: Testar inicializaSQF */
return TST_CondRetNaoConhec;
} /* Fim função: TESTMOR Efetuar operações de teste específicas para mortos */
TST_tpCondRet TST_EfetuarComando( char * ComandoTeste )
{
int inxLista = -1 ,
numLidos = -1 ,
CondRetEsp = -1 ;
char StringDado[ DIM_VALOR ] ;
int ValEsp = -1 ;
int i ;
int numElem = -1 ;
StringDado[ 0 ] = 0 ;
/* Efetuar reset de teste de lista */
if ( strcmp( ComandoTeste , RESET_LISTA_CMD ) == 0 )
{
for( i = 0 ; i < DIM_VT_LISTA ; i++ )
{
vtListas[ i ] = NULL ;
} /* for */
return TST_CondRetOK ;
} /* fim ativa: Efetuar reset de teste de lista */
/* Testar CriarLista */
else if ( strcmp( ComandoTeste , CRIAR_LISTA_CMD ) == 0 )
{
numLidos = LER_LerParametros( "i" ,
&inxLista ) ;
if ( ( numLidos != 1 )
|| ( ! ValidarInxLista( inxLista , VAZIO )))
{
return TST_CondRetParm ;
} /* if */
vtListas[ inxLista ] =
LIS_CriarLista( DestruirValor ) ;
return TST_CompararPonteiroNulo( 1 , vtListas[ inxLista ] ,
"Erro em ponteiro de nova lista." ) ;
} /* fim ativa: Testar CriarLista */
/* Testar Esvaziar lista lista */
else if ( strcmp( ComandoTeste , ESVAZIAR_LISTA_CMD ) == 0 )
{
numLidos = LER_LerParametros( "i" ,
&inxLista ) ;
if ( ( numLidos != 1 )
|| ( ! ValidarInxLista( inxLista , NAO_VAZIO )))
{
return TST_CondRetParm ;
} /* if */
LIS_EsvaziarLista( vtListas[ inxLista ] ) ;
return TST_CondRetOK ;
} /* fim ativa: Testar Esvaziar lista lista */
/* Testar Destruir lista */
else if ( strcmp( ComandoTeste , DESTRUIR_LISTA_CMD ) == 0 )
{
numLidos = LER_LerParametros( "i" ,
&inxLista ) ;
if ( ( numLidos != 1 )
|| ( ! ValidarInxLista( inxLista , NAO_VAZIO )))
{
return TST_CondRetParm ;
} /* if */
LIS_DestruirLista( vtListas[ inxLista ] ) ;
vtListas[ inxLista ] = NULL ;
return TST_CondRetOK ;
} /* fim ativa: Testar Destruir lista */
/* Testar inserir elemento antes */
else if ( strcmp( ComandoTeste , INS_ELEM_ANTES_CMD ) == 0 )
{
struct user *u = (struct user*) malloc (sizeof (struct user));
LIS_tpCondRet lret;
if (!u)
return TST_CondRetMemoria;
numLidos = LER_LerParametros( "isssi" ,
&inxLista , u->nome, u->tel, u->ender , &CondRetEsp ) ;
if ( ( numLidos != 5 )
|| ( ! ValidarInxLista( inxLista , NAO_VAZIO )) )
{
return TST_CondRetParm ;
} /* if */
lret = LIS_InserirElementoAntes( vtListas[ inxLista ] , u ) ;
if ( lret != LIS_CondRetOK )
{
free( u ) ;
} /* if */
return TST_CompararInt( CondRetEsp , lret ,
"Condicao de retorno errada ao inserir antes." ) ;
} /* fim ativa: Testar inserir elemento antes */
/* Testar inserir elemento apos */
else if ( strcmp( ComandoTeste , INS_ELEM_APOS_CMD ) == 0 )
{
struct user *u = (struct user *)malloc (sizeof (struct user));
LIS_tpCondRet lret;
if (!u)
return TST_CondRetMemoria;
numLidos = LER_LerParametros( "isssi",
&inxLista, u->nome, u->tel, u->ender, &CondRetEsp ) ;
if ( ( numLidos != 5 )
|| ( ! ValidarInxLista( inxLista , NAO_VAZIO )) )
{
return TST_CondRetParm ;
} /* if */
lret = LIS_InserirElementoApos( vtListas[ inxLista ] , u ) ;
if ( lret != LIS_CondRetOK )
{
free( u ) ;
} /* if */
return TST_CompararInt( CondRetEsp , lret,
"Condicao de retorno errada ao inserir antes.") ;
} /* fim ativa: Testar inserir elemento apos */
/* Testar excluir simbolo */
else if ( strcmp( ComandoTeste , EXC_ELEM_CMD ) == 0 )
{
numLidos = LER_LerParametros( "ii" ,
&inxLista , &CondRetEsp ) ;
if ( ( numLidos != 2 )
|| ( ! ValidarInxLista( inxLista , NAO_VAZIO )) )
{
return TST_CondRetParm ;
} /* if */
return TST_CompararInt( CondRetEsp ,
LIS_ExcluirElemento( vtListas[ inxLista ] ) ,
"Condição de retorno errada ao excluir." ) ;
} /* fim ativa: Testar excluir simbolo */
/* Testar obter valor do elemento corrente */
else if ( strcmp( ComandoTeste , OBTER_NOME_CMD ) == 0 )
{
struct user *u;
numLidos = LER_LerParametros( "isi" ,
&inxLista , StringDado , &ValEsp ) ;
if ( ( numLidos != 3 )
|| ( ! ValidarInxLista( inxLista , NAO_VAZIO )) )
{
return TST_CondRetParm ;
} /* if */
u = (struct user*) LIS_ObterValor( vtListas[ inxLista ] ) ;
if ( ValEsp == 0 )
{
return TST_CompararPonteiroNulo( 0 , u,
"Valor não deveria existir." ) ;
} /* if */
if ( u == NULL )
{
return TST_CompararPonteiroNulo( 1 , u,
"Dado tipo um deveria existir." ) ;
} /* if */
return TST_CompararString( StringDado , u->nome,
"Valor nome do elemento esta' errado." ) ;
} /* fim ativa: Testar obter valor do elemento corrente */
/* Testar obter valor do elemento corrente */
else if ( strcmp( ComandoTeste, OBTER_TEL_CMD ) == 0 )
{
struct user *u;
numLidos = LER_LerParametros( "isi" ,
&inxLista , StringDado , &ValEsp ) ;
if ( ( numLidos != 3 )
|| ( ! ValidarInxLista( inxLista , NAO_VAZIO )) )
{
return TST_CondRetParm ;
} /* if */
u = (struct user*) LIS_ObterValor( vtListas[ inxLista ] ) ;
if ( ValEsp == 0 )
{
return TST_CompararPonteiroNulo( 0 , u,
"Valor não deveria existir." ) ;
} /* if */
if ( u == NULL )
{
return TST_CompararPonteiroNulo( 1 , u,
"Dado tipo um deveria existir." ) ;
} /* if */
return TST_CompararString( StringDado , u->tel,
"Valor nome do elemento esta' errado." ) ;
} /* fim ativa: Testar obter valor do elemento corrente */
/* Testar obter valor do elemento corrente */
else if ( strcmp( ComandoTeste , OBTER_ENDER_CMD ) == 0 )
{
struct user *u;
numLidos = LER_LerParametros( "isi" ,
&inxLista , StringDado , &ValEsp ) ;
if ( ( numLidos != 3 )
|| ( ! ValidarInxLista( inxLista , NAO_VAZIO )) )
{
return TST_CondRetParm ;
} /* if */
u = (struct user*) LIS_ObterValor( vtListas[ inxLista ] ) ;
if ( ValEsp == 0 )
{
return TST_CompararPonteiroNulo( 0 , u,
"Valor não deveria existir." ) ;
} /* if */
if ( u == NULL )
{
return TST_CompararPonteiroNulo( 1 , u,
"Dado tipo um deveria existir." ) ;
} /* if */
return TST_CompararString( StringDado , u->ender,
"Valor nome do elemento esta' errado." ) ;
} /* fim ativa: Testar obter valor do elemento corrente */
/* Testar ir para o elemento inicial */
else if ( strcmp( ComandoTeste , IR_INICIO_CMD ) == 0 )
{
numLidos = LER_LerParametros( "i" , &inxLista ) ;
if ( ( numLidos != 1 )
|| ( ! ValidarInxLista( inxLista , NAO_VAZIO )) )
{
return TST_CondRetParm ;
} /* if */
IrInicioLista( vtListas[ inxLista ] ) ;
return TST_CondRetOK ;
} /* fim ativa: Testar ir para o elemento inicial */
/* LIS &Ir para o elemento final */
else if ( strcmp( ComandoTeste , IR_FIM_CMD ) == 0 )
{
numLidos = LER_LerParametros( "i" , &inxLista ) ;
if ( ( numLidos != 1 )
|| ( ! ValidarInxLista( inxLista , NAO_VAZIO )) )
{
return TST_CondRetParm ;
} /* if */
IrFinalLista( vtListas[ inxLista ] ) ;
return TST_CondRetOK ;
} /* fim ativa: LIS &Ir para o elemento final */
/* LIS &Avançar elemento */
else if ( strcmp( ComandoTeste , AVANCAR_ELEM_CMD ) == 0 )
{
numLidos = LER_LerParametros( "iii" , &inxLista , &numElem ,
&CondRetEsp ) ;
if ( ( numLidos != 3 )
|| ( ! ValidarInxLista( inxLista , NAO_VAZIO )) )
{
return TST_CondRetParm ;
} /* if */
return TST_CompararInt( CondRetEsp ,
LIS_AvancarElementoCorrente( vtListas[ inxLista ] , numElem ) ,
"Condicao de retorno errada ao avancar" ) ;
} /* fim ativa: LIS &Avançar elemento */
return TST_CondRetNaoConhec ;
} /* Fim função: TLIS &Testar lista */
TST_tpCondRet ICNT_EfetuarComadoContagem( char * ComandoTeste )
{
char NomeArquivo[ DIM_NOME_ARQ ] ;
char NomeContador[ DIM_NOME_CONTADOR ] ;
int numLidos ,
IntEsp ,
IntObtido ;
CNT_tpCondRet CondRetEsp ,
CondRetEh ;
/* Tratar CNT &Inicializar contadores */
if ( strcmp( ComandoTeste , INICIALIZAR_CONTADORES_CMD ) == 0 )
{
/*
CNT_tpCondRet CNT_InicializarContadores( FILE * pArqLog , char * NomeArquivo )
*/
CondRetEsp = CNT_CondRetOK ;
numLidos = LER_LerParametros( "si" ,
NomeArquivo , &CondRetEsp ) ;
if ( numLidos < 1 )
{
CondRetEsp = CNT_CondRetErro ;
} /* if */
if ( ( NomeArquivo[ 0 ] == 0 )
|| ( numLidos < 1 ))
{
CondRetEh = CNT_InicializarContadores( NULL ) ;
} else {
CondRetEh = CNT_InicializarContadores( NomeArquivo ) ;
} /* if */
return TST_CompararInt( CondRetEsp , CondRetEh ,
"Condição de retorno errada." ) ;
} /* fim ativa: Tratar CNT &Inicializar contadores */
/* Tratar CNT &Terminar contadores */
else if ( strcmp( ComandoTeste , TERMINAR_CONTADORES_CMD ) == 0 )
{
/*
CNT_tpCondRet CNT_TerminarContadores( )
*/
CondRetEsp = CNT_CondRetOK ;
numLidos = LER_LerParametros( "i" ,
&CondRetEsp ) ;
return TST_CompararInt( CondRetEsp , CNT_TerminarContadores( ) ,
CondRetErrada ) ;
} /* fim ativa: Tratar CNT &Terminar contadores */
/* Tratar CNT &Registrar arquivo acumulador */
if ( strcmp( ComandoTeste , REGISTRAR_ACUMULADOR_CMD ) == 0 )
{
/*
void CNT_RegistrarAcumulador( char * NomeArquivo ) ;
*/
numLidos = LER_LerParametros( "s" ,
NomeArquivo ) ;
if ( numLidos != 1 )
{
return TST_CondRetParm ;
} /* if */
if ( NomeArquivo[ 0 ] == 0 )
{
CNT_RegistrarAcumulador( NULL ) ;
} else {
CNT_RegistrarAcumulador( NomeArquivo ) ;
} /* if */
return TST_CondRetOK ;
} /* fim ativa: Tratar CNT &Registrar arquivo acumulador */
/* Tratar CNT &Ler arquivo de definição de contadores */
else if ( strcmp( ComandoTeste , LER_CONTADORES_CMD ) == 0 )
{
/*
int CNT_LerContadores( char * NomeArquivoDefinicao )
*/
IntEsp = 0 ;
numLidos = LER_LerParametros( "si" ,
NomeArquivo , &IntEsp ) ;
if ( ( numLidos < 1 )
|| ( IntEsp < 0 ))
{
return TST_CondRetParm ;
} /* if */
return TST_CompararInt( IntEsp , CNT_LerContadores( NomeArquivo ) ,
"Número de erros de leitura errado." ) ;
} /* fim ativa: Tratar CNT &Ler arquivo de definição de contadores */
/* Tratar CNT &Gravar arquivo de contagem acumulada */
else if ( strcmp( ComandoTeste , GRAVAR_CONTADORES_CMD ) == 0 )
{
/*
int CNT_GravarContadores( char * NomeArquivo )
*/
IntEsp = 0 ;
numLidos = LER_LerParametros( "si" ,
NomeArquivo , &IntEsp ) ;
if ( ( numLidos < 1 )
|| ( IntEsp < 0 ))
{
return TST_CondRetParm ;
} /* if */
return TST_CompararInt( IntEsp , CNT_GravarContadores( NomeArquivo ) ,
"Número de erros de gravação errado." ) ;
} /* fim ativa: Tratar CNT &Gravar arquivo de contagem acumulada */
/* Tratar CNT &Zerar todos contadores */
else if ( strcmp( ComandoTeste , ZERAR_CONTADORES_CMD ) == 0 )
{
/*
CNT_tpCondRet CNT_ZerarContadores( )
*/
CondRetEsp = CNT_CondRetOK ;
numLidos = LER_LerParametros( "i" ,
&CondRetEsp ) ;
return TST_CompararInt( CondRetEsp , CNT_ZerarContadores( ) ,
CondRetErrada ) ;
} /* fim ativa: Tratar CNT &Zerar todos contadores */
/* Tratar CNT &Zerar contador dado */
else if ( strcmp( ComandoTeste , ZERAR_CONTADOR_DADO_CMD ) == 0 )
{
/*
CNT_tpCondRet CNT_ZerarContador( char * NomeContador )
*/
CondRetEsp = CNT_CondRetOK ;
numLidos = LER_LerParametros( "si" ,
NomeContador , &CondRetEsp ) ;
if ( numLidos < 1 )
{
return TST_CondRetParm ;
} /* if */
return TST_CompararInt( CondRetEsp , CNT_ZerarContador( NomeContador ) ,
CondRetErrada ) ;
} /* fim ativa: Tratar CNT &Zerar contador dado */
/* Tratar CNT &Iniciar a contagem */
else if ( strcmp( ComandoTeste , INICIAR_CONTAGEM_CMD ) == 0 )
{
/*
void CNT_IniciarContagem( )
*/
CNT_IniciarContagem( ) ;
return TST_CondRetOK ;
} /* fim ativa: Tratar CNT &Iniciar a contagem */
/* Tratar CNT &Parar contagem */
else if ( strcmp( ComandoTeste , PARAR_CONTAGEM_CMD ) == 0 )
{
/*
void CNT_PararContagem( )
*/
CNT_PararContagem( ) ;
return TST_CondRetOK ;
} /* fim ativa: Tratar CNT &Parar contagem */
/* Tratar CNT &Obter valor de contagem */
else if ( strcmp( ComandoTeste , OBTER_CONTAGEM_CMD ) == 0 )
{
/*
long CNT_ObterContagem( char * NomeContador )
*/
numLidos = LER_LerParametros( "si" ,
NomeContador , &IntEsp ) ;
if ( numLidos != 2 )
{
return TST_CondRetParm ;
} /* if */
return TST_CompararInt( IntEsp ,
( int ) CNT_ObterContagem( NomeContador ) ,
"Valor de contagem errado." ) ;
} /* fim ativa: Tratar CNT &Obter valor de contagem */
/* Tratar Exibir valor de contagem */
else if ( strcmp( ComandoTeste , EXIBIR_CONTAGEM_CMD ) == 0 )
{
/*
long CNT_ObterContagem( char * NomeContador )
*/
numLidos = LER_LerParametros( "s" ,
NomeContador ) ;
if ( numLidos != 1 )
{
return TST_CondRetParm ;
} /* if */
IntObtido = ( int ) CNT_ObterContagem( NomeContador ) ;
if ( IntObtido == CNT_CondRetNaoContador )
{
TST_NotificarFalha( "Contador desconhecido: " ) ;
fprintf( TST_ObterArqLog( ) , "\"%s\"" , NomeContador ) ;
return TST_CondRetErro ;
} /* if */
TST_ExibirPrefixo( SINALIZA_COMENTARIO , "" ) ;
fprintf( TST_ObterArqLog( ) , "Valor do contador \"%s\" é: %d " ,
NomeContador , IntObtido ) ;
return TST_CondRetOK ;
} /* fim ativa: Tratar Exibir valor de contagem */
/* Tratar CNT &Obter número de contadores */
else if ( strcmp( ComandoTeste , OBTER_NUM_CONTADORES_CMD ) == 0 )
{
/*
int CNT_ObterNumeroContadores( )
*/
numLidos = LER_LerParametros( "i" ,
&IntEsp ) ;
if ( numLidos != 1 )
{
return TST_CondRetParm ;
} /* if */
return TST_CompararInt( IntEsp , CNT_ObterNumeroContadores( ) ,
"Número de contadores errado." ) ;
} /* fim ativa: Tratar CNT &Obter número de contadores */
/* Tratar CNT &Obter total de contagem */
else if ( strcmp( ComandoTeste , OBTER_TOTAL_CONTAGEM_CMD ) == 0 )
{
/*
long CNT_ObterContagemTotal( )
*/
numLidos = LER_LerParametros( "i" ,
&IntEsp ) ;
if ( numLidos != 1 )
{
return TST_CondRetParm ;
} /* if */
return TST_CompararInt( IntEsp ,
( int ) CNT_ObterContagemTotal( ) ,
"Contagem total errada." ) ;
} /* fim ativa: Tratar CNT &Obter total de contagem */
/* Tratar CNT &Verificar contagem */
else if ( strcmp( ComandoTeste , VERIFICAR_CONTAGENS_CMD ) == 0 )
{
/*
int CNT_VerificarContagem( )
*/
numLidos = LER_LerParametros( "i" ,
&IntEsp ) ;
if ( numLidos != 1 )
{
return TST_CondRetParm ;
} /* if */
return TST_CompararInt( IntEsp ,
CNT_VerificarContagem( ) ,
"Número de contadores zero errado." ) ;
} /* fim ativa: Tratar CNT &Verificar contagem */
return TST_CondRetNaoExecutou ;
} /* Fim função: ICNT &Interpretar comandos de contagem */
TST_tpCondRet TST_EfetuarComando( char * ComandoTeste )
{
int inxPilha = -1 ,
inxDado = -1,
numLidos = -1 ,
CondRetEsp = -1 ;
PIL_tpCondRet CondRet ;
char StringDado [ DIM_VALOR ] ;
char vetDado[] = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'} ;
char teste = '\0' ;
int ValEsp = -1 ;
int i ;
int numElem = -1 ;
void *EndObtido = NULL;
void *EndEsperado = NULL;
StringDado[ 0 ] = 0 ;
/* Efetuar reset de teste de pilha */
if ( strcmp( ComandoTeste , RESET_PILHA_CMD ) == 0 )
{
for( i = 0 ; i < DIM_VT_PILHA ; i++ )
{
vtPilhas[ i ] = NULL ;
} /* for */
return TST_CondRetOK ;
} /* fim ativa: Efetuar reset de teste de pilha */
/* Testar CriarPilha */
else if ( strcmp( ComandoTeste , CRIAR_PILHA_CMD ) == 0 )
{
numLidos = LER_LerParametros( "ii" ,
&inxPilha, &CondRetEsp ) ;
if ( ( numLidos != 2 )
|| ( ! ValidarInxPilha( inxPilha , VAZIO )))
{
return TST_CondRetParm ;
} /* if */
CondRet = PIL_CriarPilha( &vtPilhas[ inxPilha ] ) ;
return TST_CompararInt( CondRetEsp , CondRet ,
"Erro ao criar pilha." ) ;
} /* fim ativa: Testar CriarPilha */
/* Testar Esvaziar pilha */
else if ( strcmp( ComandoTeste , ESVAZIAR_PILHA_CMD ) == 0 )
{
numLidos = LER_LerParametros( "ii" ,
&inxPilha, &CondRetEsp ) ;
if ( ( numLidos != 2 )
|| ( ! ValidarInxPilha( inxPilha , NAO_VAZIO )))
{
return TST_CondRetParm ;
} /* if */
return TST_CompararInt( CondRetEsp, PIL_EsvaziarPilha( vtPilhas[ inxPilha ] ),
"Retorno inesperado." );
} /* fim ativa: Testar Esvaziar pilha */
/* Testar Destruir pilha */
else if ( strcmp( ComandoTeste , DESTRUIR_PILHA_CMD ) == 0 )
{
numLidos = LER_LerParametros( "ii" ,
&inxPilha, &CondRetEsp ) ;
if ( ( numLidos != 2 )
|| ( ! ValidarInxPilha( inxPilha , NAO_VAZIO )))
{
return TST_CondRetParm ;
} /* if */
CondRet = PIL_DestruirPilha( vtPilhas[ inxPilha ] ) ;
vtPilhas[ inxPilha ] = NULL ;
return TST_CompararInt( CondRetEsp , CondRet , "Retorno inesperado." ) ;
} /* fim ativa: Testar Destruir pilha */
/* Testar inserir elemento */
else if ( strcmp( ComandoTeste , EMPILHAR_CMD ) == 0 )
{
numLidos = LER_LerParametros( "iii" ,
&inxPilha , &inxDado , &CondRetEsp ) ;
if ( ( numLidos != 3 )
|| ( ! ValidarInxPilha( inxPilha , NAO_VAZIO )) )
{
return TST_CondRetParm ;
} /* if */
CondRet = PIL_Empilha( vtPilhas[ inxPilha ], &vetDado[inxDado]);
return TST_CompararInt( CondRetEsp , CondRet ,
"Condicao de retorno errada ao inserir antes." ) ;
} /* fim ativa: Testar inserir elemento */
/* Testar excluir elemento */
else if ( strcmp( ComandoTeste , DESEMPILHAR_CMD ) == 0 )
{
numLidos = LER_LerParametros( "ii" ,
&inxPilha , &CondRetEsp ) ;
if ( ( numLidos != 2 )
|| ( ! ValidarInxPilha( inxPilha , NAO_VAZIO )) )
{
return TST_CondRetParm ;
} /* if */
return TST_CompararInt( CondRetEsp ,
PIL_Desempilha( vtPilhas[ inxPilha ] ) ,
"Condição de retorno errada ao excluir." ) ;
} /* fim ativa: Testar excluir elemento */
/* Testar obter valor do elemento corrente */
else if ( strcmp( ComandoTeste , OBTER_VALOR_CMD ) == 0 )
{
numLidos = LER_LerParametros( "iici" ,
&inxPilha , &inxDado , &teste , &ValEsp ) ;
if ( numLidos != 4 )
{
return TST_CondRetParm ;
} /* if */
CondRet = PIL_ObterValor( vtPilhas[ inxPilha ], &EndObtido );
if ( CondRet != PIL_CondRetOK )
{
return TST_CompararInt( ValEsp , CondRet ,
"Erro ao obter endereço do elemento." ) ;
} /* if */
EndEsperado = &vetDado[inxDado];
if ( EndEsperado != EndObtido )
{
return TST_CompararPonteiro( EndEsperado, EndObtido, "Endereço obtido errado." );
} /*if*/
return TST_CompararChar( teste , *(char*)EndObtido ,
"Valor do elemento errado." ) ;
} /* fim ativa: Testar obter valor do elemento corrente */
return TST_CondRetNaoConhec ;
} /* Fim função: TPIL &Testar pilha */
TST_tpCondRet TST_EfetuarComando(char *ComandoTeste)
{
int inxLista = -1;
int numLidos = -1;
int CondRetEsp = -1;
char StringDado[DIM_VALOR];
int i;
int CondRet;
int tipo = -1;
int caracter = -1;
StringDado[0] = 0;
/* Efetuar reset de teste de peca */
if(strcmp(ComandoTeste, RESET_PECA_CMD) == 0) {
for(i = 0; i < DIM_VT_PECA; i++)
vtPecas[i] = NULL;
return TST_CondRetOK;
} /* fim ativa: Efetuar reset de teste de lista */
/* Testar Criar peca */
else if(strcmp(ComandoTeste, CRIAR_PECA_CMD) == 0) {
numLidos = LER_LerParametros("iis", &inxLista, &tipo, StringDado);
if((numLidos != 3) || (!ValidarInxPeca(inxLista, VAZIO)))
return TST_CondRetParm;
vtPecas[inxLista] = PEC_criar(tipo, StringDado[0]);
return TST_CompararPonteiroNulo(1, vtPecas[inxLista], "Erro em ponteiro de nova peca.");
} /* fim ativa: Testar Criar peca */
/* Testar Destruir peca*/
else if(strcmp(ComandoTeste, DESTRUIR_PECA_CMD) == 0) {
numLidos = LER_LerParametros("ii", &inxLista, &CondRetEsp);
if((numLidos != 2) || (!ValidarInxPeca(inxLista, INDIFERENTE)))
return TST_CondRetParm;
CondRet = PEC_destruir(vtPecas[inxLista]);
vtPecas[inxLista] = NULL;
return TST_CompararInt(CondRetEsp, CondRet, "Condicao de retorno errada ao destruir a peca.") ;
} /* fim ativa: Testar Destruir peca */
/* Testar Obter Tipo da peca*/
else if(strcmp(ComandoTeste, OBTER_TIPO_CMD) == 0) {
numLidos = LER_LerParametros("ii", &inxLista, &CondRetEsp);
if((numLidos != 2) || (!ValidarInxPeca(inxLista, NAO_VAZIO)))
return TST_CondRetParm;
tipo = PEC_obterTipo(vtPecas[inxLista]);
return TST_CompararInt(CondRetEsp, tipo, "Tipo errado ao obter tipo.");
} /* fim ativa: Testar Obter Tipo da peca */
/* Testar Setar Tipo da peca*/
else if(strcmp(ComandoTeste, SETAR_TIPO_CMD) == 0) {
numLidos = LER_LerParametros("iii", &inxLista, &tipo, &CondRetEsp);
if((numLidos != 3) || (!ValidarInxPeca(inxLista, INDIFERENTE)))
return TST_CondRetParm;
CondRet = PEC_setarTipo(vtPecas[inxLista], tipo);
return TST_CompararInt(CondRetEsp, CondRet, "Condicao de retorno errada ao setar tipo da peca.");
} /* fim ativa: Testar Setar Tipo da peca */
/* Testar Obter Caracter da peca*/
else if(strcmp(ComandoTeste, OBTER_CARACTER_CMD) == 0) {
numLidos = LER_LerParametros("is", &inxLista, StringDado);
if((numLidos != 2) || (!ValidarInxPeca(inxLista, NAO_VAZIO)))
return TST_CondRetParm;
caracter = PEC_obterCaracter(vtPecas[inxLista]);
return TST_CompararEspaco(StringDado, &caracter, 1, "Caracter errado ao obter caracter.");
} /* fim ativa: Testar Obter Caracter da peca */
/* Testar Setar Caracter da peca*/
else if(strcmp(ComandoTeste, SETAR_CARACTER_CMD) == 0) {
numLidos = LER_LerParametros("isi", &inxLista, StringDado, &CondRetEsp);
if((numLidos != 3) || (!ValidarInxPeca(inxLista, INDIFERENTE)))
return TST_CondRetParm;
CondRet = PEC_setarCaracter(vtPecas[inxLista], StringDado[0]);
return TST_CompararInt(CondRetEsp, CondRet, "Condicao de retorno errada ao setar caracter da peca.");
} /* fim ativa: Testar Setar Caracter da peca */
return TST_CondRetNaoConhec;
} /* Fim função: TPEC &Testar peca */
TST_tpCondRet TST_EfetuarComando( char * ComandoTeste )
{
int indice,
numLidos = -1,
CondRetEsp = -1,
indicePeca,
casa,
passos,
quantidadePecasEsp,
quantidadePecas;
void *valorPeca;
int * pecaRecebida;
int * vtPeca[10];
TST_tpCondRet Ret;
for (indice = 0; indice < 10; indice++){
vtPeca[indice] = (int*)malloc(sizeof(int));
if (vtPeca == NULL)
{
return TST_CondRetMemoria;
} /* if */
*vtPeca[indice] = indice;
} /* for */
TAB_tpCondRet CondRet ;
/* testar criar um tabuleiro */
if ( strcmp( ComandoTeste , CRIAR_TABULEIRO_CMD ) == 0 )
{
numLidos = LER_LerParametros( "i" ,
&CondRetEsp) ;
if ( numLidos != 1 ) {
return TST_CondRetParm ;
} /* if */
CondRet = TAB_CriarTabuleiro(&pTabuleiro);
return TST_CompararInt( CondRetEsp , CondRet ,
"Condicao de retorno errada ao criar tabuleiro.");
} /* Fim ativa: Testar criar um tabuleiro */
/* Testar destruir um tabuleiro */
else if ( strcmp( ComandoTeste , DESTRUIR_TABULEIRO_CMD ) == 0 )
{
numLidos = LER_LerParametros( "i" ,
&CondRetEsp) ;
if ( numLidos != 1 ) {
return TST_CondRetParm ;
} /* if */
CondRet = TAB_DestruirTabuleiro(&pTabuleiro);
return TST_CompararInt( CondRetEsp , CondRet ,
"Condicao de retorno errada ao destruir tabuleiro.");
} /* Fim ativa: Testar destruir tabuleiro */
/* Testar inserir peca */
else if (strcmp(ComandoTeste, INSERIR_PECA_CMD) == 0)
{
numLidos = LER_LerParametros("iii",
&indicePeca, &casa, &CondRetEsp);
if (numLidos != 3) {
return TST_CondRetParm;
} /* if */
CondRet = TAB_InserirPeca(&pTabuleiro, vtPeca[indicePeca], casa);
if (CondRet != TAB_CondRetOK)
free(vtPeca[indicePeca]);
return TST_CompararInt(CondRetEsp, CondRet,
"Condicao de retorno errada ao inserir peca.");
} /* Fim ativa: Testar inserir peca */
/* Testar retirar peca */
else if (strcmp(ComandoTeste, RETIRAR_PECA_CMD) == 0)
{
numLidos = LER_LerParametros("iii",
&indicePeca, &casa, &CondRetEsp);
if (numLidos != 3) {
return TST_CondRetParm;
} /* if */
CondRet = TAB_RetirarPeca(&pTabuleiro, &valorPeca, casa);
Ret = TST_CompararInt(CondRetEsp, CondRet,
"Condicao de retorno errada ao retirar peca.");
if (Ret != TST_CondRetOK)
return Ret;
pecaRecebida = (int *)valorPeca;
Ret = TST_CompararInt(*vtPeca[indicePeca], *pecaRecebida, "peca recebida errada");
free(pecaRecebida);
return Ret;
} /* Fim ativa: Testar retirar peca */
/* Testar mover peca */
else if (strcmp(ComandoTeste, MOVER_PECA_CMD) == 0)
{
numLidos = LER_LerParametros("iii",
&casa, &passos, &CondRetEsp);
if (numLidos != 3) {
return TST_CondRetParm;
} /* if */
CondRet = TAB_MoverPeca(&pTabuleiro, casa, passos);
return TST_CompararInt(CondRetEsp, CondRet,
"Condicao de retorno errada ao mover peca.");
} /* Fim ativa: Testar mover peca */
/* Testar quantidade peca */
else if (strcmp(ComandoTeste, QUANTIDADE_PECA_CMD) == 0)
{
numLidos = LER_LerParametros("iii",
&casa, &quantidadePecasEsp, &CondRetEsp);
if (numLidos != 3) {
return TST_CondRetParm;
} /* if */
CondRet =TAB_QuantidadePecasCasa(pTabuleiro, casa, &quantidadePecas);
Ret = TST_CompararInt(CondRetEsp, CondRet,
"Condicao de retorno errada ao contar peca.");
if (Ret != TST_CondRetOK)
return Ret;
return TST_CompararInt(quantidadePecasEsp, quantidadePecas, "numero de pecas errado");
} /* Fim ativa: Testar quantidade peca */
/* Liberar espaco alocado teste */
else if (strcmp(ComandoTeste, LIBERAR_CMD) == 0)
{
for (indice = 0; indice < 10; indice++)
free(vtPeca[indice]);
return TST_CondRetOK;
} /* Fim ativa: Liberar espaco alocado teste */
return TST_CondRetNaoConhec ;
} /* Fim função: TTAB &Testar tabuleiro */
TST_tpCondRet TST_EfetuarComando( char * ComandoTeste )
{
PIL_tpCondRet CondRetObtido = PIL_CondRetOK ;
PIL_tpCondRet CondRetEsperada = PIL_CondRetFaltouMemoria ;
/* inicializa para qualquer coisa */
char NaipeEsperado = '?' ;
char NaipeObtido = '!' ;
char NaipeDado = '\0' ;
int ValorEsperado = -1 ;
int ValorObtido = -2 ;
int ValorDado = 0 ;
int PosicaoPilha = -1 ;
int NumPilha = -1 ;
int NumLidos = -1 ;
CAR_tppCarta CartaObtida ;
CAR_tppCarta CartaDada ;
TST_tpCondRet Ret ;
/* Testar PIL Criar Pilha de Cartas */
if ( strcmp( ComandoTeste , CRIAR_PIL_CMD ) == 0 )
{
NumLidos = LER_LerParametros( "ii" , &NumPilha ,
&CondRetEsperada ) ;
if ( NumLidos != 2 || NumPilha >= MAX_PILS || NumPilha < 0 )
{
return TST_CondRetParm ;
} /* if */
CondRetObtido = PIL_CriarPilhaVazia( &vPilhas[NumPilha] ) ;
return TST_CompararInt( CondRetEsperada , CondRetObtido ,
"Retorno errado ao criar pilha." );
} /* fim ativa: Testar PIL Criar Pilha de cartas*/
/* Testar PIL Push Carta na pilha */
else if ( strcmp( ComandoTeste , PUSH_CMD ) == 0 )
{
NumLidos = LER_LerParametros( "icii" ,
&NumPilha, &NaipeDado , &ValorDado, &CondRetEsperada ) ;
if ( NumLidos != 4 || NumPilha >= MAX_PILS || NumPilha < 0 )
{
return TST_CondRetParm ;
} /* if */
CAR_CriarCarta( &CartaDada ) ;
CAR_PreencheCarta( CartaDada, NaipeDado , ValorDado );
CondRetObtido = PIL_PushCarta( vPilhas[NumPilha] , CartaDada ) ;
return TST_CompararInt( CondRetEsperada , CondRetObtido ,
"Retorno errado ao operar 'push' na pilha" );
} /* fim ativa: Testar PIL Push Carta na pilha */
/* Testar PIL Pop Carta da Pilha */
else if ( strcmp( ComandoTeste , POP_CMD ) == 0 )
{
NumLidos = LER_LerParametros( "ii" ,
&NumPilha , &CondRetEsperada ) ;
if ( NumLidos != 2 || NumPilha >= MAX_PILS || NumPilha < 0 )
{
return TST_CondRetParm ;
} /* if */
CondRetObtido = PIL_PopCarta( vPilhas[NumPilha] , &CartaObtida ) ;
return TST_CompararInt( CondRetEsperada , CondRetObtido ,
"Retorno errado ao operar 'pop' na pilha") ;
} /* Testar PIL Ver Carta da Pilha */
else if ( strcmp( ComandoTeste , VER_CMD ) == 0 )
{
NumLidos = LER_LerParametros( "iii" ,
&NumPilha , &PosicaoPilha , &CondRetEsperada ) ;
if ( NumLidos != 3 || NumPilha >= MAX_PILS || NumPilha < 0 )
{
return TST_CondRetParm ;
} /* if */
CondRetObtido = PIL_VerCarta( vPilhas[NumPilha] , &CartaObtida , PosicaoPilha ) ;
return TST_CompararInt( CondRetEsperada , CondRetObtido ,
"Retorno errado ao ver carta da pilha") ;
} /* Testar PIL Ver Carta da Pilha */
/* Testar PIL Destruir pilha de cartas */
else if ( strcmp( ComandoTeste , DESTROI_CMD ) == 0 )
{
NumLidos = LER_LerParametros( "ii" , &NumPilha ,
&CondRetEsperada ) ;
if ( NumLidos != 2 || NumPilha >= MAX_PILS || NumPilha < 0 )
{
return TST_CondRetParm ;
} /* if */
CondRetObtido = PIL_DestruirPilha( vPilhas[NumPilha] ) ;
return TST_CompararInt( CondRetEsperada , CondRetObtido ,
"Retorno errado destruir pilha." );
} /* fim ativa: Testar PIL Destruir Pilha de Cartas */
/* Testar PIL Destruir Pilha */
return TST_CondRetNaoConhec ;
} /* Fim função: TPIL Efetuar operações de teste específicas para pilha de cartas */
TST_tpCondRet TST_EfetuarComando(char *ComandoTeste)
{
int numLidos = -1,
CondRetEsp = -1;
TST_tpCondRet CondRet;
/*Testar CriarGrafo */
if (strcmp (ComandoTeste, CRIAR_GRAFO_CMD) == 0)
{
numLidos = LER_LerParametros("i", &CondRetEsp);
if (numLidos != 1)
{
return TST_CondRetParm;
}
CondRet = GRA_CriarGrafo(&pGrafo, DestruirValor);
if(CondRet == GRA_CondRetOK)
{
CondRet = TST_CompararPonteiroNulo(1, pGrafo, "Erro em ponteiro de nova lista.");
return CondRet;
}
return TST_CondRetErro;
}
/*Testar Destruir grafo */
else if (strcmp(ComandoTeste, DESTRUIR_GRAFO_CMD) == 0)
{
numLidos = LER_LerParametros("i", &CondRetEsp);
if (numLidos != 1)
{
return TST_CondRetParm;
}
CondRet = GRA_DestruirGrafo(&pGrafo);
return TST_CompararInt(CondRetEsp, CondRet, "Erro ao destruir grafo");
}
/*Testar inserir vertice */
else if (strcmp(ComandoTeste, INS_VERT_CMD) == 0)
{
char *nome = AlocarEspacoParaNome();
char *pDado = AlocarEspacoParaNome();
numLidos = LER_LerParametros("ssi", nome, pDado, &CondRetEsp);
if (numLidos != 3)
{
return TST_CondRetParm;
}
CondRet = GRA_InserirVertice(pGrafo, nome, pDado);
return TST_CompararInt(CondRetEsp, CondRet, "Condicao de retorno errada ao inserir vértice.");
}
/*Testar inserir aresta */
else if (strcmp(ComandoTeste, INS_ARESTA_CMD) == 0)
{
char *nomeAresta = AlocarEspacoParaNome();
char *nomeVerticeOrig = AlocarEspacoParaNome();
char *nomeVerticeDest = AlocarEspacoParaNome();
numLidos = LER_LerParametros("sssi", nomeAresta, nomeVerticeOrig, nomeVerticeDest, &CondRetEsp);
if (numLidos != 4)
{
return TST_CondRetParm;
}
CondRet = GRA_InserirAresta(pGrafo, nomeAresta, nomeVerticeOrig, nomeVerticeDest);
MEM_Free(nomeVerticeOrig);
MEM_Free(nomeVerticeDest);
return TST_CompararInt(CondRetEsp, CondRet, "Condicao de retorno errada ao inserir aresta.");
}
/*Testar obter valor do vértice corrente */
else if (strcmp(ComandoTeste, OBTER_VALOR_CMD) == 0)
{
char *pDadoEsperado = AlocarEspacoParaNome();
char *pDadoObtido;
numLidos = LER_LerParametros("si", pDadoEsperado, &CondRetEsp);
if (numLidos != 2)
{
MEM_Free(pDadoEsperado);
return TST_CondRetParm;
}
if (strcmp(pDadoEsperado, SIMBOLO_PARA_NULL) == 0)
{
pDadoEsperado = NULL;
}
CondRet = GRA_ObterValorCorrente(pGrafo, (void**) &pDadoObtido);
if (CondRetEsp == TST_CondRetOK)
{
CondRet = TST_CompararString(pDadoEsperado, pDadoObtido, "Valor do elemento errado.");
MEM_Free(pDadoEsperado);
return CondRet;
}
else
{
MEM_Free(pDadoEsperado);
if (pDadoObtido != NULL)
{
return TST_NotificarFalha("Não foi obtido null como conteudo ao ocorrer um erro.");
}
return TST_CompararInt(CondRetEsp, CondRet, "Não ocorreu o erro esperado na obtenção do conteudo.");
}
}
/*Testar alterar valor do vértice corrente */
else if (strcmp(ComandoTeste, ALTER_VALOR_CMD) == 0)
{
char *pNovoValor = AlocarEspacoParaNome();
char *pAntigoValor;
numLidos = LER_LerParametros("si", pNovoValor, &CondRetEsp);
if (numLidos != 2)
{
return TST_CondRetParm;
}
GRA_ObterValorCorrente(pGrafo, (void**) &pAntigoValor);
MEM_Free(pAntigoValor);
CondRet = GRA_AlterarValorCorrente(pGrafo, pNovoValor);
return TST_CompararInt(CondRetEsp, CondRet, "Ocorreu um erro ao alterar o valor.");
}
/*Testar tornar corrente uma origem */
else if (strcmp(ComandoTeste, TORNAR_ORIGEM_CMD) == 0)
{
numLidos = LER_LerParametros("i", &CondRetEsp);
if (numLidos != 1)
{
return TST_CondRetParm;
}
CondRet = GRA_TornarCorrenteUmaOrigem(pGrafo);
return TST_CompararInt(CondRetEsp, CondRet, "Ocorreu um erro ao tornar o corrente uma origem.");
}
/*Testar tornar corrente uma origem */
else if (strcmp(ComandoTeste, DEIXAR_ORIGEM_CMD) == 0)
{
numLidos = LER_LerParametros("i", &CondRetEsp);
if (numLidos != 1)
{
return TST_CondRetParm;
}
CondRet = GRA_DeixarDeSerOrigem(pGrafo);
return TST_CompararInt(CondRetEsp, CondRet, "Ocorreu um erro remover uma origem.");
}
/*Testar seguir pela aresta */
else if (strcmp(ComandoTeste, IR_ARESTA_CMD) == 0)
{
char *nomeDaAresta = AlocarEspacoParaNome();
numLidos = LER_LerParametros("si", nomeDaAresta, &CondRetEsp);
if (numLidos != 2)
{
return TST_CondRetParm;
}
CondRet = GRA_SeguirPelaAresta(pGrafo, nomeDaAresta);
MEM_Free(nomeDaAresta);
return TST_CompararInt(CondRetEsp, CondRet, "Ocorreu um erro ao ir para vértice adjacente.");
}
/*Testar ir vertice adjacente */
else if (strcmp(ComandoTeste, IR_VERTICE_CMD) == 0)
{
char *nomeVertice = AlocarEspacoParaNome();
numLidos = LER_LerParametros("si", nomeVertice, &CondRetEsp);
if (numLidos != 2)
{
return TST_CondRetParm;
}
CondRet = GRA_IrParaVerticeAdjacente(pGrafo, nomeVertice);
MEM_Free(nomeVertice);
return TST_CompararInt(CondRetEsp, CondRet, "Ocorreu um erro ao ir para vértice adjacente.");
}
/*Testar ir para origem */
else if (strcmp(ComandoTeste, IR_ORIGEM_CMD) == 0)
{
char *nomeVertice = AlocarEspacoParaNome();
numLidos = LER_LerParametros("si", nomeVertice, &CondRetEsp);
if (numLidos != 2)
{
return TST_CondRetParm;
}
CondRet = GRA_IrParaAOrigem(pGrafo, nomeVertice);
MEM_Free(nomeVertice);
return TST_CompararInt(CondRetEsp, CondRet, "Ocorreu um erro ao ir para origem.");
}
/*Testar ir destruir aresta adjacente */
else if (strcmp(ComandoTeste, DESTRUIR_ARESTA_CMD) == 0)
{
char *nomeAresta = AlocarEspacoParaNome();
numLidos = LER_LerParametros("si", nomeAresta, &CondRetEsp);
if (numLidos != 2)
{
return TST_CondRetParm;
}
CondRet = GRA_DestruirArestaAdjacente(pGrafo, nomeAresta);
MEM_Free(nomeAresta);
return TST_CompararInt(CondRetEsp, CondRet, "Ocorreu um erro ao destruir aresta adjacente.");
}
/*Testar ir destruir aresta adjacente */
else if (strcmp(ComandoTeste, DESTRUIR_VERT_CMD) == 0)
{
numLidos = LER_LerParametros("i", &CondRetEsp);
if (numLidos != 1)
{
return TST_CondRetParm;
}
CondRet = GRA_DestruirVerticeCorrente(pGrafo);
return TST_CompararInt(CondRetEsp, CondRet, "Ocorreu um erro ao destruir vertice corrente.");
}
/* Finalizar o teste */
else if (strcmp(ComandoTeste, FIM_CMD) == 0)
{
MEM_LiberarTodaMemoriaAlocada();
return TST_CondRetOK;
}
return TST_CondRetNaoConhec;
}
TST_tpCondRet TST_EfetuarComando(char * ComandoTeste)
{
PILHA_tpCondRet CondRetRecebida;
PILHA_tpCondRet CondRetEsperada;
CAR_tpCarta CartaDada;
CAR_tpCarta CartaObtida;
int acao;
int nElem;
int NumLidos = -1;
int PosicaoPilha = -1;
int numeroPilha = -1;
char FaceEsperada = 'V';
char FaceObtida = 'E';
char FaceDada;
char NaipeEsperado = 'A';
char NaipeObtido = 'E';
char NaipeDado = 'O';
char PosicaoEsperada = '1';
char PosicaoObtida = '2';
char PosicaoDada = '4';
int numAlocAnt = CED_ObterNumeroEspacosAlocados();
/* Testar PILHA criarPilha */
if (strcmp(ComandoTeste, CRIAR_PILHA_CMD) == 0)
{
NumLidos = LER_LerParametros("ii", &numeroPilha, &CondRetEsperada);
if (NumLidos != 2 || numeroPilha >= 10 || numeroPilha < 0){
return TST_CondRetParm;
} /* if */
CondRetRecebida = PILHA_criarPilha(&nPilhas[numeroPilha]);
return TST_CompararInt(CondRetEsperada, CondRetRecebida, "Erro ao criar a Pilha.");
} /* fim ativa: Testar PILHA criarPilha */
/* Testar PILHA liberaPilha */
else if (strcmp(ComandoTeste, LIBERA_PILHA_CMD) == 0)
{
NumLidos = LER_LerParametros("ii", &numeroPilha, &CondRetEsperada);
if (NumLidos != 2 || numeroPilha >= 10 || numeroPilha < 0){
return TST_CondRetParm;
} /* if */
CondRetRecebida = PILHA_liberaPilha(nPilhas[numeroPilha]);
return TST_CompararInt(CondRetEsperada, CondRetRecebida, "Erro ao destruir a Pilha");
} /* fim ativa: Testar PILHA liberaPilha */
/* Testar PILHA num elem */
else if (strcmp(ComandoTeste, RETORNA_NUM_ELEM_CMD) == 0)
{
NumLidos = LER_LerParametros("ii", &numeroPilha, &CondRetEsperada);
if (NumLidos != 2 || numeroPilha >= 10 || numeroPilha < 0){
return TST_CondRetParm;
} /* if */
CondRetRecebida = PILHA_retornaNumElem(nPilhas[numeroPilha], &nElem);
return TST_CompararInt(CondRetEsperada, CondRetRecebida, "Erro ao saber a quantidade de cartas da Pilha");
}
/* Testar PILHA pushPilha */
else if (strcmp(ComandoTeste, PUSH_PILHA_CMD) == 0)
{
char naipe;
char posicao;
char face;
NumLidos = LER_LerParametros("iccci", &numeroPilha, &FaceDada, &NaipeDado, &PosicaoDada, &CondRetEsperada);
if (NumLidos != 5 || numeroPilha >= 10 || numeroPilha < 0){
return TST_CondRetParm;
} /* if */
CAR_criarCarta(&CartaDada);
CAR_editarCarta(CartaDada, FaceDada, NaipeDado, PosicaoDada);
CondRetRecebida = PILHA_pushPilha(nPilhas[numeroPilha], CartaDada);
//(CAR_tpCarta)LIS_ObterValor(nPilhas[numeroPilha], &CartaDada);
CAR_retornaFace(CartaDada, &face);
CAR_retornaNaipe(CartaDada, &naipe);
CAR_retornaPosicao(CartaDada, &posicao);
printf("Carta Push: %c %c %c", face, naipe, posicao);
return TST_CompararInt(CondRetEsperada, CondRetRecebida, "Erro ao push a Pilha.");
} /* fim ativa: Testar PILHA pushPilha */
/* Testar PILHA popPilha */
else if (strcmp(ComandoTeste, POP_PILHA_CMD) == 0)
{
NumLidos = LER_LerParametros("ii", &numeroPilha, &CondRetEsperada);
if (NumLidos != 2 || numeroPilha >= 10 || numeroPilha < 0){
return TST_CondRetParm;
} /* if */
CondRetRecebida = PILHA_popPilha(nPilhas[numeroPilha], &CartaObtida);
return TST_CompararInt(CondRetEsperada, CondRetRecebida, "Erro ao pop a pilha.");
} /* fim ativa: Testar PILHA popPilha */
/* Testar PILHA verificaPilhaVazia */
else if (strcmp(ComandoTeste, VERIFICA_PILHA_CMD) == 0)
{
NumLidos = LER_LerParametros("ii", &numeroPilha, &CondRetEsperada);
if (NumLidos != 2 || numeroPilha >= 10 || numeroPilha < 0){
return TST_CondRetParm;
} /* if */
CondRetRecebida = PILHA_verificaPilhaVazia(nPilhas[numeroPilha]);
return TST_CompararInt(CondRetEsperada, CondRetRecebida, "Erro ao verificar a Pilha");
} /* fim ativa: Testar PILHA verificaPilhaVazia */
/* Testar PILHA imprimePilha */
else if (strcmp(ComandoTeste, IMPRIME_PILHA_CMD) == 0)
{
NumLidos = LER_LerParametros("ii", &numeroPilha, &CondRetEsperada);
if (NumLidos != 2 || numeroPilha >= 10 || numeroPilha < 0){
return TST_CondRetParm;
} /* if */
CondRetRecebida = PILHA_imprimePilha(nPilhas[numeroPilha]);
return TST_CompararInt(CondRetEsperada, CondRetRecebida, "Erro ao imprimir a Pilha");
} /* fim ativa: Testar PILHA imprimePilha */
#ifdef _DEBUG
else if (strcmp(ComandoTeste, DETURPAR_CMD) == 0)
{
NumLidos = LER_LerParametros("iii", &numeroPilha, &acao, &CondRetEsperada);
if (NumLidos != 3 || numeroPilha >= 10 || numeroPilha < 0){
return TST_CondRetParm;
} /* if */
if (acao == 1){
numAlocAnt = CED_ObterNumeroEspacosAlocados();
}
CondRetRecebida = PILHA_deturpaPilha(nPilhas[numeroPilha], acao, &numAlocAnt);
return TST_CompararInt(CondRetEsperada, CondRetRecebida, "Erro ao Deturpar a Pilha");
} /* fim ativa: Testar PILHA DeturpaPilha */
#endif
#ifdef _DEBUG
else if (strcmp(ComandoTeste, VER_PILHA_CMD) == 0)
{
NumLidos = LER_LerParametros("ii", &numeroPilha, &CondRetEsperada);
if (NumLidos != 2 || numeroPilha >= 10 || numeroPilha < 0){
return TST_CondRetParm;
} /* if */
CondRetRecebida = PILHA_verificaNo(nPilhas[numeroPilha], numAlocAnt);
return TST_CompararInt(CondRetEsperada, CondRetRecebida, "Erro ao Verificar a Pilha");
} /* fim ativa: Testar PILHA VerificaPilha */
#endif
return TST_CondRetNaoConhec;
} /* Fim função: TESTPILHA Efetuar operações de teste específicas para cartas */
TST_tpCondRet TST_EfetuarComando( char * ComandoTeste )
{
/* Variáveis para retorno de operações com lista */
/* Devem ser inicializadas com qualquer valor */
LIS_tpCondRet LIS_CondRetObtido = LIS_CondRetOK ;
LIS_tpCondRet LIS_CondRetEsperada = LIS_CondRetFaltouMemoria ;
int indexFocoLista = '0';
int NumLidos = -1 ;
int i = 0;
int resposta = 0;
int numPassos = 0;
char * caracter;
char stringDado [2] ;
TST_tpCondRet Ret = TST_CondRetOK ;
stringDado[1]='\0';
/* Efetuar reset de teste de lista */
if ( strcmp (ComandoTeste, RESET_LIS_CMD) == 0 )
{
for ( i = 0; i < DIM_VT_LISTA; i++ )
vtListas[ i ] = NULL;
return TST_CondRetOK;
} /* Fim ativa: Efetuar reset de teste de lista */
/* Testar LIS Criar lista */
else if ( strcmp( ComandoTeste , CRIAR_LIS_CMD ) == 0 )
{
NumLidos = LER_LerParametros( "ii" ,
&indexFocoLista,
&LIS_CondRetEsperada ) ;
if ( NumLidos != 2 || !ValidarIndex ( indexFocoLista, DIM_VT_LISTA ) )
{
return TST_CondRetParm ;
} /* if */
LIS_CondRetObtido = LIS_CriarLista( &vtListas[ indexFocoLista ], DestruirConteudoLista );
return TST_CompararInt( LIS_CondRetEsperada , LIS_CondRetObtido ,
"Retorno errado ao criar lista." );
} /* Fim ativa: Testar LIS Criar lista */
/* Testar LIS Inserir elemento na lista antes do elemento corrente */
else if ( strcmp( ComandoTeste , INSERIR_ANTES_CMD ) == 0 )
{
NumLidos = LER_LerParametros( "ici" ,
&indexFocoLista,
stringDado,
&LIS_CondRetEsperada ) ;
if ( NumLidos != 3 || !ValidarIndex ( indexFocoLista, DIM_VT_LISTA ) )
{
return TST_CondRetParm ;
} /* if */
caracter = ( char * ) malloc( strlen( stringDado ) + 1 ) ;
if ( caracter == NULL )
{
return TST_CondRetMemoria ;
} /* if */
strcpy( caracter , stringDado ) ;
LIS_CondRetObtido = LIS_InserirElementoAntes ( vtListas[ indexFocoLista ], caracter );
return TST_CompararInt( LIS_CondRetEsperada , LIS_CondRetObtido ,
"Retorno errado ao inserir à esquerda (antes do elemento corrente da lista)." );
} /* fim ativa: Testar LIS Inserir elemento na lista antes do elemento corrente */
/* Testar LIS Inserir elemento na lista depois do elemento corrente */
else if ( strcmp( ComandoTeste , INSERIR_APOS_CMD ) == 0 )
{
NumLidos = LER_LerParametros( "ici" ,
&indexFocoLista,
stringDado,
&LIS_CondRetEsperada ) ;
if ( NumLidos != 3 || !ValidarIndex ( indexFocoLista, DIM_VT_LISTA ) )
{
return TST_CondRetParm ;
} /* if */
caracter = ( char * ) malloc( strlen( stringDado ) + 1 ) ;
if ( caracter == NULL )
{
return TST_CondRetMemoria ;
} /* if */
strcpy( caracter , stringDado ) ;
LIS_CondRetObtido = LIS_InserirElementoApos ( vtListas[ indexFocoLista ], caracter );
return TST_CompararInt( LIS_CondRetEsperada , LIS_CondRetObtido ,
"Retorno errado ao inserir à direita (após elemento corrente)." );
} /* fim ativa: Testar LIS Inserir elemento na lista depois do elemento corrente */
/* Testar LIS Ir para elemento inicial (origem da lista) */
else if ( strcmp( ComandoTeste , IR_INICIOLISTA_CMD ) == 0 )
{
NumLidos = LER_LerParametros( "ii" ,
&indexFocoLista,
&LIS_CondRetEsperada ) ;
if ( NumLidos != 2 || !ValidarIndex ( indexFocoLista, DIM_VT_LISTA ) )
{
return TST_CondRetParm ;
} /* if */
LIS_CondRetObtido = LIS_IrInicioLista( vtListas[ indexFocoLista ] ) ;
return TST_CompararInt( LIS_CondRetEsperada , LIS_CondRetObtido ,
"Retorno errado ao ir para o início da lista." );
} /* fim ativa: Testar LIS Ir para elemento inicial (origem da lista) */
/* Testar LIS Ir para elemento final (fim da lista) */
else if ( strcmp( ComandoTeste , IR_FIMLISTA_CMD ) == 0 )
{
NumLidos = LER_LerParametros( "ii" ,
&indexFocoLista,
&LIS_CondRetEsperada ) ;
if ( NumLidos != 2 || !ValidarIndex ( indexFocoLista, DIM_VT_LISTA ) )
{
return TST_CondRetParm ;
} /* if */
LIS_CondRetObtido = LIS_IrFinalLista( vtListas[ indexFocoLista ] ) ;
return TST_CompararInt( LIS_CondRetEsperada , LIS_CondRetObtido ,
"Retorno errado ao ir para o fim da lista." );
} /* fim ativa: Testar LIS Ir para elemento final (fim da lista) */
/* Testar LIS Percorre lista */
else if ( strcmp( ComandoTeste , PERCORRE_LIS_CMD ) == 0 )
{
NumLidos = LER_LerParametros( "iii" ,
&indexFocoLista,
&numPassos,
&LIS_CondRetEsperada ) ;
if ( NumLidos != 3 || !ValidarIndex ( indexFocoLista, DIM_VT_LISTA ) )
{
return TST_CondRetParm ;
} /* if */
LIS_CondRetObtido = LIS_PercorreLista( vtListas[ indexFocoLista ], numPassos ) ;
return TST_CompararInt( LIS_CondRetEsperada , LIS_CondRetObtido ,
"Retorno errado ao percorrer a lista." );
} /* fim ativa: Testar LIS Percorre lista */
/* Testar LIS Obter elementos existentes na lista */
else if ( strcmp ( ComandoTeste, OBTER_NUMELEMLISTA_CMD ) == 0 )
{
NumLidos = LER_LerParametros ( "ii",
&indexFocoLista,
&LIS_CondRetEsperada ) ;
if ( NumLidos != 2 || !ValidarIndex ( indexFocoLista, DIM_VT_LISTA ) )
{
return TST_CondRetParm;
}
LIS_CondRetObtido = LIS_ObterNumeroElementos ( vtListas[ indexFocoLista ], &resposta );
if ( LIS_CondRetObtido == LIS_CondRetOK )
{
printf ( "\nNumero de elementos na lista: %d\n", resposta );
}
return TST_CompararInt( LIS_CondRetEsperada , LIS_CondRetObtido ,
"Retorno errado ao requisitar número de elementos de lista." );
} /* fim ativa: Testar LIS Obter elementos existentes na lista */
/* Testar LIS Excluir elemento corrente da lista */
else if ( strcmp ( ComandoTeste, EXC_ELEM_CMD ) == 0 )
{
NumLidos = LER_LerParametros ( "ii",
&indexFocoLista,
&LIS_CondRetEsperada );
if ( NumLidos != 2 || !ValidarIndex ( indexFocoLista, DIM_VT_LISTA ))
{
return TST_CondRetParm;
}
LIS_CondRetObtido = LIS_ExcluirElementoCorrente ( vtListas[ indexFocoLista ] );
return TST_CompararInt( LIS_CondRetEsperada , LIS_CondRetObtido ,
"Retorno errado ao excluir elemento corrente da lista." );
} /* fim ativa: Testar LIS Excluir elemento corrente da lista */
/* Testar LIS Procurar valor nos elementos da lista */
else if ( strcmp ( ComandoTeste, PROCURA_VALISTA_CMD ) == 0 )
{
NumLidos = LER_LerParametros ( "ici",
&indexFocoLista,
stringDado,
&LIS_CondRetEsperada );
if ( NumLidos != 3 || !ValidarIndex ( indexFocoLista, DIM_VT_LISTA ))
{
return TST_CondRetParm;
}
LIS_CondRetObtido = LIS_ProcurarValor ( vtListas[ indexFocoLista ], (void**)&stringDado, ComparaConteudo );
return TST_CompararInt( LIS_CondRetEsperada , LIS_CondRetObtido ,
"Retorno errado ao procurar elemento da lista." );
} /* fim ativa: Testar LIS Procurar valor nos elementos da lista */
/* Testar LIS Obter valor armazenado no elemento corrente */
else if ( strcmp( ComandoTeste , OBTER_VALISTA_CMD ) == 0 )
{
NumLidos = LER_LerParametros( "ici" ,
&indexFocoLista,
stringDado,
&LIS_CondRetEsperada );
if ( NumLidos != 3 || !ValidarIndex( indexFocoLista, DIM_VT_LISTA ) )
{
return TST_CondRetParm ;
} /* if */
LIS_CondRetObtido = LIS_ObterValorCorrente ( vtListas[ indexFocoLista ], (void**)&caracter ) ;
if ( LIS_CondRetObtido == LIS_CondRetOK )
{
printf ("\nCaracter obtido: %c \n", *caracter );
return TST_CompararChar( stringDado[0], *caracter, "Caracteres diferentes" );
}
else
{
return TST_CompararInt( LIS_CondRetEsperada, LIS_CondRetObtido, "Retorno errado para obter elemento do elemento corrente da lista." );
}
} /* fim ativa: Testar LIS Obter valor armazenado no elemento corrente */
/* Testar LIS Esvaziar lista */
else if ( strcmp( ComandoTeste , ESVAZIAR_LIS_CMD ) == 0 )
{
NumLidos = LER_LerParametros ( "ii",
&indexFocoLista,
&LIS_CondRetEsperada );
if (NumLidos != 2 || !ValidarIndex ( indexFocoLista, DIM_VT_LISTA ) )
{
return TST_CondRetParm;
}
LIS_CondRetObtido = LIS_EsvaziarLista ( vtListas[ indexFocoLista ] ) ;
return TST_CompararInt ( LIS_CondRetEsperada, LIS_CondRetObtido, "Retorno de erro ao esvaziar lista." );
} /* fim ativa: Testar LIS Esvaziar lista */
/* Testar LIS Destruir lista */
else if ( strcmp( ComandoTeste , DESTROI_LIS_CMD ) == 0 )
{
NumLidos = LER_LerParametros ( "ii",
&indexFocoLista,
&LIS_CondRetEsperada );
if ( NumLidos != 2 || !ValidarIndex ( indexFocoLista, DIM_VT_LISTA ) )
{
return TST_CondRetParm;
}
LIS_CondRetObtido = LIS_DestruirLista( &vtListas[ indexFocoLista ] ) ;
return TST_CompararInt( LIS_CondRetEsperada , LIS_CondRetObtido ,
"Retorno errado ao destruir lista." );
} /* fim ativa: Testar LIS Destruir lista */
return TST_CondRetNaoConhec ;
} /* Fim função: TLIS Efetuar operações de teste específicas para lista de caracteres */
TST_tpCondRet TST_EfetuarComando(char *ComandoTeste)
{
int numLidos = -1,
CondRetEsp = -1;
TST_tpCondRet CondRet;
PAS_tppPasso PASSOS[3][MAX_PASSOS];
int PASSOS_SIZE[3];
PAS_CriarPasso(&PASSOS[0][0], NORTE, 2);
PASSOS_SIZE[0] = 1;
PAS_CriarPasso(&PASSOS[1][0], SUL, 2);
PAS_CriarPasso(&PASSOS[1][1], ESTE, 5);
PASSOS_SIZE[1] = 2;
PAS_CriarPasso(&PASSOS[2][0], OESTE, 2);
PAS_CriarPasso(&PASSOS[2][1], NOROESTE, 1);
PAS_CriarPasso(&PASSOS[2][2], ESTE, 0);
PASSOS_SIZE[2] = 3;
/*Testar Ler tipo de movimento*/
if (strcmp (ComandoTeste, LER_TIPO_MOVIMENTO_CMD) == 0)
{
char *tipoStr;
int tipoEsperado;
MPEC_tpTipoMovimento tipoObtido;
MEM_Alloc(sizeof(tipoStr)*MAX_TIPO_STR, (void **) &tipoStr);
numLidos = LER_LerParametros("sii", tipoStr, &tipoEsperado, &CondRetEsp);
if (numLidos != 3)
{
return TST_CondRetParm;
}
CondRet = ISP_LerTipoMovimento(tipoStr, &tipoObtido);
if(CondRet == ISP_CondRetOK)
{
TST_CompararInt(tipoEsperado, (int) tipoObtido, "Não foi obtido o tipo esperado.");
}
return CondRet;
}
/*Testar Ler passos*/
if (strcmp(ComandoTeste, LER_PASSOS_CMD) == 0)
{
char *passosStr;
int iPassosEsperado;
LIS_tppLista pPassosEsperado;
LIS_tppLista pPassosObtido;
MEM_Alloc(sizeof(passosStr)*MAX_PASSOS_STR, (void **) &passosStr);
numLidos = LER_LerParametros("sii", passosStr, &iPassosEsperado, &CondRetEsp);
if (numLidos != 3)
{
return TST_CondRetParm;
}
pPassosEsperado = CriarListaPassos(PASSOS[iPassosEsperado], PASSOS_SIZE[iPassosEsperado]);
CondRet = ISP_LerPassos(passosStr, &pPassosObtido);
if (CondRet == ISP_CondRetOK)
{
if (!ListaDePassosSaoIguais(pPassosEsperado, pPassosObtido))
{
TST_NotificarFalha("A lista de passos obtida não é igual à esperada");
return TST_CondRetErro;
}
}
return CondRet;
}
/* Finalizar o teste */
else if (strcmp(ComandoTeste, FIM_CMD) == 0)
{
MEM_LiberarTodaMemoriaAlocada();
return TST_CondRetOK;
}
return TST_CondRetNaoConhec;
}
TST_tpCondRet TST_EfetuarComando( char * ComandoTeste )
{
MAT_tpCondRet CondRetObtido = MAT_CondRetOK ;
MAT_tpCondRet CondRetEsperada = MAT_CondRetFaltouMemoria ;
/* inicializa para qualquer coisa */
char StringDado[ DIM_VALOR ] ;
int i ,
valor;
int numColuna,
numLinha;
int NumLidos = -1 ;
int inxMatriz = -1 ;
numColuna = -1;
numLinha = -1;
valor = -1;
StringDado[ 0 ] = 0 ;
#ifdef _DEBUG
int IntEsperado = -1 ;
#endif
/* Tratar: inicializar contexto */
if ( strcmp( ComandoTeste , RESET_CMD ) == 0 )
{
if ( estaInicializado )
{
for( i = 0 ; i < DIM_VT_MATRIZES ; i++ )
{
destruirMatriz( ( vtRefMatriz[ i ] )) ;
} /* for */
} /* if */
for( i = 0 ; i < DIM_VT_MATRIZES ; i++ )
{
vtRefMatriz[ i ] = 0 ;
} /* for */
estaInicializado = 1 ;
} /* fim ativa: Tratar: inicializar contexto */
/* Testar MAT Criar matriz */
// else if ( strcmp( ComandoTeste , CRIAR_MAT_CMD ) == 0 )
// {
// NumLidos = LER_LerParametros( "ii" ,
// &inxMatriz , &CondRetEsperada ) ;
// if ( ( NumLidos != 2 )
// || !VerificarInx( inxMatriz ))
// {
// return TST_CondRetParm ;
// } /* if */
//CondRetObtido = criarMatriz( &(vtRefMatriz[inxMatriz] ));
// return TST_CompararInt( CondRetEsperada , CondRetObtido ,
// "Retorno errado ao criar matriz." );
// } /* fim ativa: Testar MAT Criar matriz */
/* Testar MAT Adicionar linha à matriz */
// else if ( strcmp( ComandoTeste , INS_LIN_CMD ) == 0 )
// {
// NumLidos = LER_LerParametros( "ii" ,
// &inxMatriz , &CondRetEsperada ) ;
// if ( ( NumLidos != 2 )
// || !VerificarInx( inxMatriz ))
// {
// return TST_CondRetParm ;
// } /* if */
//CondRetObtido = inserirLinha(*vtRefMatriz[inxMatriz]);
// return TST_CompararInt( CondRetEsperada , CondRetObtido ,
// "Retorno errado inserir à direita." );
// } /* fim ativa: Testar MAT Adicionar linha à matriz */
// /* Testar MAT Adicionar coluna à matriz */
// else if ( strcmp( ComandoTeste , INS_COL_CMD ) == 0 )
// {
// NumLidos = LER_LerParametros( "ii" ,
// &inxMatriz , &CondRetEsperada ) ;
// if ( ( NumLidos != 2 )
// || !VerificarInx( inxMatriz ))
// {
// return TST_CondRetParm ;
// } /* if */
//CondRetObtido = inserirColuna(*vtRefMatriz[inxMatriz]);
// return TST_CompararInt( CondRetEsperada , CondRetObtido ,
// "Retorno errado ao inserir à esquerda." );
// } /* fim ativa: Testar MAT Adicionar coluna à matriz */
/* Testar MAT Criar tabuleiro */
else if ( strcmp( ComandoTeste , CRIAR_TAB_CMD ) == 0 )
{
NumLidos = LER_LerParametros( "iiii" ,
&inxMatriz , &numLinha, &numColuna, &CondRetEsperada ) ;
if ( ( NumLidos != 4 )
|| !VerificarInx( inxMatriz ))
{
return TST_CondRetParm ;
} /* if */
CondRetObtido = criarTabuleiro(&(vtRefMatriz[inxMatriz]), numLinha, numColuna);
return TST_CompararInt( CondRetEsperada , CondRetObtido ,
"Retorno errado ao criar tabuleiro." );
} /* fim ativa: Testar MAT Criar tabuleiro */
/* Testar MAT Empilhar valor */
else if ( strcmp( ComandoTeste , EMP_VAL_CMD ) == 0 )
{
printf("Entrou no empilhar");
NumLidos = LER_LerParametros( "iiiii" ,
&inxMatriz , &valor, &numLinha, &numColuna, &CondRetEsperada ) ;
if ( ( NumLidos != 5 )
|| !VerificarInx( inxMatriz ))
{
return TST_CondRetParm ;
} /* if */
CondRetObtido =
empilharValor(vtRefMatriz[0], 1,
numLinha, numColuna ) ;
return TST_CompararInt( CondRetEsperada , CondRetObtido ,
"Retorno errado ao empilhar valor." );
} /* fim ativa: Testar MAT Empilhar valor */
/* Testar MAT Desempilhar valor */
else if ( strcmp( ComandoTeste , DESEMP_VAL_CMD ) == 0 )
{
NumLidos = LER_LerParametros( "iiii" ,
&inxMatriz , &numLinha, &numColuna, &CondRetEsperada ) ;
if ( ( NumLidos != 4 )
|| !VerificarInx( inxMatriz ))
{
return TST_CondRetParm ;
} /* if */
CondRetObtido = desempilharValor( vtRefMatriz[ inxMatriz ], numLinha, numColuna);
return TST_CompararInt( CondRetEsperada , CondRetObtido ,
"Retorno errado ao desempilhar valor." );
} /* fim ativa: Testar MAT Desempilhar valor */
/* Testar MAT Destruir matriz */
else if( strcmp( ComandoTeste, DESTRUIR_MAT_CMD) == 0)
{
NumLidos = LER_LerParametros( "ii" ,
&inxMatriz, &CondRetEsperada ) ;
if ( ( NumLidos != 2 )
|| !VerificarInx( inxMatriz ))
{
return TST_CondRetParm ;
} /* if */
CondRetObtido = destruirMatriz( vtRefMatriz[ inxMatriz ] );
return TST_CompararInt(CondRetEsperada, CondRetObtido,
"Retorno errado destruir matriz.");
}/* fim ativa: Testar MAT Destruir matriz */
return TST_CondRetNaoConhec ;
} /* Fim função: TMAT &Efetuar operações específicas */
TST_tpCondRet TST_EfetuarComando(char * ComandoTeste)
{
PDCRT_tpCondRet CondRetObtido = PDCRT_CondRetOK;
PDCRT_tpCondRet CondRetEsperada = PDCRT_CondRetCartaInexistente;
/* inicializa para qualquer coisa */
int numLidos = -1,
CondRetEsp = -1;
TST_tpCondRet CondRet;
char ValorDado[DIM_VALOR];
char NaipeDado;
char * pDado;
int estado = -1;
int situacao = -1;
/* Testar Criar Pilha*/
if (strcmp(ComandoTeste, CRIA_CMD) == 0)
{
numLidos = LER_LerParametros("i",
&CondRetEsp);
if (numLidos != 1)
{
return TST_CondRetParm;
} /* if */
PilhaTeste = PDCRT_CriaPilha();
if (PilhaTeste != NULL)
{
CondRetObtido = PDCRT_CondRetOK;
}
else
{
CondRetObtido = PDCRT_CondRetFaltouMemoria;
}
return TST_CompararInt(CondRetEsp, CondRetObtido,
"Condição de retorno errada ao criar Pilha!");
} /* fim ativa: Testar Criar Pilha */
/* Testar Destruir Pilha */
if (strcmp(ComandoTeste, DESTROI_CMD) == 0)
{
numLidos = LER_LerParametros("i",
&CondRetEsp);
if (numLidos != 1)
{
return TST_CondRetParm;
} /* if */
CondRetObtido = PDCRT_DestroiPilha(PilhaTeste);
return TST_CompararInt(CondRetEsp, CondRetObtido,
"Condição de retorno errada ao destruir pilha!");
} /* fim ativa: Testar Destruir Pilha */
/* Testar Push */
else if (strcmp(ComandoTeste, PUSH_CMD) == 0)
{
numLidos = LER_LerParametros("sciii",
ValorDado, &NaipeDado, &estado, &situacao, &CondRetEsp);
if (numLidos != 5)
{
return TST_CondRetParm;
} /* if */
pDado = (char *)malloc(strlen(ValorDado) + 1);
if (pDado == NULL)
{
return TST_CondRetMemoria;
} /* if */
strcpy(pDado, ValorDado);
CartaTeste = CTA_CriaCarta(pDado, NaipeDado, estado, situacao);
if (CartaTeste == NULL)
{
CondRetObtido = PDCRT_CondRetFaltouMemoria;
}
else if (PilhaTeste == NULL)
{
CondRetObtido = PDCRT_CondRetPilhaInexistente;
}
else
{
PDCRT_Push(PilhaTeste, CartaTeste);
CondRetObtido = PDCRT_CondRetOK;
} /* if */
free(pDado);
return TST_CompararInt(CondRetEsp, CondRetObtido,
"Condição de retorno errada ao adicionar carta.");
} /* fim ativa: Testar Push */
/* Testar Pop */
else if (strcmp(ComandoTeste, POP_CMD) == 0)
{
numLidos = LER_LerParametros("i",
&CondRetEsp);
if (numLidos != 1)
{
return TST_CondRetParm;
} /* if */
if (PDCRT_AcessaTopo(PilhaTeste) != NULL)
{
CartaTeste = PDCRT_Pop(PilhaTeste);
if (CartaTeste == NULL)
{
CondRetObtido = PDCRT_CondRetCartaInexistente;
}
else {
CondRetObtido = PDCRT_CondRetOK;
}
}
else{
CondRetObtido = PDCRT_CondRetPilhaVazia;
}
return TST_CompararInt(CondRetEsp, CondRetObtido,
"Condicao de retorno errada ao retirar carta!");
} /* fim ativa: Testar Pop */
#ifdef _DEBUG
/* Testar PDCRT Deturpa */
else if (strcmp(ComandoTeste, DETURPA_CMD) == 0)
{
numLidos = LER_LerParametros("ii", &AcaoDeturpadora, &CondRetEsperada);
if (numLidos != 2)
{
return TST_CondRetParm;
} /* if */
CondRetObtido = PDCRT_Deturpar(AcaoDeturpadora, PDCRT_AcessaCabeca(PilhaTeste));
return TST_CompararInt(CondRetEsperada, CondRetObtido,
"A contagem de erro não bate.");
} /* fim ativa: Testar PDCRT Deturpa */
/* Testar PDCRT Verifica */
else if (strcmp(ComandoTeste, VERIFICA_CMD) == 0)
{
int numErrosEsperados;
int numErrosOcorridos;
numLidos = LER_LerParametros("i", &numErrosEsperados);
if (numLidos != 1)
{
return TST_CondRetParm;
} /* if */
PDCRT_Verifica(&numErrosOcorridos, PilhaTeste, AcaoDeturpadora);
return TST_CompararInt(numErrosEsperados, numErrosOcorridos,
"Erro na contagem de falhas.");
} /* fim ativa: Testar PDCRT Verifica */
#endif
return TST_CondRetNaoConhec;
} /* Fim função: PDCRT &Testar Pilha de Cartas */
TST_tpCondRet TST_EfetuarComando( char * ComandoTeste )
{
TRF_tpCondRet CondRetObtido = TRF_CondRetOK ;
TRF_tpCondRet CondRetEsperada = TRF_CondRetFaltouMemoria ;
/* inicializa para qualquer coisa */
char ValorEsperado = '?' ;
char ValorObtido = '!' ;
char ValorDado = '\0' ;
int TarefaObtida = 11 ;
int TarefaObtidaAux = 12;
int idConsultado = -1;
int duracaoConsultada = -1;
int idRecursoObtido = -1;
int situacaoObtida = -1;
int duracaoObtida = -1;
char NomeObtido[STRING_DIM];
char DescricaoObtida[STRING_DIM];
char * NomeConsultado = (char*)malloc(sizeof(char)*STRING_DIM);
char * DescricaoConsultada = (char*)malloc(sizeof(char)*STRING_DIM);
int NumLidos = -1 ;
TST_tpCondRet Ret ;
/* Testar TRF Criar tarefa */
if ( strcmp( ComandoTeste , CRIAR_TRF_CMD ) == 0 )
{
NumLidos = LER_LerParametros( "issii" ,
&TarefaObtida, NomeObtido, DescricaoObtida, &duracaoObtida, &CondRetEsperada ) ;
if ( NumLidos != 5 )
{
return TST_CondRetParm ;
} /* if */
if ( TarefaObtida < 10 && TarefaObtida >= 0 )
{
CondRetObtido = TRF_CriarTarefa(&tarefas[TarefaObtida], NomeObtido, DescricaoObtida, duracaoObtida);
}
else
{
return TST_CompararInt(CondRetEsperada, TST_CondRetAcessoInvalidoVetor,
"Acesso Invalido ao vetor de tarefas.");
}
return TST_CompararInt( CondRetEsperada , CondRetObtido ,
"Retorno errado ao criar tarefa." );
} /* fim ativa: Testar TRF Criar tarefa */
/* Testar TRF Destruir tarefa */
else if ( strcmp( ComandoTeste , DESTRUIR_TRF_CMD ) == 0 )
{
NumLidos = LER_LerParametros( "i", &TarefaObtida ) ;
if ( NumLidos != 1 )
{
return TST_CondRetParm ;
} /* if */
if ( TarefaObtida < 10 && TarefaObtida >= 0 )
{
TRF_DestruirTarefa( &tarefas[TarefaObtida] ) ;
}
else
{
return TST_CompararInt(CondRetEsperada, TST_CondRetAcessoInvalidoVetor,
"Acesso Invalido ao vetor de tarefas.");
}
return TST_CondRetOK ;
} /* fim ativa: Testar TRF Destruir tarefa */
/* Testar TRF Conectar tarefas */
else if ( strcmp( ComandoTeste, CONECTAR_TRF_CMD ) == 0 )
{
NumLidos = LER_LerParametros( "iii", &TarefaObtida, &TarefaObtidaAux, &CondRetEsperada ) ;
if( NumLidos != 3 )
{
return TST_CondRetParm ;
} /* if */
if ( TarefaObtida < 10 && TarefaObtida >= 0 && TarefaObtida != TarefaObtidaAux &&
TarefaObtidaAux < 10 && TarefaObtidaAux >= 0)
{
CondRetObtido = TRF_ConectarTarefas(&tarefas[TarefaObtida], &tarefas[TarefaObtidaAux]);
}
else
{
return TST_CompararInt(CondRetEsperada, TST_CondRetAcessoInvalidoVetor,
"Acesso Invalido ao vetor de tarefas.");
}
return TST_CompararInt( CondRetEsperada , CondRetObtido ,
"Retorno errado ao conectar tarefas." );
} /* fim ativa: Testar TRF Conectar tarefas */
/* Testar TRF Alterar tarefa */
else if ( strcmp( ComandoTeste, ALTERAR_TRF_CMD ) == 0 )
{
NumLidos = LER_LerParametros( "issii" ,
&TarefaObtida, NomeObtido, DescricaoObtida, &duracaoObtida, &CondRetEsperada ) ;
if ( NumLidos != 5 )
{
return TST_CondRetParm ;
} /* if */
if ( TarefaObtida < 10 && TarefaObtida >= 0 )
{
CondRetObtido = TRF_AlterarTarefa(&tarefas[TarefaObtida], NomeObtido, DescricaoObtida, duracaoObtida);
}
else
{
return TST_CompararInt(CondRetEsperada, TST_CondRetAcessoInvalidoVetor,
"Acesso Invalido ao vetor de tarefas.");
}
return TST_CompararInt( CondRetEsperada , CondRetObtido ,
"Retorno errado ao alterar tarefa." );
} /* fim ativa: Testar TRF Alterar tarefas */
/* Testar TRF Consultar id da tarefa */
else if ( strcmp( ComandoTeste, CONSULTAR_ID_TRF_CMD ) == 0 )
{
NumLidos = LER_LerParametros( "ii" ,
&TarefaObtida, &CondRetEsperada ) ;
if ( NumLidos != 2 )
{
return TST_CondRetParm ;
} /* if */
if ( TarefaObtida < 10 && TarefaObtida >= 0 )
{
CondRetObtido = TRF_ConsultarIdTarefa(&tarefas[TarefaObtida], &idConsultado);
}
else
{
return TST_CompararInt(CondRetEsperada, TST_CondRetAcessoInvalidoVetor,
"Acesso Invalido ao vetor de tarefas.");
}
return TST_CompararInt( CondRetEsperada , CondRetObtido ,
"Retorno errado ao consultar id da tarefa." );
} /* fim ativa: Testar TRF Consultar id da tarefa */
/* Testar TRF Consultar nome de tarefa */
else if ( strcmp( ComandoTeste, CONSULTAR_NOME_TRF_CMD ) == 0 )
{
NumLidos = LER_LerParametros( "ii" ,
&TarefaObtida, &CondRetEsperada ) ;
if ( NumLidos != 2 )
{
return TST_CondRetParm ;
} /* if */
if ( TarefaObtida < 10 && TarefaObtida >= 0 )
{
CondRetObtido = TRF_ConsultarNomeTarefa(&tarefas[TarefaObtida], &NomeConsultado);
}
else
{
return TST_CompararInt(CondRetEsperada, TST_CondRetAcessoInvalidoVetor,
"Acesso Invalido ao vetor de tarefas.");
}
return TST_CompararInt( CondRetEsperada , CondRetObtido ,
"Retorno errado ao consultar nome da tarefa." );
} /* fim ativa: Testar TRF Consultar nome de tarefa */
/* Testar TRF Consultar descricao de tarefa */
else if ( strcmp( ComandoTeste, CONSULTAR_DESC_TRF_CMD ) == 0 )
{
NumLidos = LER_LerParametros( "ii" ,
&TarefaObtida, &CondRetEsperada ) ;
if ( NumLidos != 2 )
{
return TST_CondRetParm ;
} /* if */
if ( TarefaObtida < 10 && TarefaObtida >= 0 )
{
CondRetObtido = TRF_ConsultarDescricaoTarefa(&tarefas[TarefaObtida], &DescricaoConsultada);
}
else
{
return TST_CompararInt(CondRetEsperada, TST_CondRetAcessoInvalidoVetor,
"Acesso Invalido ao vetor de tarefas.");
}
return TST_CompararInt( CondRetEsperada , CondRetObtido ,
"Retorno errado ao consultar descricao da tarefa." );
} /* fim ativa: Testar TRF Consultar descricao de tarefa */
/* Testar TRF Consultar duracao da tarefa */
else if ( strcmp( ComandoTeste, CONSULTAR_DUR_TRF_CMD ) == 0 )
{
NumLidos = LER_LerParametros( "ii" ,
&TarefaObtida, &CondRetEsperada ) ;
if ( NumLidos != 2 )
{
return TST_CondRetParm ;
} /* if */
if ( TarefaObtida < 10 && TarefaObtida >= 0 )
{
CondRetObtido = TRF_ConsultarDuracaoTarefa(&tarefas[TarefaObtida], &duracaoConsultada);
}
else
{
return TST_CompararInt(CondRetEsperada, TST_CondRetAcessoInvalidoVetor,
"Acesso Invalido ao vetor de tarefas.");
}
return TST_CompararInt( CondRetEsperada , CondRetObtido ,
"Retorno errado ao consultar id da tarefa." );
} /* fim ativa: Testar TRF Consultar duracao da tarefa */
/* Testar TRF Cadastrar id do recurso da tarefa */
else if ( strcmp( ComandoTeste, CADASTRAR_ID_REC_TRF_CMD ) == 0 )
{
NumLidos = LER_LerParametros( "iii" ,
&TarefaObtida, &idRecursoObtido, &CondRetEsperada ) ;
if ( NumLidos != 3 )
{
return TST_CondRetParm ;
} /* if */
if ( TarefaObtida < 10 && TarefaObtida >= 0 )
{
CondRetObtido = TRF_CadastrarIdRecurso(&tarefas[TarefaObtida], idRecursoObtido);
}
else
{
return TST_CompararInt(CondRetEsperada, TST_CondRetAcessoInvalidoVetor,
"Acesso Invalido ao vetor de tarefas.");
}
return TST_CompararInt( CondRetEsperada , CondRetObtido ,
"Retorno errado ao cadastrar id do recurso da tarefa." );
} /* fim ativa: TRF Cadastrar id do recurso da tarefa */
/* Testar TRF Consultar id do recurso da tarefa */
else if ( strcmp( ComandoTeste, CONSULTAR_ID_REC_TRF_CMD ) == 0 )
{
NumLidos = LER_LerParametros( "ii" ,
&TarefaObtida, &CondRetEsperada ) ;
if ( NumLidos != 2 )
{
return TST_CondRetParm ;
} /* if */
if ( TarefaObtida < 10 && TarefaObtida >= 0 )
{
CondRetObtido = TRF_ConsultarIdRecurso(&tarefas[TarefaObtida], &idRecursoObtido);
}
else
{
return TST_CompararInt(CondRetEsperada, TST_CondRetAcessoInvalidoVetor,
"Acesso Invalido ao vetor de tarefas.");
}
return TST_CompararInt( CondRetEsperada , CondRetObtido ,
"Retorno errado ao consultar id do recurso da tarefa." );
} /* fim ativa: TRF Consultar id do recurso da tarefa */
/* Testar TRF Checa se a lista de predecessores está vazia */
else if ( strcmp( ComandoTeste, TEM_PREDECESSOR_TRF_CMD ) == 0 )
{
NumLidos = LER_LerParametros( "ii" ,
&TarefaObtida, &CondRetEsperada ) ;
if ( NumLidos != 2 )
{
return TST_CondRetParm ;
} /* if */
if ( TarefaObtida < 10 && TarefaObtida >= 0 )
{
CondRetObtido = TRF_TemPredecessores(tarefas[TarefaObtida], &situacaoObtida);
}
else
{
return TST_CompararInt(CondRetEsperada, TST_CondRetAcessoInvalidoVetor,
"Acesso Invalido ao vetor de tarefas.");
}
return TST_CompararInt( CondRetEsperada , CondRetObtido ,
"Retorno errado ao consultar se a tarefa possui predecessores." );
} /* fim ativa: TRF Checa se a lista de predecessores está vazia */
/* Testar TRF Checa se a lista de sucessores está vazia */
else if ( strcmp( ComandoTeste, TEM_SUCESSOR_TRF_CMD ) == 0 )
{
NumLidos = LER_LerParametros( "ii" ,
&TarefaObtida, &CondRetEsperada ) ;
if ( NumLidos != 2 )
{
return TST_CondRetParm ;
} /* if */
if ( TarefaObtida < 10 && TarefaObtida >= 0 )
{
CondRetObtido = TRF_TemSucessores(tarefas[TarefaObtida], &situacaoObtida);
}
else
{
return TST_CompararInt(CondRetEsperada, TST_CondRetAcessoInvalidoVetor,
"Acesso Invalido ao vetor de tarefas.");
}
return TST_CompararInt( CondRetEsperada , CondRetObtido ,
"Retorno errado ao consultar se a tarefa possui sucessores." );
} /* fim ativa: TRF Checa se a lista de sucessores está vazia */
/* Testar TRF Calcula Caminho Crítico */
else if ( strcmp( ComandoTeste, CAMINHO_CRITICO_TRF_CMD ) == 0 )
{
NumLidos = LER_LerParametros( "ii" ,
&TarefaObtida, &CondRetEsperada ) ;
if ( NumLidos != 2 )
{
return TST_CondRetParm ;
} /* if */
if ( TarefaObtida < 10 && TarefaObtida >= 0 )
{
CondRetObtido = TRF_CalculaCaminhoCritico(tarefas[TarefaObtida]);
}
else
{
return TST_CompararInt(CondRetEsperada, TST_CondRetAcessoInvalidoVetor,
"Acesso Invalido ao vetor de tarefas.");
}
return TST_CompararInt( CondRetEsperada , CondRetObtido ,
"Retorno errado ao calcular o caminho critico." );
} /* fim ativa: TRF Calcula Caminho Crítico */
return TST_CondRetNaoConhec ;
} /* Fim função: TTRF Efetuar operações de teste específicas para tarefa */
TST_tpCondRet TST_EfetuarComando( char * ComandoTeste )
{
int NumLidos = -1 ;
int IntEsperado,
IntObtido ;
char CharEsperado,
CharObtido ;
long LongEsperado,
LongObtido ;
double FloatEsperado ,
FloatObtido ,
Tolerancia ;
char StringEsperado[ 250 ] ,
StringObtido[ 250 ] ;
char EspacEsperado[ 100 ] ;
char EspacObtido[ 100 ] ;
/* Testar Booleano */
if ( strcmp( ComandoTeste , BOOL_CMD ) == 0 )
{
NumLidos = LER_LerParametros( "ii" ,
&IntEsperado , &IntObtido ) ;
if ( NumLidos != 2 )
{
return TST_CondRetParm ;
} /* if */
return TST_CompararBool( IntEsperado , IntObtido ,
"Booleanos não são iguais." ) ;
} /* fim ativa: Testar Booleano */
/* Testar caractere */
else if ( strcmp( ComandoTeste , CHAR_CMD ) == 0 )
{
NumLidos = LER_LerParametros( "cc" ,
&CharEsperado , &CharObtido ) ;
if ( NumLidos != 2 )
{
return TST_CondRetParm ;
} /* if */
return TST_CompararChar( CharEsperado , CharObtido ,
"Caracteres não são iguais." ) ;
} /* fim ativa: Testar caractere */
/* Testar inteiro normal */
else if ( strcmp( ComandoTeste , INT_CMD ) == 0 )
{
NumLidos = LER_LerParametros( "ii" ,
&IntEsperado , &IntObtido ) ;
if ( NumLidos != 2 )
{
return TST_CondRetParm ;
} /* if */
return TST_CompararInt( IntEsperado , IntObtido ,
"Inteiros não são iguais." ) ;
} /* fim ativa: Testar inteiro normal */
/* Testar inteiro longo */
else if ( strcmp( ComandoTeste , LONG_CMD ) == 0 )
{
NumLidos = LER_LerParametros( "ii" ,
&LongEsperado , &LongObtido ) ;
if ( NumLidos != 2 )
{
return TST_CondRetParm ;
} /* if */
return TST_CompararInt( LongEsperado , LongObtido ,
"Inteiros longos não são iguais." ) ;
} /* fim ativa: Testar inteiro longo */
/* Testar flutuante */
else if ( strcmp( ComandoTeste , FLOAT_CMD ) == 0 )
{
NumLidos = LER_LerParametros( "fff" ,
&FloatEsperado , &FloatObtido , &Tolerancia ) ;
if ( NumLidos != 3 )
{
return TST_CondRetParm ;
} /* if */
return TST_CompararFloat( FloatEsperado , FloatObtido , Tolerancia ,
"Flutuantes fora da tolerância." ) ;
} /* fim ativa: Testar flutuante */
/* Testar string */
else if ( strcmp( ComandoTeste , STRING_CMD ) == 0 )
{
NumLidos = LER_LerParametros( "ss" ,
StringEsperado , StringObtido ) ;
if ( NumLidos != 2 )
{
return TST_CondRetParm ;
} /* if */
return TST_CompararString( StringEsperado , StringObtido ,
"Strings não são iguais." ) ;
} /* fim ativa: Testar string */
/* Testar acesso a espaços */
else if ( strcmp( ComandoTeste , ESPAC_CMD ) == 0 )
{
NumLidos = LER_LerParametros( "ss" ,
EspacEsperado , EspacObtido ) ;
if ( NumLidos != 2 )
{
return TST_CondRetParm ;
} /* if */
if ( EspacEsperado[ 0 ] == '.' ) /* gera string vazio */
{
EspacEsperado[ 0 ] = 0 ;
} /* if */
if ( EspacObtido[ 0 ] == '.' ) /* gera string com algum lixo */
{
memcpy( EspacObtido , &NumLidos , 20 ) ; /* força espaco errado contendo resíduo da pilha */
} /* if */
return TST_CompararEspaco( EspacEsperado , EspacObtido ,
strlen( EspacEsperado ) ,
"Espaços não são iguais." ) ;
} /* fim ativa: Testar acesso a espaços */
return TST_CondRetNaoConhec ;
} /* Fim função: TGEN &Testar módulo TesteGen */
TST_tpCondRet TST_EfetuarComando( char * ComandoTeste )
{
GRA_tpCondRet CondRetObtido = GRA_CondRetOK ;
GRA_tpCondRet CondRetEsperada = GRA_CondRetFaltouMemoria ;
char ValorDado = '\0' ;
char ValorOrig = '\0' ;
char ValorDest = '\0' ;
char StringDado[DIM_VALOR];
int inxGrafo = -1 ,
NumLidos = -1 ,
i = 0 ;
#ifdef _DEBUG
int indDeturpa = 0;
#endif
/* Testar GRA Criar grafo */
if ( strcmp( ComandoTeste , CRIAR_GRAFO_CMD ) == 0 )
{
NumLidos = LER_LerParametros( "ii" ,
&inxGrafo , &CondRetEsperada ) ;
if ( (NumLidos != 2) || ( ! ValidarInxGrafo(inxGrafo, VAZIO) ) )
{
return TST_CondRetParm ;
} /* if */
vtGrafo[ inxGrafo ] = NULL;
CondRetObtido = GRA_CriarGrafo( &vtGrafo[ inxGrafo ] , TES_excluirInfo );
return TST_CompararInt( CondRetEsperada , CondRetObtido ,
"Retorno errado ao criar grafo." );
} /* fim ativa: Testar GRA Criar grafo */
/* Testar GRA Criar vertice para grafo */
else if( strcmp( ComandoTeste , CRIAR_VERTICE_GRAFO_CMD ) == 0 )
{
NumLidos = LER_LerParametros ( "isci" , &inxGrafo , &StringDado , &ValorDado , &CondRetEsperada );
if ( NumLidos != 4 )
{
return TST_CondRetParm ;
} /* if */
CondRetObtido = GRA_CriaVerticeGrafo( vtGrafo[ inxGrafo ] , StringDado , ValorDado , TES_excluirInfo );
return TST_CompararInt( CondRetEsperada , CondRetObtido ,
"Retorno errado ao criar vertice no grafo." );
} /* fim ativa: Testar GRA Criar vertice para grafo */
/* Testar GRA Inserir aresta */
else if(strcmp ( ComandoTeste, CRIA_ARESTA_CMD ) == 0)
{
NumLidos = LER_LerParametros ( "ccisi" , &ValorOrig, &ValorDest , &inxGrafo, &StringDado , &CondRetEsperada );
if(NumLidos != 5){
return TST_CondRetParm;
}
CondRetObtido = GRA_CriarAresta( ValorOrig , ValorDest , vtGrafo[ inxGrafo ] , StringDado );
return TST_CompararInt( CondRetEsperada , CondRetObtido ,
"Retorno errado ao criar aresta." );
} /* fim ativa: Testar GRA Inserir aresta */
/* Testar GRA Excluir vértice */
else if (strcmp (ComandoTeste, EXCLUIR_VERT_CMD) == 0)
{
NumLidos = LER_LerParametros ( "ii" , &inxGrafo , &CondRetEsperada );
if(NumLidos != 2){
return TST_CondRetParm;
}
CondRetObtido = GRA_ExcluirVerticeCorrente( vtGrafo[ inxGrafo ] );
return TST_CompararInt( CondRetEsperada , CondRetObtido ,
"Retorno errado ao excluir vértice." );
} /* fim ativa: Testar GRA Excluir vértice */
/* Testar GRA Obter valor do vértice corrente */
else if(strcmp (ComandoTeste, OBTER_VALOR_VERT_CMD) == 0)
{
NumLidos = LER_LerParametros ( "isi" , &inxGrafo , &StringDado , &CondRetEsperada );
if(NumLidos != 3){
return TST_CondRetParm;
}
CondRetObtido = GRA_ChecarNomeVerticeCorrente( vtGrafo[inxGrafo] , StringDado );
return TST_CompararInt( CondRetEsperada , CondRetObtido ,
"Retorno errado ao obter valor do vértice corrente." );
} /* fim ativa: Testar GRA Obter valor do vértice corrente */
/* Testar GRA Inserir vértice no início da lista de origens */
else if(strcmp (ComandoTeste, INSERE_VERT_ORIG_CMD ) == 0)
{
NumLidos = LER_LerParametros ( "ici" , &inxGrafo , &ValorDado , &CondRetEsperada );
if(NumLidos != 3){
return TST_CondRetParm;
}
CondRetObtido = GRA_InsereOrigem(vtGrafo[ inxGrafo ] , ValorDado);
return TST_CompararInt( CondRetEsperada , CondRetObtido ,
"Retorno errado ao inserir vertice na lista de origens" );
} /* fim ativa: Testar GRA Inserir vértice no início da lista de origens */
/* Testar GRA Inserir vértice no início da lista de origens */
else if(strcmp (ComandoTeste, EXCLUIR_ARES_CMD ) == 0)
{
NumLidos = LER_LerParametros ( "ccii" , &ValorDado , &ValorDest , &inxGrafo , &CondRetEsperada );
if(NumLidos != 4){
return TST_CondRetParm;
}
CondRetObtido = GRA_ExcluirAresta( ValorDado , ValorDest , vtGrafo[ inxGrafo ]);
return TST_CompararInt( CondRetEsperada , CondRetObtido ,
"Retorno errado ao excluir aresta" );
} /* fim ativa: Testar GRA Inserir vértice no início da lista de origens */
/* Testar GRA Definir corrente */
else if(strcmp (ComandoTeste, DEFINIR_CORR_GRA_CMD ) == 0)
{
NumLidos = LER_LerParametros ( "ici" , &inxGrafo , &ValorDado , &CondRetEsperada );
if(NumLidos != 3){
return TST_CondRetParm;
}
CondRetObtido = GRA_DefinirCorrente( vtGrafo[ inxGrafo ] , ValorDado);
return TST_CompararInt( CondRetEsperada , CondRetObtido ,
"Retorno errado ao definir corrente" );
} /* fim ativa: Testar GRA Inserir vértice no início da lista de origens */
/* Testar GRA Destruir Grafo */
else if(strcmp (ComandoTeste, DESTRUIR_GRA_CMD ) == 0)
{
NumLidos = LER_LerParametros ( "ii" , &inxGrafo , &CondRetEsperada );
if(NumLidos != 2){
return TST_CondRetParm;
}
CondRetObtido = GRA_DestruirGrafo( vtGrafo[ inxGrafo ]);
vtGrafo[ inxGrafo ] = NULL;
return TST_CompararInt( CondRetEsperada , CondRetObtido ,
"Retorno errado ao destruir grafo!" );
} /* fim ativa: Testar GRA Destruir Grafo */
/* Testar VerificarMemoria */
#ifdef _DEBUG
else if ( strcmp( ComandoTeste , VER_MEMO_GRA_CMD ) == 0 )
{
CED_ExibirTodosEspacos( CED_ExibirTodos ) ;
return TST_CondRetOK ;
} /* fim ativa: VerificarMemoria */
#endif
/* Verificacao do Grafo */
#ifdef _DEBUG
else if ( strcmp( ComandoTeste , VERIFICAR_GRA_CMD ) == 0 )
{
NumLidos = LER_LerParametros( "ii" , &inxGrafo , &CondRetEsperada ) ;
if ( ( NumLidos != 2 ) || ( inxGrafo < 0 ) || ( inxGrafo >= DIM_VT_GRAFO ))
{
return TST_CondRetParm ;
} /* if */
CondRetObtido = GRA_VerificarGrafo( vtGrafo[ inxGrafo ] );
return TST_CompararInt( CondRetEsperada , CondRetObtido ,
"Retorno errado ao verificar grafo" );
} /* fim ativa: Verificacao do Grafo */
#endif
/* Testar Deturpar */
#ifdef _DEBUG
else if ( strcmp( ComandoTeste , DETURPAR_GRA_CMD ) == 0 )
{
NumLidos = LER_LerParametros( "iii" , &inxGrafo, &indDeturpa , &CondRetEsperada ) ;
if ( ( NumLidos != 3 )
|| ( inxGrafo < 0 ) || ( inxGrafo >= DIM_VT_GRAFO ))
{
return TST_CondRetParm ;
} /* if */
CondRetObtido = GRA_DeturparGrafo ( vtGrafo[ inxGrafo ], (GRA_tpTiposDeturpacao)indDeturpa ) ;
return TST_CompararInt( CondRetEsperada , CondRetObtido ,
"Retorno errado ao verificar grafo" );
} /* fim ativa: Deturpar */
#endif
return TST_CondRetNaoConhec ;
} /* Fim função: TGRA Efetuar operações de teste específicas para grafo */
TST_tpCondRet TST_EfetuarComando(char *ComandoTeste)
{
JUD_tpCondRet CondRetObtido = JUD_CondRetOK ;
JUD_tpCondRet CondRetEsperada = JUD_CondRetFaltouMemoria ;
/* inicializa para qualquer coisa */
int IndiceValorEsperado = -1;
int IndiceValorObtido = -1;
int IndiceValorDado = -1;
int NumLidos = -1;
TST_tpCondRet Ret;
if (pPartida == NULL)
{
PAR_CriarPartida(&pPartida);
}
/* Testar PAR Eh checkmate*/
if (strcmp( ComandoTeste, EH_CHECKMATE_CMD) == 0 )
{
int respostaEsperada, respostaObtida;
TST_tpCondRet condRet;
NumLidos = LER_LerParametros("ii", &respostaEsperada, &CondRetEsperada) ;
if (NumLidos != 2)
{
return TST_CondRetParm ;
}
CondRetObtido = JUD_EhCheckmate(pPartida, &respostaObtida);
condRet = TST_CompararInt(CondRetEsperada, CondRetObtido,
"Não foi possível verificar se eh checkmate.");
if (condRet != TST_CondRetOK)
{
return condRet;
}
return TST_CompararInt(respostaEsperada, respostaObtida,
"Foi obtida uma resposta diferente da esperada para a verificação de checkmate");
}
/* Testar PAR Criar peca*/
else if ( strcmp( ComandoTeste , CRIAR_PECA_CMD ) == 0 )
{
char *nome, *passosStr;
int iTipoMovimento;
MPEC_tpTipoMovimento tipo;
LIS_tppLista pPassos;
MEM_Alloc(sizeof(char)*MAX_NOME_PECA, (void**) &nome);
MEM_Alloc(sizeof(char)*MAX_PASSOS_STR, (void**) &passosStr);
NumLidos = LER_LerParametros("ssii", nome, passosStr, &iTipoMovimento, &CondRetEsperada) ;
if (NumLidos != 4)
{
return TST_CondRetParm ;
}
ISP_LerPassos(passosStr, &pPassos);
tipo = (MPEC_tpTipoMovimento) iTipoMovimento;
CondRetObtido = PAR_CriarPeca(pPartida, nome, pPassos, tipo);
return TST_CompararInt(CondRetEsperada, CondRetObtido,
"Não foi possível criar a casa.");
}
/* Testar PAR Inserir peca*/
else if (strcmp( ComandoTeste, INSERIR_PECA_CMD) == 0 )
{
char *nomeCasa, *nomeModelo;
int iTime;
PEC_tpTimePeca time;
LIS_tppLista pPassos;
MEM_Alloc(sizeof(char)*MAX_NOME_PECA, (void**) &nomeModelo);
MEM_Alloc(sizeof(char)*MAX_NOME_PECA, (void**) &nomeCasa);
NumLidos = LER_LerParametros("ssii", nomeCasa, nomeModelo, &iTime, &CondRetEsperada) ;
if (NumLidos != 4)
{
return TST_CondRetParm ;
}
time = (PEC_tpTimePeca) iTime;
PAR_IrCasa(pPartida, nomeCasa);
CondRetObtido = PAR_InserirPeca(pPartida, nomeModelo, time);
return TST_CompararInt(CondRetEsperada, CondRetObtido,
"Não foi possível inserir a peça.");
}
/* Testar PAR Remover peca*/
else if (strcmp( ComandoTeste, REMOVER_PECA_CMD) == 0 )
{
char *nomeCasa;
MEM_Alloc(sizeof(char)*MAX_NOME_PECA, &nomeCasa);
NumLidos = LER_LerParametros("si", nomeCasa, &CondRetEsperada) ;
if (NumLidos != 2)
{
return TST_CondRetParm ;
}
PAR_IrCasa(pPartida, nomeCasa);
CondRetObtido = PAR_RemoverPeca(pPartida);
return TST_CompararInt(CondRetEsperada, CondRetObtido,
"Não foi possível remover a peça.");
}
/* Testar PAR Remover rei*/
else if (strcmp( ComandoTeste, REMOVER_REI_CMD) == 0 )
{
NumLidos = LER_LerParametros("i", &CondRetEsperada) ;
if (NumLidos != 1)
{
return TST_CondRetParm ;
}
CondRetObtido = PAR_RemoverRei(pPartida);
return TST_CompararInt(CondRetEsperada, CondRetObtido,
"Não foi possível remover o rei.");
}
/* Testar PAR Inserir rei */
else if (strcmp( ComandoTeste, INSERIR_REI_CMD) == 0 )
{
char *nomeCasa;
MEM_Alloc(sizeof(char)*MAX_NOME_PECA, (void **) &nomeCasa);
NumLidos = LER_LerParametros("si", nomeCasa, &CondRetEsperada) ;
if (NumLidos != 2)
{
return TST_CondRetParm ;
}
PAR_IrCasa(pPartida, nomeCasa);
CondRetObtido = PAR_InserirRei(pPartida);
return TST_CompararInt(CondRetEsperada, CondRetObtido,
"Não foi possível inserir o rei.");
}
/* Testar Finalizar teste */
else if ( strcmp( ComandoTeste , FIM_CMD ) == 0 )
{
MEM_LiberarTodaMemoriaAlocada();
return TST_CondRetOK;
}
return TST_CondRetNaoConhec ;
} /* Fim função: TPAR Efetuar operações de teste específicas para matriz */
