int VerificaVazamentoMem(LIS_tppLista pLista)
{
/*
void CED_InicializarIteradorEspacos( ) ;
int CED_AvancarProximoEspaco( ) ;
void * CED_ObterPonteiroEspacoCorrente( ) ;
int CED_EhEspacoAtivo( void * Ponteiro ) ;
void CED_ExibirTodosEspacos( CED_tpModoExibir Regra ) ;
*/
void* aux;
int i, contaInativos = 0, f;
struct tagElemLista * elemAux;
void CED_InicializarIteradorEspacos( ) ;
elemAux = pLista->pOrigemLista;
// Percorre a estrutura marcando os espaços ativos
CED_MarcarEspacoAtivo(pLista);
while(elemAux != NULL)
{
verificaElemento(elemAux, &f);
elemAux = elemAux->pProx;
}
// percorre a lista de espaços alocados verficando se existe algum espaço inativo, se tiver, entao houve vazamento
CED_InicializarIteradorEspacos( ) ;
do
{
aux = CED_ObterPonteiroEspacoCorrente( ) ;
if(!CED_EhEspacoAtivo( aux ))
contaInativos++;
}while(CED_AvancarProximoEspaco( ));
// exibe todos os espaços inativos se houver
if(contaInativos > 0)
{
CED_ExibirTodosEspacos( CED_ExibirInativos ) ;
f = 1;
}
CED_TerminarIteradorEspacos();
return f;
}
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 * 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 inxTab = -1 ,
numLidos = -1 ;
short int tamColuna = -1 ,
tamLinha = -1 ,
Coluna = -1 ,
Linha = -1 ,
ColunaDest = -1,
LinhaDest = -1;
PECA_tpCor cor;
TAB_tpTamanho tam;
TAB_tpPosicao pos,
posOrigem,
posDestino;
TAB_tpCondRet condEsp;
TAB_tpCondRet tabCondRet;
PECA_tppPeca pDado ;
int valEsp = -1 ;
#ifdef _DEBUG
TAB_tpModoDeturpacao modoDeturpacao;
#endif
int i ;
/* Efetuar reset de teste de tabuleiro */
if ( strcmp( ComandoTeste , RESETAR_TABULEIRO_CMD ) == 0 )
{
for ( i = 0 ; i < DIM_VT_TABULEIRO ; i++ )
{
vtTab[ i ] = NULL ;
} /* for */
return TST_CondRetOK ;
} /* fim ativa: Efetuar reset de teste de tabuleiro */
/* Testar Criar Tabuleiro */
else if ( strcmp( ComandoTeste , CRIAR_TABULEIRO_CMD ) == 0 )
{
numLidos = LER_LerParametros( "iiii" ,
&inxTab, &tamColuna, &tamLinha, &valEsp ) ;
if ( ( numLidos != 4 )
|| ( ! ValidarInxTabuleiro( inxTab )))
{
return TST_CondRetParm ;
}
vtTab[ inxTab ] =
TAB_CriarTabuleiro( tamColuna, tamLinha, DestruirPeca ) ;
return TST_CompararPonteiroNulo( 1 , vtTab[ inxTab ] ,
"Erro em ponteiro de nova tabuleiro." ) ;
} /* fim ativa: Testar CriarTabuleiro */
/* Testar Destruir Tabuleiro */
else if ( strcmp( ComandoTeste , DESTRUIR_TABULEIRO_CMD ) == 0 )
{
numLidos = LER_LerParametros( "i" ,
&inxTab ) ;
if ( ( numLidos != 1 )
|| ( ! ValidarInxTabuleiro( inxTab )))
{
return TST_CondRetParm ;
}
TAB_DestruirTabuleiro( vtTab[ inxTab ] ) ;
vtTab[ inxTab ] = NULL;
return TST_CondRetOK ;
} /* fim ativa: Testar Destruir Tabuleiro*/
/* Testar Obter Tamanho */
else if ( strcmp( ComandoTeste , OBTER_TAMANHO_CMD ) == 0 )
{
numLidos = LER_LerParametros( "iii" ,
&inxTab, &tamColuna, &tamLinha ) ;
if ( ( numLidos != 3 )
|| ( ! ValidarInxTabuleiro( inxTab )))
{
return TST_CondRetParm ;
}
tam = TAB_ObterTamanho( vtTab[ inxTab ] ) ;
if ((tam.colunas == tamColuna) && (tam.linhas == tamLinha))
return TST_CondRetOK ;
return TST_CondRetErro;
} /* fim ativa: Testar Obter Tamanho */
/* Testar Incluir Peca */
else if ( strcmp( ComandoTeste , INCLUIR_PECA_CMD ) == 0 )
{
numLidos = LER_LerParametros( "iiiii" ,
&inxTab , &Coluna, &Linha, &cor , &condEsp ) ;
if ( ( numLidos != 5 )
|| ( ! ValidarInxTabuleiro( inxTab )) )
{
return TST_CondRetParm ;
}
pDado = (PECA_tppPeca) PECA_CriarPeca (cor) ;
if ( pDado == NULL )
{
return TST_CondRetMemoria ;
}
pos.coluna = Coluna;
pos.linha = Linha;
tabCondRet = TAB_IncluirPeca( vtTab[ inxTab ] , pDado , pos) ;
if ( tabCondRet != TAB_CondRetOK )
{
PECA_DestruirPeca(pDado) ;
}
return TST_CompararInt( condEsp , tabCondRet ,
"Condicao de retorno errada ao incluir peca no tabuleiro." ) ;
} /* fim ativa: Testar Incluir Peca*/
/* Testar Mover Peça*/
else if ( strcmp( ComandoTeste , MOVER_PECA_CMD ) == 0 )
{
numLidos = LER_LerParametros( "iiiiii" ,
&inxTab , &Coluna, &Linha, &ColunaDest , &LinhaDest, &condEsp ) ;
if ( ( numLidos != 6 )
|| ( ! ValidarInxTabuleiro( inxTab )) )
{
return TST_CondRetParm ;
}
posOrigem.coluna = Coluna;
posOrigem.linha = Linha;
posDestino.coluna = ColunaDest;
posDestino.linha = LinhaDest;
tabCondRet = TAB_MoverPeca( vtTab[ inxTab ] , posOrigem , posDestino) ;
return TST_CompararInt( condEsp , tabCondRet ,
"Condicao de retorno errada ao mover a peca no tabuleiro." ) ;
} /* fim ativa: Testar Mover Peca*/
/* Testar Obter Peca */
else if ( strcmp( ComandoTeste , OBTER_PECA_CMD ) == 0 )
{
numLidos = LER_LerParametros( "iiii" ,
&inxTab , &Coluna, &Linha, &valEsp ) ;
if ( ( numLidos != 4 )
|| ( ! ValidarInxTabuleiro( inxTab )) )
{
return TST_CondRetParm ;
}
pos.coluna = Coluna;
pos.linha = Linha;
pDado = (PECA_tppPeca) TAB_ObterPeca( vtTab[ inxTab ] , pos) ;
if ( valEsp == 0 )
{
return TST_CompararPonteiroNulo( 0, pDado,
"Peça não devia existir");
}
if ( pDado == NULL)
{
return TST_CompararPonteiroNulo( 1, pDado,
"Peça deveria existir");
}
return TST_CondRetOK;
} /* fim ativa: Testar Obter Peca*/
/* Testar Destruir Peca */
else if ( strcmp( ComandoTeste , DESTRUIR_PECA_CMD ) == 0 )
{
numLidos = LER_LerParametros( "iiii" ,
&inxTab , &Coluna, &Linha, &condEsp ) ;
if ( ( numLidos != 4 )
|| ( ! ValidarInxTabuleiro( inxTab )) )
{
return TST_CondRetParm ;
}
pos.coluna = Coluna;
pos.linha = Linha;
tabCondRet = TAB_DestruirPeca( vtTab[ inxTab ] , pos) ;
return TST_CompararInt( condEsp , tabCondRet ,
"Condicao de retorno errada ao excluir peca do tabuleiro." ) ;
} /* fim ativa: Testar Destruir Peca*/
/* Testar Remover Peca */
else if ( strcmp( ComandoTeste , REMOVER_PECA_CMD ) == 0 )
{
numLidos = LER_LerParametros( "iiii" ,
&inxTab , &Coluna, &Linha, &valEsp ) ;
if ( ( numLidos != 4 )
|| ( ! ValidarInxTabuleiro( inxTab )) )
{
return TST_CondRetParm ;
}
pos.coluna = Coluna;
pos.linha = Linha;
pDado = (PECA_tppPeca) TAB_RemoverPeca( vtTab[ inxTab ] , pos) ;
if ( valEsp == 0 )
{
return TST_CompararPonteiroNulo( 0, pDado, "Peça não devia existir");
}
if ( pDado == NULL )
{
return TST_CompararPonteiroNulo( 1, pDado, "Peça deveria existir");
}
return TST_CondRetOK;
} /* fim ativa: Testar Remover Peca*/
/* Início instrumentação */
#ifdef _DEBUG
/* Testar verificador de tabuleiro */
else if ( strcmp( ComandoTeste, VERIFICAR_TABULEIRO_CMD ) == 0 )
{
numLidos = LER_LerParametros( "ii",
&inxTab, &condEsp ) ;
if ( ( numLidos != 2 )
|| !ValidarInxTabuleiro( inxTab ))
{
return TST_CondRetParm;
}
return TST_CompararInt( condEsp ,
TAB_VerificarTabuleiro( vtTab[ inxTab ] ) ,
"Retorno incorreto ao verificar tabuleiro") ;
} /* fim ativa: Testar verificador de tabuleiro */
/* Deturpar um tabuleiro */
else if ( strcmp( ComandoTeste, DETURPAR_CMD ) == 0 )
{
numLidos = LER_LerParametros( "ii" ,
&inxTab , &modoDeturpacao ) ;
if ( ( numLidos != 2 )
|| !ValidarInxTabuleiro( inxTab ))
{
return TST_CondRetParm;
}
TAB_Deturpar( vtTab [ inxTab ] , modoDeturpacao ) ;
return TST_CondRetOK ;
} /* fim ativa: Deturpar um tabuleiro */
/* Verificar vazamento de memória */
else if ( strcmp( ComandoTeste, VERIFICAR_MEMORIA_CMD ) == 0 )
{
CED_ExibirTodosEspacos( CED_ExibirTodos ) ;
return TST_CondRetOK ;
} /* fim ativa: Verificar vazamento de memória */
#endif
/* Fim instrumentação */
return TST_CondRetNaoConhec ;
} /* Fim função: TTAB &Testar tabuleiro */
