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 )
{
int inxGrafo = -1 ,
numLidos = -1 ,
CondRetEsp = -1 ,
param, numErros;
char idVertice;
char idVertice2;
char StringDado[ DIM_VALOR ];
VER_tppVertice novoVertice;
TST_tpCondRet CondRet ;
void * pDado ;
char * pValor;
/* Testar criar Grafo */
if ( strcmp( ComandoTeste , CRIAR_GRAFO_CMD ) == 0 ) {
numLidos = LER_LerParametros( "ii" , &inxGrafo, &CondRetEsp ) ;
if ( ( numLidos != 2 ) || ( ValidarInxGrafo( inxGrafo , NAO_VAZIO ) ) )
{
return TST_CondRetParm ;
} /* if */
CondRet = GRA_CriarGrafo( &vtGRAFO[ inxGrafo ], DestruirValor );
return TST_CompararInt( CondRetEsp , CondRet ,
"Condicao de retorno errada ao criar grafo." ) ;
} /* fim ativa: Testar criar Grafo */
/* Testar destruir Grafo */
else if ( strcmp( ComandoTeste , DESTRUIR_GRAFO_CMD ) == 0 ) {
numLidos = LER_LerParametros( "ii" , &inxGrafo, &CondRetEsp ) ;
if ( ( numLidos != 2 ) || ( ValidarInxGrafo( inxGrafo , VAZIO ) ) )
{
return TST_CondRetParm ;
} /* if */
CondRet = GRA_DestruirGrafo( vtGRAFO[ inxGrafo ] );
vtGRAFO[ inxGrafo ] = NULL;
return TST_CompararInt( CondRetEsp , CondRet ,
"Condicao de retorno errada ao destruir grafo." ) ;
} /* fim ativa: Testar destruir Grafo */
/* Testar esvaziar Grafo */
else if ( strcmp( ComandoTeste , ESV_GRAFO_CMD ) == 0 ) {
numLidos = LER_LerParametros( "ii" , &inxGrafo, &CondRetEsp ) ;
if ( ( numLidos != 2 ) || (ValidarInxGrafo( inxGrafo , VAZIO ) ) )
{
return TST_CondRetParm ;
} /* if */
CondRet = GRA_EsvaziarGrafo( vtGRAFO[ inxGrafo ] );
return TST_CompararInt( CondRetEsp , CondRet ,
"Condicao de retorno errada ao esvaziar grafo." ) ;
} /* fim ativa: Testar esvaziar Grafo */
/* Testar obter vertice corrente em Grafo */
else if ( strcmp( ComandoTeste , CORR_GRAFO_CMD ) == 0 ) {
numLidos = LER_LerParametros( "isi" , &inxGrafo, StringDado, &CondRetEsp ) ;
if ( ( numLidos != 3 ) || ( ValidarInxGrafo( inxGrafo , VAZIO ) ) )
{
return TST_CondRetParm ;
} /* if */
CondRet = GRA_ObterValorCorrente( vtGRAFO[ inxGrafo ], &novoVertice );
if(CondRet != GRA_CondRetOK)
return TST_CompararInt( CondRetEsp , CondRet ,
"Condicao de retorno errada ao obter valor corrente." ) ;
VER_ObterValor( novoVertice, &pValor);
return TST_CompararString( StringDado , pValor ,
"Retorno errado ao obter valor corrente." ) ;
} /* fim ativa: Testar obter vertice corrente em Grafo */
/* Testar alterar vertice corrente em Grafo */
else if ( strcmp( ComandoTeste , ALTCORR_GRAFO_CMD ) == 0 ) {
numLidos = LER_LerParametros( "isi" , &inxGrafo, StringDado, &CondRetEsp ) ;
if ( ( numLidos != 3 ) || ( ValidarInxGrafo( inxGrafo , VAZIO ) ) )
{
return TST_CondRetParm ;
} /* if */
VER_CriarVertice( &novoVertice );
#ifdef _DEBUG
CED_DefinirTipoEspaco( novoVertice, ID_VER_tppVertice );
#endif
VER_AtribuirValor( novoVertice, StringDado ) ;
CondRet = GRA_AlterarValorCorrente( vtGRAFO[ inxGrafo ], novoVertice );
if(CondRet != GRA_CondRetOK)
VER_DestruirVertice(novoVertice);
return TST_CompararInt( CondRetEsp , CondRet ,
"Condicao de retorno errada ao alterar corrente." ) ;
} /* fim ativa: Testar alterar vertice corrente em Grafo */
/* Testar alterar vertice corrente para null em Grafo */
else if ( strcmp( ComandoTeste , ALTCORRNULL_GRAFO_CMD ) == 0 ) {
numLidos = LER_LerParametros( "ii" , &inxGrafo, &CondRetEsp ) ;
if ( ( numLidos != 2 ) || ( ValidarInxGrafo( inxGrafo , VAZIO ) ) )
{
return TST_CondRetParm ;
} /* if */
CondRet = GRA_AlterarValorCorrente( vtGRAFO[ inxGrafo ], NULL );
return TST_CompararInt( CondRetEsp , CondRet ,
"Condicao de retorno errada ao alterar corrente." ) ;
} /* fim ativa: Testar alterar vertice corrente em Grafo */
/* Testar ir para vertice em Grafo */
else if ( strcmp( ComandoTeste , IRVER_GRAFO_CMD ) == 0 ) {
numLidos = LER_LerParametros( "ici" , &inxGrafo, &idVertice, &CondRetEsp ) ;
if ( ( numLidos != 3 ) || ( ValidarInxGrafo( inxGrafo , VAZIO ) ) )
{
return TST_CondRetParm ;
} /* if */
CondRet = GRA_IrParaVertice( vtGRAFO[ inxGrafo ], idVertice );
return TST_CompararInt( CondRetEsp , CondRet ,
"Condicao de retorno errada ao ir para vertice." ) ;
} /* fim ativa: Testar ir para vertice em Grafo */
/* Testar andar para vertice em Grafo */
else if ( strcmp( ComandoTeste , ANDARVER_GRAFO_CMD ) == 0 ) {
numLidos = LER_LerParametros( "ici" , &inxGrafo, &idVertice, &CondRetEsp ) ;
if ( ( numLidos != 3 ) || ( ValidarInxGrafo( inxGrafo , VAZIO ) ) )
{
return TST_CondRetParm ;
} /* if */
CondRet = GRA_AndarParaVertice( vtGRAFO[ inxGrafo ], idVertice );
return TST_CompararInt( CondRetEsp , CondRet ,
"Condicao de retorno errada ao andar para vertice." ) ;
} /* fim ativa: Testar andar para vertice em Grafo */
/* Testar inserir vertice em Grafo */
else if ( strcmp( ComandoTeste , INSVER_GRAFO_CMD ) == 0 ) {
numLidos = LER_LerParametros( "isci" , &inxGrafo, StringDado, &idVertice, &CondRetEsp ) ;
if ( ( numLidos != 4 ) || ( ValidarInxGrafo( inxGrafo , VAZIO ) ) )
{
return TST_CondRetParm ;
} /* if */
VER_CriarVertice( &novoVertice );
#ifdef _DEBUG
CED_EhEspacoAtivo( novoVertice );
CED_DefinirTipoEspaco( novoVertice, ID_VER_tppVertice );
#endif
VER_AtribuirValor( novoVertice, StringDado ) ;
CondRet = GRA_InserirVertice( vtGRAFO[ inxGrafo ], novoVertice, idVertice );
return TST_CompararInt( CondRetEsp , CondRet ,
"Condicao de retorno errada ao inserir vertice." ) ;
} /* fim ativa: Testar inserir vertice em Grafo */
/* Testar inserir vertice de valor null em Grafo */
else if ( strcmp( ComandoTeste , INSVERNULL_GRAFO_CMD ) == 0 ) {
numLidos = LER_LerParametros( "ici" , &inxGrafo, &idVertice, &CondRetEsp ) ;
if ( ( numLidos != 3 ) || ( ValidarInxGrafo( inxGrafo , VAZIO ) ) )
{
return TST_CondRetParm ;
} /* if */
CondRet = GRA_InserirVertice( vtGRAFO[ inxGrafo ], NULL, idVertice );
return TST_CompararInt( CondRetEsp , CondRet ,
"Condicao de retorno errada ao inserir vertice." ) ;
} /* fim ativa: Testar inserir vertice de valor null em Grafo */
/* Testar excluir vertice corrente em Grafo */
else if ( strcmp( ComandoTeste , EXCCORR_GRAFO_CMD ) == 0 ) {
numLidos = LER_LerParametros( "ii" , &inxGrafo, &CondRetEsp) ;
if ( ( numLidos != 2 ) || ( ValidarInxGrafo( inxGrafo , VAZIO ) ) )
{
return TST_CondRetParm ;
} /* if */
CondRet = GRA_ExcluirVerticeCorrente( vtGRAFO[ inxGrafo ] );
return TST_CompararInt( CondRetEsp , CondRet ,
"Condicao de retorno errada ao excluir vertice corrente." ) ;
} /* fim ativa: Testar excluir vertice corrente em Grafo */
/* Testar inserir aresta em Grafo */
else if ( strcmp( ComandoTeste , INSAR_GRAFO_CMD ) == 0 ) {
numLidos = LER_LerParametros( "iccsi" , &inxGrafo, &idVertice, &idVertice2, StringDado, &CondRetEsp) ;
if ( ( numLidos != 5 ) || ( ValidarInxGrafo( inxGrafo , VAZIO ) ) )
{
return TST_CondRetParm ;
} /* if */
CondRet = GRA_InserirAresta( vtGRAFO[ inxGrafo ], idVertice, idVertice2, StringDado );
return TST_CompararInt( CondRetEsp , CondRet ,
"Condicao de retorno errada ao inserir aresta." ) ;
} /* fim ativa: Testar inserir aresta em Grafo */
/* Testar inserir aresta em origem no Grafo */
else if ( strcmp( ComandoTeste , INSARO_GRAFO_CMD ) == 0 ) {
numLidos = LER_LerParametros( "icsi" , &inxGrafo, &idVertice, StringDado, &CondRetEsp) ;
if ( ( numLidos != 4 ) || ( ValidarInxGrafo( inxGrafo , VAZIO ) ) )
{
return TST_CondRetParm ;
} /* if */
CondRet = GRA_InserirArestaOrigemCorrente( vtGRAFO[ inxGrafo ], idVertice, StringDado );
return TST_CompararInt( CondRetEsp , CondRet ,
"Condicao de retorno errada ao inserir aresta na origem corrente." ) ;
} /* fim ativa: Testar inserir aresta em origem no Grafo */
/* Testar excluir aresta em Grafo */
else if ( strcmp( ComandoTeste , EXCAR_GRAFO_CMD ) == 0 ) {
numLidos = LER_LerParametros( "isi" , &inxGrafo, StringDado, &CondRetEsp) ;
if ( ( numLidos != 3 ) || ( ValidarInxGrafo( inxGrafo , VAZIO ) ) )
{
return TST_CondRetParm ;
} /* if */
CondRet = GRA_ExcluirAresta( vtGRAFO[ inxGrafo ], StringDado );
return TST_CompararInt( CondRetEsp , CondRet ,
"Condicao de retorno errada ao excluir aresta." ) ;
} /* fim ativa: Testar excluir aresta em Grafo */
/* Testar adicionar origem em Grafo */
else if ( strcmp( ComandoTeste , ADDOR_GRAFO_CMD ) == 0 ) {
numLidos = LER_LerParametros( "ici" , &inxGrafo, &idVertice, &CondRetEsp) ;
if ( ( numLidos != 3 ) || ( ValidarInxGrafo( inxGrafo , VAZIO ) ) )
{
return TST_CondRetParm ;
} /* if */
CondRet = GRA_AdicionarOrigem( vtGRAFO[ inxGrafo ], idVertice );
return TST_CompararInt( CondRetEsp , CondRet ,
"Condicao de retorno errada ao adicionar origem." ) ;
} /* fim ativa: Testar adicionar origem em Grafo */
/* Testar remover origem em Grafo */
else if ( strcmp( ComandoTeste , RMVOR_GRAFO_CMD ) == 0 ) {
numLidos = LER_LerParametros( "ici" , &inxGrafo, &idVertice, &CondRetEsp) ;
if ( ( numLidos != 3 ) || ( ValidarInxGrafo( inxGrafo , VAZIO ) ) )
{
return TST_CondRetParm ;
} /* if */
CondRet = GRA_RemoverOrigem( vtGRAFO[ inxGrafo ], idVertice );
return TST_CompararInt( CondRetEsp , CondRet ,
"Condicao de retorno errada ao remover origem." ) ;
} /* fim ativa: Testar remover origem em Grafo */
#ifdef _DEBUG
/* Realizar deturpacao */
else if ( strcmp( ComandoTeste , DETURPAR_GRAFO_CMD ) == 0 ) {
numLidos = LER_LerParametros( "ii" , &inxGrafo, ¶m) ;
if ( ( numLidos != 2 ) || ( ValidarInxGrafo( inxGrafo , VAZIO ) ) )
{
return TST_CondRetParm ;
} /* if */
return TST_CompararInt( GRA_CondRetOK , GRA_Deturpar(vtGRAFO[ inxGrafo ], param),
"Erro ao deturpar." ) ;
} /* fim ativa: Realizar deturpacao */
/* Realizar verificao estrututral */
else if ( strcmp( ComandoTeste , VERIFICAR_GRAFO_CMD ) == 0 ) {
numLidos = LER_LerParametros( "ii" , &inxGrafo, ¶m) ;
if ( ( numLidos != 2 ) || ( ValidarInxGrafo( inxGrafo , VAZIO ) ) )
{
return TST_CondRetParm ;
} /* if */
GRA_VerificarEstrutura( vtGRAFO[ inxGrafo ], &numErros );
return TST_CompararInt( param , numErros ,
"Total de erros errado ao verificar estrutura." ) ;
} /* fim ativa: Realizar verificao estrututral */
#endif
} /* Fim função: TGRA &Testar grafo */
TST_tpCondRet TST_EfetuarComando( char * ComandoTeste )
{
int 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 */
