void TST_Assert( int Expressao , int Linha , char * NomeArq )
{
char Msg[ DIM_MSG ] ;
if ( Expressao )
{
return ;
} /* if */
sprintf( Msg , "Assertiva falhou: linha %d arquivo: %s" ,
Linha , NomeArq ) ;
TST_ExibirPrefixo( "\n " , "************************************\n" ) ;
TST_NotificarFalha( Msg ) ;
TST_ExibirPrefixo( "\n " , "Assertiva Assertiva Assertiva\n" ) ;
if ( pArqLog != stdout )
{
fclose( pArqLog ) ;
pArqLog = stdout ;
TST_ExibirPrefixo( "\n " , "************************************\n" ) ;
TST_NotificarFalha( Msg ) ;
TST_ExibirPrefixo( "\n " , "Assertiva Assertiva Assertiva\n" ) ;
} /* if */
exit( 4 ) ;
} /* Fim função: TSTG &Assertiva controlada */
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 LER_InterpretarComandos( char * ComandoTeste )
{
char Parm[ LER_DIM_NOME ] ;
int tamParm ;
#ifdef _DEBUG
TST_ASSERT( Inicializado ) ;
#endif
/* Tratar declaração de nome */
if ( strcmp( ComandoTeste , DECLARAR_SIMBOLO_CMD ) == 0 )
{
if ( ! LER_DeclararParametro( ))
{
return TST_NotificarFalha( "Não declarou o parâmetro." ) ;
} /* if */
return TST_CondRetOK ;
} /* fim ativa: Tratar declaração de nome */
/* Tratar exibição de uma declaração */
else if ( strcmp( ComandoTeste , EXIBIR_SIMBOLO_CMD ) == 0 )
{
LER_PularComando( ) ;
if ( ! LER_LerParmNome( Parm , &tamParm , LER_DIM_NOME ))
{
return TST_CondRetParm ;
} /* if */
LER_ExibirParametro( Parm ) ;
return TST_CondRetOK ;
} /* fim ativa: Tratar exibição de uma declaração */
/* Tratar comando não é para LER */
return TST_CondRetNaoExecutou ;
} /* Fim função: LER &Interpretar comandos de teste */
TST_tpCondRet TBS_ValidarTabela( TBS_tppTabela pTabela )
{
unsigned inxHash ;
tpLista * pElem ;
#ifdef _DEBUG
TST_ASSERT( pTabela != NULL ) ;
#endif
/* Validar existência de dados da cabeça */
if ( pTabela->tamVtHash <= 1 )
{
return TST_NotificarFalha( "Tamanho incorreto do vetor de randomização." ) ;
} /* if */
if ( pTabela->pVtHash == NULL )
{
return TST_NotificarFalha( "Falta vetor de randomização." ) ;
} /* if */
if ( pTabela->ObterSimbolo == NULL )
{
return TST_NotificarFalha( "Falta função obter simbolo." ) ;
} /* if */
/* Validar listas de colisão */
for ( inxHash = 0 ; inxHash < pTabela->tamVtHash ; inxHash ++ ) {
/* Validar toda a lista de colisão */
pElem = pTabela->pVtHash[ inxHash ] ;
while ( pElem != NULL ) {
/* Validar elemento da lista de colisão */
if ( pElem->pDado == NULL )
{
return TST_NotificarFalha( "Faltou dado em elemento de lista." ) ;
} /* if */
if ( Hash( pTabela->ObterSimbolo( pElem->pDado ) ,
pTabela->tamVtHash ) != inxHash )
{
return TST_NotificarFalha( "Índice has de elemento está incorreto." ) ;
} /* if */
if ( pElem->pAnt != NULL )
{
if ( pElem->pAnt->pProx != pElem )
{
return TST_NotificarFalha( "Erro de encadeamento à esquerda em elemento de lista." ) ;
} /* if */
} else
{
if ( pElem != pTabela->pVtHash[ inxHash ] )
{
return TST_NotificarFalha( "Erro de encadeamento origem em elemento de lista." ) ;
} /* if */
} /* if */
if ( pElem->pProx != NULL )
{
if ( pElem->pProx->pAnt != pElem )
{
return TST_NotificarFalha( "Erro de encadeamento à direita em elemento de lista." ) ;
} /* if */
} /* if */
pElem = pElem->pProx ;
} /* fim repete: Validar toda a lista de colisão */
} /* fim repete: Validar listas de colisão */
return TST_CondRetOK ;
} /* Fim função: TBS &Validar tabela de símbolos */
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 */
// Só n é possível testar a deturpa 1 e 8
void verificaLista (LIS_tppLista pLista, int* qtd)
{
int i, num, cont = 0, tamObtido, tipoObtido;
void* valorCorr, *valorAux;
char* c;
LIS_tppLista listaAux;
int qtdFalhas = 0, f;
struct tagElemLista *elemAux;
*qtd = 0;
CED_MarcarTodosEspacosInativos(); // passo para verificar vazamento de memoria
CED_MarcarEspacoAtivo(lixo);
elemAux = pLista->pElemCorr;
if(elemAux == NULL)// o corrente foi deturpado para nulo (deturpa 9)
{
CNT_CONTAR( "ElemCorrNulo" ) ;
// entao foi o deturpa 9
TST_NotificarFalha("O ponteiro para o elemento corrente é NULL");
qtdFalhas++;
}
else
{
CNT_CONTAR( "NaoElemCorrNulo") ;
// entao elemAux != NULL
valorCorr = pLista->pElemCorr->pValor;
if(valorCorr == NULL)
{
CNT_CONTAR( "ElemCorrValorNulo" ) ;
TST_NotificarFalha("Ponteiro para o conteudo do no eh NULL");
qtdFalhas++;
}
else
{
CNT_CONTAR( "NaoElemCorrValorNulo" ) ;
elemAux = pLista->pElemCorr;
tamObtido = PercorreLista(pLista);
if(tamObtido != pLista->numElem)
{
CNT_CONTAR( "TamanhoLista" ) ;
TST_NotificarFalha("Ponteiro para o corrente foi liberado");
qtdFalhas++;
}
else
{
CNT_CONTAR( "NaoTamanhoLista" ) ;
pLista->pElemCorr = elemAux;
verificaElemento(elemAux, &f);
elemAux = pLista->pElemCorr->pProx;
// verifica a intergridade do elemento
qtdFalhas+=f;
if(elemAux == NULL)// entao proximo do corrente foi deturpado
{
CNT_CONTAR( "ElemCorrPproxNulo" ) ;
TST_NotificarFalha("Ponteiro para o proximo do corrente eh NULL");
qtdFalhas++;
}
else
{
CNT_CONTAR( "NaoElemCorrPproxNulo" ) ;
elemAux = pLista->pElemCorr->pAnt;
if(elemAux == NULL) // entao o anterior do corrente foi deturpado
{
CNT_CONTAR( "ElemCorrPantNulo" ) ;
TST_NotificarFalha("Ponteiro para o anterior do corrente eh NULL");
qtdFalhas++;
}
else
{
CNT_CONTAR( "NaoElemCorrPantNulo" ) ;
// agora vale checar se o prox ou o anterior sao lixo
elemAux = pLista->pElemCorr->pProx;
if(elemAux->pValor == NULL) // proximo é lixo
{
CNT_CONTAR( "ElemCorrPproxPvalorNulo" ) ;
TST_NotificarFalha("Ponteiro para o proximo do corrente eh lixo");
qtdFalhas++;
}
else
{
CNT_CONTAR( "NaoElemCorrPproxPvalorNulo" ) ;
elemAux = pLista->pElemCorr->pAnt;
if(elemAux->pValor == NULL)// anterior é lixo
{
CNT_CONTAR( "ElemCorrPantPvalorNulo" ) ;
TST_NotificarFalha("Ponteiro para o anterior do corrente eh lixo");
qtdFalhas++;
}
else
{
CNT_CONTAR( "NaoElemCorrPantPvalorNulo" ) ;
if(pLista->pOrigemLista == NULL)
{
CNT_CONTAR( "OrigemListaNulo" ) ;
TST_NotificarFalha("Ponteiro para a origem da lista é NULL");
qtdFalhas++;
}
else
{
CNT_CONTAR( "NaoOrigemListaNulo" ) ;
tipoObtido = CED_ObterTipoEspaco( pLista->pElemCorr );
if(tipoObtido != LIS_TipoElemento)
{
CNT_CONTAR( "TipoDaLista" ) ;
TST_NotificarFalha("Tipo de espaco deturpado, nao eh elemento");
qtdFalhas++;
}
else
{
CNT_CONTAR( "NaoTipoDaLista" ) ;
tipoObtido = CED_ObterTipoEspaco(pLista);
if(tipoObtido != LIS_TipoCabeca)
{
CNT_CONTAR( "TipoCabeca" ) ;
TST_NotificarFalha("Houve vazamento de memoria");
qtdFalhas++;
}
else
{
CNT_CONTAR( "NaoTipoCabeca" ) ;
qtdFalhas += VerificaVazamentoMem(pLista);
if(qtdFalhas > 0)
{
CNT_CONTAR( "VazamentoDaLista" ) ;
TST_NotificarFalha("Houve vazamento de memoria");
}
else
CNT_CONTAR( "NaoVazamentoDaLista" ) ;
}
}
}
}
}
}
}
}
}
}
*qtd = qtdFalhas;
}
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)
{
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;
}
TAB_tpCondRet TAB_VerificarTabuleiro(Tabuleiro* tabuleiro)
{
int condRet, linha, coluna;
Peca*peca;
LIS_tppLista lista;
if(!tabuleiro) {
CNT_CONTAR("Tabuleiro Inexistente");
TST_NotificarFalha("Tentou verificar tabuleiro inexistente.");
return TAB_CondRetErroEstrutura;
}
else
CNT_CONTAR("Tabuleiro Existente");
if(!CED_VerificarEspaco(tabuleiro, NULL)) {
CNT_CONTAR("Tabuleiro possui alguma falha");
TST_NotificarFalha("Controle do espaço acusou erro.");
return TAB_CondRetErroEstrutura ;
}
else
CNT_CONTAR("Tabuleiro nao possui falha");
if(TST_CompararInt(TAB_Tabuleiro, CED_ObterTipoEspaco(tabuleiro),
"Tipo do espaço de dados nao e tabuleiro.") != TST_CondRetOK) {
CNT_CONTAR("Tipo nao e Tabuleiro");
return TAB_CondRetErroEstrutura;
}
else
CNT_CONTAR("Tipo e Tabuleiro");
CED_MarcarEspacoAtivo(tabuleiro);
CNT_CONTAR("Tipo Tabuleiro OK");
/*Verificar a lista das listas, primária*/
if(LIS_VerificarLista(tabuleiro->lista) == LIS_CondRetErroEstrutura)
{
CNT_CONTAR("Lista de listas com erro");
return TAB_CondRetErroEstrutura;
}
/*Verificar Cada elemento da lista, ou seja, cada linha*/
LIS_IrInicioLista(tabuleiro->lista);
for(linha = 0; linha < TabuleiroAltura; ++linha) {
lista = LIS_ObterValor(tabuleiro->lista);
condRet = LIS_VerificarLista(lista);
if(condRet == LIS_CondRetErroEstrutura) {
CNT_CONTAR("Uma das listas de pecas possui algum problema");
return TAB_CondRetErroEstrutura;
}
/*Verificar Cada elemento da lista secundária, ou seja, cada casa do tabuleiro*/
LIS_IrInicioLista(lista);
for(coluna = 0; coluna < TabuleiroLargura; ++coluna) {
peca = LIS_ObterValor(lista);
if(peca) {
CNT_CONTAR("Casa nao Vazia");
if(TST_CompararInt(PEC_Peca, CED_ObterTipoEspaco(peca), "Tipo do espaço de dados nao e peca.") != TST_CondRetOK) {
TST_NotificarFalha("Tipo numa casa do tabuleiro nao e peca");
CNT_CONTAR("Tipo nao e peca");
return TAB_CondRetErroEstrutura;
}
else
{
CNT_CONTAR("Tipo e peca");
CED_MarcarEspacoAtivo(peca);
}
}
else
CNT_CONTAR("Casa Vazia");
LIS_AvancarElementoCorrente(lista, 1);
}
if(LIS_IrIndice(lista, 7) == LIS_CondRetOK && LIS_IrIndice(lista, 8) == LIS_CondRetFimLista)
CNT_CONTAR("Tabuleiro com 8 colunas");
else {
CNT_CONTAR("Tabuleiro nao tem 8 colunas");
TST_NotificarFalha("Tabuleiro nao tem 8 colunas");
return TAB_CondRetErroEstrutura;
}
LIS_AvancarElementoCorrente(tabuleiro->lista, 1);
}
if(LIS_IrIndice(tabuleiro->lista, 7) == LIS_CondRetOK && LIS_IrIndice(tabuleiro->lista, 8) == LIS_CondRetFimLista)
CNT_CONTAR("Tabuleiro com 8 linhas");
else {
CNT_CONTAR("Tabuleiro nao tem 8 linhas");
TST_NotificarFalha("Tabuleiro nao tem 8 linhas");
return TAB_CondRetErroEstrutura;
}
CNT_CONTAR("Ha uma lista de listas e a sublista de pecas sem problemas");
return TAB_CondRetOK;
}
TST_tpCondRet TST_EfetuarComando( char * ComandoTeste )
{
int i ;
int numLidos = -1 ;
int inxEspaco = -1 ;
int valEsperado = -1 ;
int valObtido = -1 ;
#define DIM_STRING_PARM 100
char StringParm[ DIM_STRING_PARM ] ;
int Deslocamento ;
int Valor ;
int Tamanho ;
int numLinhaFonte ;
int idTipo ;
int numAllocs = -1 ,
Frequencia = 0 ,
ContaNULL = 0 ;
double Tolerancia ,
PercentEsperado ,
PercentObtido ;
void * pEspaco = NULL ;
InstrumentarString( StringParm , DIM_STRING_PARM ) ;
/* Tratar: Reinicializar módulo de teste espeçifico */
if ( strcmp( ComandoTeste , ResetEspacosCmd ) == 0 )
{
if ( EhPrimeiraVez )
{
EhPrimeiraVez = FALSE ;
for( i = 0 ; i < DIM_VT_ESPACO ; i ++ )
{
vtEspaco[ i ] = NULL ;
} /* for */
return TST_CondRetOK ;
} /* if */
for( i = 0 ; i < DIM_VT_ESPACO ; i++ )
{
if ( vtEspaco[ i ] != NULL )
{
CED_Free( vtEspaco[ i ] ) ;
vtEspaco[ i ] = NULL ;
} /* if */
} /* for */
return TST_CondRetOK ;
} /* fim ativa: Tratar: Reinicializar módulo de teste espeçifico */
/* Tratar: Deturpar espaço */
else if ( strcmp( ComandoTeste , DeturparEspacoCmd ) == 0 )
{
numLidos = LER_LerParametros( "iii" ,
&inxEspaco , &Deslocamento , &Valor ) ;
if ( ( numLidos != 3 )
|| !VerificarInxEspaco( inxEspaco , TRUE ))
{
return TST_CondRetParm ;
} /* if */
(( char * ) vtEspaco[ inxEspaco ] )[ Deslocamento ] = ( char ) Valor ;
return TST_CondRetOK ;
} /* fim ativa: Tratar: Deturpar espaço */
/* Tratar: Atribuir string ao espaço */
else if ( strcmp( ComandoTeste , InserirStringEspacoCmd ) == 0 )
{
numLidos = LER_LerParametros( "is" ,
&inxEspaco , StringParm ) ;
if ( ( numLidos != 2 )
|| !VerificarInxEspaco( inxEspaco , TRUE )
|| !VerificarString( StringParm , DIM_STRING_PARM ))
{
return TST_CondRetParm ;
} /* if */
strcpy( vtEspaco[ inxEspaco ] , StringParm ) ;
return TST_CondRetOK ;
} /* fim ativa: Tratar: Atribuir string ao espaço */
/* Testar: Obter string contido no espaço */
else if ( strcmp( ComandoTeste , ObterStringEspacoCmd ) == 0 )
{
numLidos = LER_LerParametros( "is" ,
&inxEspaco , StringParm ) ;
if ( ( numLidos != 2 )
|| !VerificarInxEspaco( inxEspaco , TRUE )
|| !VerificarString( StringParm , DIM_STRING_PARM ))
{
return TST_CondRetParm ;
} /* if */
return TST_CompararEspaco( StringParm , vtEspaco[ inxEspaco ] ,
strlen( StringParm ) , "Conteúdo do valor errado." ) ;
} /* fim ativa: Testar: Obter string contido no espaço */
/* Testar: CED &Alocar espaço */
else if ( strcmp( ComandoTeste , AlocarEspacoCmd ) == 0 )
{
numLidos = LER_LerParametros( "iiis" ,
&inxEspaco , &Tamanho , &numLinhaFonte , StringParm ) ;
if ( ( numLidos != 4 )
|| ( Tamanho <= 0 )
|| ( numLinhaFonte < 1 )
|| !VerificarInxEspaco( inxEspaco , FALSE )
|| !VerificarString( StringParm , DIM_STRING_PARM ))
{
return TST_CondRetParm ;
} /* if */
vtEspaco[ inxEspaco ] =
CED_Malloc( Tamanho , numLinhaFonte , StringParm ) ;
return TST_CondRetOK ;
} /* fim ativa: Testar: CED &Alocar espaço */
/* Testar: CED &Desalocar espaço */
else if ( strcmp( ComandoTeste , DesalocarEspacoCmd ) == 0 )
{
numLidos = LER_LerParametros( "i" ,
&inxEspaco ) ;
if ( ( numLidos != 1 )
|| !VerificarInxEspaco( inxEspaco , FALSE ))
{
return TST_CondRetParm ;
} /* if */
CED_Free( vtEspaco[ inxEspaco ] ) ;
vtEspaco[ inxEspaco ] = NULL ;
return TST_CondRetOK ;
} /* fim ativa: Testar: CED &Desalocar espaço */
/* Testar: CED &Exibir conteúdo bruto do espaço */
else if ( strcmp( ComandoTeste , ExibirEspacoBrutoCmd ) == 0 )
{
#define DIM_ESPACO 70
numLidos = LER_LerParametros( "i" ,
&inxEspaco ) ;
if ( ( numLidos != 1 )
|| !VerificarInxEspaco( inxEspaco , FALSE ))
{
return TST_CondRetParm ;
} /* if */
TST_ExibirEspacoHexa( DIM_ESPACO + 4 , (( char * ) vtEspaco[ inxEspaco ] ) - DIM_ESPACO ) ;
return TST_CondRetOK ;
} /* fim ativa: Testar: CED &Exibir conteúdo bruto do espaço */
/* Testar: CED &Exibir conteúdo útil do espaço */
else if ( strcmp( ComandoTeste , ExibirEspacoCmd ) == 0 )
{
numLidos = LER_LerParametros( "i" ,
&inxEspaco ) ;
if ( ( numLidos != 1 )
|| !VerificarInxEspaco( inxEspaco , FALSE ))
{
return TST_CondRetParm ;
} /* if */
CED_ExibirEspaco( vtEspaco[ inxEspaco ] ) ;
return TST_CondRetOK ;
} /* fim ativa: Testar: CED &Exibir conteúdo útil do espaço */
/* Testar: CED &Verificar a integridade de um espaço de dados */
else if ( strcmp( ComandoTeste , VerificarEspacoCmd ) == 0 )
{
numLidos = LER_LerParametros( "ii" ,
&inxEspaco , &valEsperado ) ;
if ( ( numLidos != 2 )
|| !VerificarInxEspaco( inxEspaco , FALSE ))
{
return TST_CondRetParm ;
} /* if */
valObtido = CED_VerificarEspaco( vtEspaco[ inxEspaco ] ,
VerificarValor ) ;
return TST_CompararBool( valEsperado , valObtido ,
"Verificação resultou errado." ) ;
} /* fim ativa: Testar: CED &Verificar a integridade de um espaço de dados */
/* Testar: CED &Definir o tipo do espaço */
else if ( strcmp( ComandoTeste , DefinirTipoEspacoCmd ) == 0 )
{
numLidos = LER_LerParametros( "iii" ,
&inxEspaco , &idTipo , &valEsperado ) ;
if ( ( numLidos != 3 )
|| !VerificarInxEspaco( inxEspaco , FALSE ))
{
return TST_CondRetParm ;
} /* if */
valObtido = CED_DefinirTipoEspaco( vtEspaco[ inxEspaco ] , idTipo );
return TST_CompararInt( valEsperado , valObtido ,
"Condição de retorno errada." ) ;
} /* fim ativa: Testar: CED &Definir o tipo do espaço */
/* Testar: CED &Obter o tipo do espaço */
else if ( strcmp( ComandoTeste , ObterTipoEspacoCmd ) == 0 )
{
numLidos = LER_LerParametros( "ii" ,
&inxEspaco , &valEsperado ) ;
if ( ( numLidos != 2 )
|| !VerificarInxEspaco( inxEspaco , FALSE ))
{
return TST_CondRetParm ;
} /* if */
valObtido = CED_ObterTipoEspaco( vtEspaco[ inxEspaco ] ) ;
return TST_CompararInt( valEsperado , valObtido ,
"Tipo do espaço errado." ) ;
} /* fim ativa: Testar: CED &Obter o tipo do espaço */
/* Testar: CED &Obter tamanho do valor contido no espaço */
else if ( strcmp( ComandoTeste , ObterTamanhoEspacoCmd ) == 0 )
{
numLidos = LER_LerParametros( "ii" ,
&inxEspaco , &valEsperado ) ;
if ( ( numLidos != 2 )
|| !VerificarInxEspaco( inxEspaco , FALSE ))
{
return TST_CondRetParm ;
} /* if */
valObtido = CED_ObterTamanhoValor( vtEspaco[ inxEspaco ] ) ;
return TST_CompararInt( valEsperado , valObtido ,
"Tamanho do valor errado." ) ;
} /* fim ativa: Testar: CED &Obter tamanho do valor contido no espaço */
/* Testar: CED &Marcar ativo o espaço */
else if ( strcmp( ComandoTeste , MarcarEspacoAtivoCmd ) == 0 )
{
numLidos = LER_LerParametros( "i" ,
&inxEspaco ) ;
if ( ( numLidos != 1 )
|| !VerificarInxEspaco( inxEspaco , TRUE ))
{
return TST_CondRetParm ;
} /* if */
CED_MarcarEspacoAtivo( vtEspaco[ inxEspaco ] ) ;
return TST_CondRetOK ;
} /* fim ativa: Testar: CED &Marcar ativo o espaço */
/* Testar: CED &Marcar não ativo o espaço */
else if ( strcmp( ComandoTeste , MarcarEspacoNaoAtivoCmd ) == 0 )
{
numLidos = LER_LerParametros( "i" ,
&inxEspaco ) ;
if ( ( numLidos != 1 )
|| !VerificarInxEspaco( inxEspaco , TRUE ))
{
return TST_CondRetParm ;
} /* if */
CED_MarcarEspacoNaoAtivo( vtEspaco[ inxEspaco ] ) ;
return TST_CondRetOK ;
} /* fim ativa: Testar: CED &Marcar não ativo o espaço */
/* Testar: CED &Marcar não ativos todos os espaços */
else if ( strcmp( ComandoTeste , MarcarTodosNaoAtivosCmd ) == 0 )
{
CED_MarcarTodosEspacosInativos( ) ;
return TST_CondRetOK ;
} /* fim ativa: Testar: CED &Marcar não ativos todos os espaços */
/* Testar: CED &Verificar se espaço é ativo */
else if ( strcmp( ComandoTeste , VerificarEspacoAtivoCmd ) == 0 )
{
numLidos = LER_LerParametros( "ii" ,
&inxEspaco , &valEsperado ) ;
if ( ( numLidos != 2 )
|| !VerificarInxEspaco( inxEspaco , TRUE ))
{
return TST_CondRetParm ;
} /* if */
valObtido = CED_EhEspacoAtivo( vtEspaco[ inxEspaco ] ) ;
return TST_CompararInt( valEsperado , valObtido ,
"Marca de espaço ativo errada." ) ;
} /* fim ativa: Testar: CED &Verificar se espaço é ativo */
/* Testar CED &Limitar com freqüência de geração de NULL */
else if ( strcmp( ComandoTeste , VerificarFrequenciaCmd ) == 0 )
{
numLidos = LER_LerParametros( "iif" ,
&numAllocs , &Frequencia , &Tolerancia ) ;
if ( ( numLidos != 3 )
|| ( numAllocs < 100 ))
{
return TST_CondRetParm ;
} /* if */
valObtido = CED_LimitarFrequencia( Frequencia ) ;
if ( !valObtido )
{
return TST_NotificarFalha( "Freqüência limite de malloc em erro." ) ;
} /* if */
for( i = 0 ; i < numAllocs ; i++ )
{
pEspaco = CED_Malloc( 100 , i + 1 , "TesteFrequencia" ) ;
if ( pEspaco == NULL )
{
ContaNULL ++ ;
} else
{
CED_Free( pEspaco ) ;
} /* if */
} /* for */
PercentEsperado = ( 1000. - Frequencia ) / 1000. ;
PercentObtido = ContaNULL ;
PercentObtido = PercentObtido / numAllocs ;
return TST_CompararFloat( PercentEsperado , PercentObtido , Tolerancia ,
"Número de NULLs gerados está fora da tolerância." ) ;
} /* fim ativa: Testar CED &Limitar com freqüência de geração de NULL */
/* Testar: CED &Iterador: iniciar iterador de espaços */
else if ( strcmp( ComandoTeste , IniciarIteradorEspacosCmd ) == 0 )
{
CED_InicializarIteradorEspacos( ) ;
return TST_CondRetOK ;
} /* fim ativa: Testar: CED &Iterador: iniciar iterador de espaços */
/* Testar: CED &Iterador: avançar para o próximo espaço */
else if ( strcmp( ComandoTeste , AvancarProximoEspacoCmd ) == 0 )
{
numLidos = LER_LerParametros( "i" ,
&valEsperado ) ;
if ( numLidos != 1 )
{
return TST_CondRetParm ;
} /* if */
valObtido = CED_AvancarProximoEspaco( ) ;
return TST_CompararInt( valEsperado , valObtido ,
"Condição de avanço errada." ) ;
} /* fim ativa: Testar: CED &Iterador: avançar para o próximo espaço */
/* Testar: CED &Iterador: obter referência para o espaço corrente */
else if ( strcmp( ComandoTeste , ObterEspacoCorrenteCmd ) == 0 )
{
numLidos = LER_LerParametros( "i" ,
&inxEspaco ) ;
if ( ( numLidos != 1 )
|| !VerificarInxEspaco( inxEspaco , FALSE ))
{
return TST_CondRetParm ;
} /* if */
vtEspaco[ inxEspaco ] = CED_ObterPonteiroEspacoCorrente( ) ;
return TST_CondRetOK ;
} /* fim ativa: Testar: CED &Iterador: obter referência para o espaço corrente */
/* Testar: CED &Iterador: existe espaço corrente */
else if ( strcmp( ComandoTeste , ExisteEspacoCorrenteCmd ) == 0 )
{
numLidos = LER_LerParametros( "i" ,
&valEsperado ) ;
if ( numLidos != 1 )
{
return TST_CondRetParm ;
} /* if */
valObtido = CED_ExisteEspacoCorrente( ) ;
return TST_CompararInt( valEsperado , valObtido ,
"Condição de existência de iterador errada." ) ; {
} /* fim repete: Testar: CED &Iterador: existe espaço corrente */
} /* fim ativa: Testar: CED &Iterador: existe espaço corrente */
/* Testar: CED &Iterador: terminar iterador */
else if ( strcmp( ComandoTeste , TerminarIteradorEspacoCmd ) == 0 )
{
CED_TerminarIteradorEspacos( ) ;
return TST_CondRetOK ;
} /* fim ativa: Testar: CED &Iterador: terminar iterador */
/* Testar: CED &Iterador: excluir espaço corrente */
else if ( strcmp( ComandoTeste , ExcluirEspacoCorrenteCmd ) == 0 )
{
CED_ExcluirEspacoCorrente( ) ;
return TST_CondRetOK ;
} /* fim ativa: Testar: CED &Iterador: excluir espaço corrente */
return TST_CondRetNaoConhec ;
} /* Fim função: TCED &Efetuar comando de teste do controle de espaço dinâmico */
