static tpVertice* ObterOrigem (GRA_tppGrafo grafo, tpVertice* v) {
tpVertice** us = NULL; //Vetor com componentes a iterar;
tpVertice* u = NULL;
LIS_tppLista origens = grafo->componentes;
int i = 0;
LIS_IrInicioLista(grafo->vertices);
LIS_IrInicioLista(origens);
if (LIS_ProcurarValor(origens, v) == LIS_CondRetOK) {
return v; //é a origem da própria componente
}
if(LIS_NumeroDeElementos(origens) > 0) {
us = (tpVertice**) calloc(LIS_NumeroDeElementos(origens), sizeof(tpVertice*));
LIS_IrInicioLista(origens);
do {
u = (tpVertice *)LIS_ObterValor(origens);
if(u == NULL) break;
us[i] = u;
i++;
} while(LIS_AvancarElementoCorrente(origens, 1) == LIS_CondRetOK);
for ( i;i; i--) {
if (BFS(us[i-1],v) == 1) {
u = us[i-1];
}
}
free(us);
}
return u;
}
/***************************************************************************
* Função: GRA Destruir aresta adjacente
******/
GRA_tpCondRet GRA_DestruirArestaAdjacente(GRA_tppGrafo pGrafoParm, char *nomeAresta)
{
tpGrafo *pGrafo = NULL;
tpAresta *pAresta = NULL;
GRA_tpCondRet graCondRet;
if (pGrafoParm == NULL)
{
return GRA_CondRetGrafoNaoFoiCriado;
}
pGrafo = (tpGrafo*) pGrafoParm;
if (EstaVazio(pGrafo))
{
return GRA_CondRetGrafoVazio;
}
// Busca Aresta à remover
graCondRet = ProcurarAresta(pGrafo->pCorrente, nomeAresta, &pAresta);
if (graCondRet != GRA_CondRetOK)
{
return GRA_CondRetNaoAchou;
}
// Remove referência do vértice corrente
LIS_IrInicioLista(pAresta->pVertice->pAntecessores);
LIS_ProcurarValor(pAresta->pVertice->pAntecessores,pGrafo->pCorrente->nome);
LIS_ExcluirElemento(pAresta->pVertice->pAntecessores);
LIS_ExcluirElemento(pGrafo->pCorrente->pSucessores);
return GRA_CondRetOK;
}
void AssertLink(Link *l)
{
Link *b = l->brother;
CNT_CONTAR("AssertLink - Verificando assertivas");
assert( b->brother == l );
assert( l != b );
assert( l->n1 == b->n2 );
assert( l->n2 == b->n1 );
assert( l->n1->links == b->n2->links );
assert( l->n2->links == b->n1->links );
IrInicioLista( l->n1->links );
IrInicioLista( b->n1->links );
assert( LIS_CondRetOK == LIS_ProcurarValor( l->n1->links , l) );
assert( LIS_CondRetOK == LIS_ProcurarValor( b->n1->links , b) );
}
static GRA_tpCondRet ExcluirVertice (GRA_tppGrafo pGrafo, tpVertice* pVertice) {
tpAresta** vizinhos = NULL;
tpNode* no = NULL;
tpVertice * pVerticeVizinho = NULL;
int i = 0;
no = pVertice->pNode;
LIS_IrInicioLista(pGrafo->componentes);
LIS_ProcurarValor(pGrafo->componentes, pVertice);
LIS_ExcluirElemento(pGrafo->componentes);
if (LIS_NumeroDeElementos(no->arestas) > 0) {
vizinhos = (tpAresta**)calloc(LIS_NumeroDeElementos(no->arestas), sizeof(tpAresta*));
LIS_IrInicioLista(no->arestas);
do {
vizinhos[i] = (tpAresta *)LIS_ObterValor(no->arestas);
i++;
} while ( LIS_AvancarElementoCorrente(no->arestas,1) == LIS_CondRetOK);
for (i; i; i--) {
ExcluirAresta(pGrafo, pVertice, vizinhos[i-1]->pVizinho);
}
if (pGrafo->ExcluirValor != NULL && no->pValor != NULL) {
pGrafo->ExcluirValor(no->pValor);
no->pValor = NULL;
}
free(vizinhos);
}
LIS_DestruirLista(no->arestas);
no->arestas = NULL;
pVertice->pNode = NULL;
free(no);
LIS_IrInicioLista(pGrafo->vertices);
LIS_ProcurarValor(pGrafo->vertices, pVertice);
LIS_ExcluirElemento(pGrafo->vertices);
return GRA_CondRetOK;
}
static void RemoverAresta(tpVertice* u, tpVertice* v) {
LIS_tppLista vizinhos = NULL;
tpAresta * aresta_v = NULL;
vizinhos = u->pNode->arestas;
aresta_v = get_edge_by_vertex(vizinhos, v);
LIS_IrInicioLista(vizinhos);
if (aresta_v != NULL && (LIS_ProcurarValor(vizinhos, aresta_v ) == LIS_CondRetOK)) {
LIS_ExcluirElemento(vizinhos);
}
}
GRA_tpCondRet GRA_InserirAresta( GRA_tppGrafo pGrafo, int idVertice1, int idVertice2 , int idAresta) {
tpVertice* origem1 = NULL;
tpVertice* origem2 = NULL;
tpVertice* pVertice1 = get_by_id(pGrafo,idVertice1);
tpVertice* pVertice2 = get_by_id(pGrafo,idVertice2);
tpAresta* vizinho = NULL;
/* Verifica se vertice pertence ao grafo; */
if (pVertice1 == NULL || pVertice2 == NULL) {
return GRA_CondRetNaoEhVertice;
}
if (pVertice1 == pVertice2) {
return GRA_CondRetEhVizinho;
}
if (!EhVizinho(pGrafo, pVertice1, pVertice2) &&
!EhVizinho(pGrafo, pVertice2, pVertice1) ) {
tpAresta * aresta1 = NULL;
tpAresta * aresta2 = NULL;
origem1 = ObterOrigem(pGrafo, pVertice1);
origem2 = ObterOrigem(pGrafo, pVertice2);
aresta1 = ( tpAresta * ) calloc(1, sizeof( tpAresta )) ;
if (aresta1 == NULL){
return GRA_CondRetFaltouMemoria;
}
aresta2 = ( tpAresta * ) calloc(1, sizeof( tpAresta )) ;
if (aresta2 == NULL ) {
free(aresta1);
return GRA_CondRetFaltouMemoria;
}
aresta1->id = idAresta;
aresta2->id = idAresta;
aresta1->pVizinho = pVertice2;
aresta2->pVizinho = pVertice1;
LIS_InserirElementoApos(pVertice1->pNode->arestas, aresta1);
LIS_InserirElementoApos(pVertice2->pNode->arestas, aresta2);
if (origem1 != origem2) { //Estavam em componentes distintas? Se sim, junta
LIS_IrInicioLista(pGrafo->componentes);
LIS_ProcurarValor(pGrafo->componentes, origem1);
LIS_ExcluirElemento(pGrafo->componentes);
}
return GRA_CondRetOK;
}
else {
return GRA_CondRetEhVizinho;
}
}
void delLink (Link *l)
{
static int RecursionCnt = 0;
RecursionCnt++;
IrInicioLista( l->n2->links );
CNT_CONTAR("delLink - Inicio");
if ( RecursionCnt <= 1 &&
LIS_CondRetOK == LIS_ProcurarValor(l->n2->links,l->brother) ){
CNT_CONTAR("delLink - Achou: Deletando Lista de Links");
LIS_ExcluirElemento(l->n2->links);
}
CNT_CONTAR("delLink - Finalizando");
free (l);
RecursionCnt--;
}
GRA_tpCondRet GRA_MudarCorrente( GRA_tppGrafo pGrafo , int id ) {
tpVertice * vizinho = NULL;
/* Verifica se vertice pertence ao grafo; */
if (pGrafo->corrente == -1) {
return GRA_CondRetGrafoVazio;
}
vizinho = get_by_id(pGrafo,id);
if(vizinho == NULL)
return GRA_CondRetNaoEhVertice;
LIS_ProcurarValor(pGrafo->vertices,vizinho);
pGrafo->corrente = id;
return GRA_CondRetOK;
}
/***********************************************************************
*
* Função: GRA Procurar Aresta
*
* Descrição:
* Função responsável por realizar uma pesquisa na lista de arestas partindo
* de um dado vértice.
*
***********************************************************************/
GRA_tpCondRet ProcurarAresta(tpVertice *pVertice, char *nome, tpAresta **pAresta)
{
LIS_tpCondRet lisCondRet;
*pAresta = NULL;
if (nome == NULL)
{
return GRA_CondRetNaoAchou;
}
LIS_IrInicioLista(pVertice->pSucessores);
lisCondRet = LIS_ProcurarValor(pVertice->pSucessores, nome);
if (lisCondRet != LIS_CondRetOK)
{
return GRA_CondRetNaoAchou;
}
else
{
void *pVazio;
LIS_ObterValor(pVertice->pSucessores, &pVazio);
*pAresta = (tpAresta*) pVazio;
return GRA_CondRetOK;
}
}
/***********************************************************************
*
* Função: GRA Procurar Origem
*
* Descrição:
* Função responsável por realizar uma pesquisa na lista de origens.
*
***********************************************************************/
GRA_tpCondRet ProcurarOrigem(tpGrafo *pGrafo, char *nome, tpVertice **pVertice)
{
LIS_tpCondRet lisCondRet;
*pVertice = NULL;
if (nome == NULL)
{
return GRA_CondRetNaoAchou;
}
LIS_IrInicioLista(pGrafo->pOrigens);
lisCondRet = LIS_ProcurarValor(pGrafo->pOrigens, nome);
if (lisCondRet != LIS_CondRetOK)
{
return GRA_CondRetNaoAchou;
}
else
{
void *pVazio;
LIS_ObterValor(pGrafo->pOrigens, &pVazio);
*pVertice = (tpVertice*) pVazio;
return GRA_CondRetOK;
}
}
/***************************************************************************
* Função: GRA Destruir vértice corrente
******/
GRA_tpCondRet GRA_DestruirVerticeCorrente(GRA_tppGrafo pGrafoParm)
{
tpGrafo *pGrafo = NULL;
tpVertice *pVerticeOrigem = NULL, *pVertice = NULL;
tpAresta *pAresta = NULL;
int estaVazia = -1, numElemLista = 0;
if (pGrafoParm == NULL)
{
return GRA_CondRetGrafoNaoFoiCriado;
}
pGrafo = (tpGrafo*) pGrafoParm;
if (EstaVazio(pGrafo))
{
return GRA_CondRetGrafoVazio;
}
LIS_EstaVazia(pGrafo->pOrigens,&estaVazia);
if (estaVazia)
{
return GRA_CondRetNaoAchou;
}
// remove corrente vai para origem
// Navega para o inicio da lista de origens
LIS_IrInicioLista(pGrafo->pOrigens);
//Pega o valor do primeiro vértice de origem
LIS_ObterValor(pGrafo->pOrigens,(void**)&pVerticeOrigem);
//remove arestas do vertice corrente
LIS_EsvaziarLista(pGrafo->pCorrente->pSucessores);
// Para cada item da lista de anteressores, remover aresta que aponta para o corrente
LIS_NumELementos(pGrafo->pCorrente->pAntecessores,&numElemLista);
LIS_IrInicioLista(pGrafo->pCorrente->pAntecessores);
while(numElemLista > 0)
{
int nElem = 0;
LIS_ObterValor(pGrafo->pCorrente->pAntecessores,(void**)&pVertice);
LIS_NumELementos(pVertice->pSucessores, &nElem);
LIS_IrInicioLista(pVertice->pSucessores);
while(nElem > 0)
{
LIS_ObterValor(pVertice->pSucessores,(void**)&pAresta);
if(!strcmp(pAresta->pVertice->nome, pGrafo->pCorrente->nome))
{
LIS_ExcluirElemento(pVertice->pSucessores);
break;
}
LIS_AvancarElementoCorrente(pVertice->pSucessores,1);
nElem--;
}
LIS_AvancarElementoCorrente(pGrafo->pCorrente->pAntecessores,1);
numElemLista--;
}
//Exclui elemento corrente
LIS_IrInicioLista(pGrafo->pVertices);
LIS_ProcurarValor(pGrafo->pVertices,pGrafo->pCorrente->nome);
LIS_ExcluirElemento(pGrafo->pVertices);
pGrafo->pCorrente = pVerticeOrigem;
return GRA_CondRetOK;
}
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 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 */
