DES_tpCondRet DES_DestroiDesenho( void )
{
int i;
// Testa se o ponteiro desenho já foi iniciado;
if( pDesenho == NULL )
return DES_CondRetDesenhoNaoIniciado;
// Libera cada cabeça de lista
for( i = 0; i < pDesenho->iLinhas; i++ )
LST_DestruirLista( pDesenho->pListasHorizontais[i], ExcluiValor );
#ifdef _DEBUG
CED_MarcarEspacoNaoAtivo( pDesenho->pListasHorizontais );
#endif
// Libera o vetor de cabeças de lista
free( pDesenho->pListasHorizontais );
// Libera cada cabeça de lista
for( i = 0; i < pDesenho->iColunas; i++ )
LST_DestruirLista( pDesenho->pListasVerticais[i], ExcluiValor );
#ifdef _DEBUG
CED_MarcarEspacoNaoAtivo( pDesenho->pListasVerticais );
#endif
// Libera o vetor de cabeças de lista
free( pDesenho->pListasVerticais );
// Libera a matriz de jogo
MAT_DestruirMatriz( pDesenho->pMatrizJogo, ExcluiCelula );
#ifdef _DEBUG
CED_MarcarEspacoNaoAtivo( pDesenho->pMatrizJogo );
#endif
// Libera o ponteiro para estrutura matriz
free( pDesenho->pMatrizJogo );
#ifdef _DEBUG
CED_MarcarEspacoNaoAtivo( pDesenho );
#endif
// Libera o ponteiro para estrutura encapsulada Desenho
free( pDesenho );
pDesenho = NULL;
return DES_CondRetOk;
}
PILHA_tpCondRet PILHA_DestroiPilha(PILHA_tppPilha p){
if(!p){
return PILHA_CondRetPilhaInexistente;
}
#ifdef _DEBUG
CED_MarcarEspacoNaoAtivo(p);
#endif
LIS_DestruirLista(p->topo);
free(p);
return PILHA_CondRetOK;
}
void LIS_DestruirLista( LIS_tppLista pLista )
{
#ifdef _DEBUG
CED_MarcarEspacoNaoAtivo(pLista);
#endif
#ifdef _DEBUG
assert( pLista != NULL ) ;
#endif
LIS_EsvaziarLista( pLista ) ;
free( pLista ) ;
} /* Fim função: LIS &Destruir lista */
LST_tpCondRet LST_DestruirLista( TpLista * pLista, void ( * ExcluirValor) ( void * pDado) )
{
if ( pLista == NULL)
{
return LST_CondRetListaInexistente;
} /* if */
LST_EsvaziarLista ( pLista , ExcluirValor );
#ifdef _DEBUG
CED_MarcarEspacoNaoAtivo( pLista );
#endif
free ( pLista );
return LST_CondRetOK;
} /* Fim função: LST Destruir lista duplamente encadeada*/
LIS_tpCondRet LIS_ExcluirElemento( LIS_tppLista pLista )
{
tpElemLista * pElem ;
#ifdef _DEBUG
CED_MarcarEspacoNaoAtivo(pLista->pElemCorr);
#endif
#ifdef _DEBUG
assert( pLista != NULL ) ;
#endif
if ( pLista->pElemCorr == NULL )
{
return LIS_CondRetListaVazia ;
} /* if */
pElem = pLista->pElemCorr ;
/* Desencadeia à esquerda */
if ( pElem->pAnt != NULL )
{
pElem->pAnt->pProx = pElem->pProx ;
pLista->pElemCorr = pElem->pAnt ;
} else {
pLista->pElemCorr = pElem->pProx ;
pLista->pOrigemLista = pLista->pElemCorr ;
} /* if */
/* Desencadeia à direita */
if ( pElem->pProx != NULL )
{
pElem->pProx->pAnt = pElem->pAnt ;
} else
{
pLista->pFimLista = pElem->pAnt ;
} /* if */
LiberarElemento( pLista , pElem ) ;
return LIS_CondRetOK ;
} /* Fim função: LIS &Excluir elemento */
void LiberarNo( TpLista * pLista , TpNoLista * pElem, void ( * ExcluirValor) ( void * pDado) )
{
if (( pElem != NULL ))
{
pElem->pAnt = pElem->pProx;
ExcluirValor ( pElem->pValor ) ;
pLista->numElementos = pLista->numElementos - 1;
#ifdef _DEBUG
CED_MarcarEspacoNaoAtivo(pElem);
#endif
free(pElem);
} /* if */
} /* Fim função: LST Liberar No da lista */
void LiberarElemento( LIS_tppLista pLista ,
tpElemLista * pElem )
{
#ifdef _DEBUG
CED_MarcarEspacoNaoAtivo(pElem);
#endif
if ( ( pLista->ExcluirValor != NULL )
&& ( pElem->pValor != NULL ))
{
pLista->ExcluirValor( pElem->pValor ) ;
} /* if */
free( pElem ) ;
pLista->numElem-- ;
} /* Fim função: LIS -Liberar elemento da lista */
void LIS_eliminaElemCorr(LIS_tppLista pLista){ // 1
CED_MarcarEspacoNaoAtivo(pLista->pElemCorr);
free(pLista->pElemCorr);
}
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 */
