LIS_tpCondRet VerificaLista (LIS_tppLista pLista)
{
LIS_tppLista ant = NULL;
tpElemLista * aux;
int elementosPercorridos = 1 ;
printf("verificar lista 1\n");
if( pLista == NULL )
{
return LIS_CondRetOK;
}/*if*/
aux = pLista->pOrigemLista;
printf("verificar lista 2\n");
if( aux->pAnt != NULL )
{
CNT_CONTAR ("LIS_ErroPrimeiro") ;
CNT_CONTAR (CONTADOR_FALHAS_ESTRUTURA) ; //algo antes do primeiro elemento
}/* if */
printf("verificar lista 3\n");
do
{
printf("HAHAHA: %d, %d\n",LIS_TipoEspacoElemento,CED_ObterTipoEspaco(aux));
if(TST_CompararInt(LIS_TipoEspacoElemento,CED_ObterTipoEspaco(aux),"Tipo de espaço do elemento não é elemento da lista")!=TST_CondRetOK)
{
CNT_CONTAR(CONTADOR_FALHAS_ESTRUTURA);
printf("vai retornar\n");
return LIS_CondRetErroEstrutura;
}
printf("--\n");
if(TST_CompararPonteiro(aux->pProx->pAnt,aux,"Erro no ponteiro para proximo")!=TST_CondRetOK)
{
CNT_CONTAR ("LIS_ErroProximo") ;
CNT_CONTAR (CONTADOR_FALHAS_ESTRUTURA) ;
}/*if*/
aux=aux->pProx ;
elementosPercorridos++;
} while(aux->pProx!=NULL);
printf("verificar lista 4\n");
if(elementosPercorridos!=pLista->numElem)
{
CNT_CONTAR ("LIS_ErroNumElem") ;
CNT_CONTAR (CONTADOR_FALHAS_ESTRUTURA) ; //numero de elementos percorridos é diferente do numero da cabeça da lista
}/* if */
printf("verificar lista 5\n");
if(TST_CompararPonteiro(pLista->pFimLista,aux,"Ultimo elemento nao e o esperado.")!=TST_CondRetOK)
{
CNT_CONTAR ("LIS_ErroUltimo") ;
CNT_CONTAR (CONTADOR_FALHAS_ESTRUTURA) ;
}/* if */
return LIS_CondRetOK;
}
LIS_tpCondRet verificaElemento (void * ppElem, int* f)
{
struct tagElemLista * pElem;
int falha = 0;
pElem = (tpElemLista*)(ppElem);
CNT_CONTAR("verificaElem");
// marca elemento ativo
CED_MarcarEspacoAtivo(pElem);
// verifica tipo de dado do elemento
if ( TST_CompararInt( LIS_TipoElemento ,
CED_ObterTipoEspaco( pElem) ,
"Tipo do espaço de dados não é elemento da lista." ) != TST_CondRetOK )
{
CNT_CONTAR("VerificaElemif0");
falha++;
}
else CNT_CONTAR("NaoVerificaElemTipoif0");
// marca o campo valor como ativo
CED_MarcarEspacoAtivo(pElem->pValor);
*f = falha;
return LIS_CondRetOK;
}
int LST_VerificaAssertivaAnt ( TpLista *pLista )
{
TpNoLista *aux;
int i = 1;
aux = pLista->pFimLista;
if ( aux != NULL )
{
CNT_CONTAR("LST_AssertivaAnt_if1");
while ( aux->pAnt != NULL && CED_ObterTipoEspaco(aux->pAnt) == CED_ObterTipoEspaco(aux) )
{
CNT_CONTAR("LST_AssertivaAnt_while1");
if ( aux != aux->pAnt->pProx ){
printf("\nErro: pNoCorrente != pNoCorrente->pAnt->pProx\n");
CNT_CONTAR("LST_AssertivaAnt_Erro");
return 1;
} else {
CNT_CONTAR("LST_AssertivaAnt_No_ok");
}
i++;
aux = aux -> pAnt;
}
} else {
CNT_CONTAR("LST_AssertivaAnt_else1");
}/* if*/
if(i == LST_RetornaNumElementos( pLista ))
{
CNT_CONTAR("LST_AssertivaAnt_if2");
return 0;
} /* if*/
else
{
printf("\nErro: nao foi possivel percorrer toda a lista, significa que algum no foi desencadeado\n");
CNT_CONTAR("LST_AssertivaAnt_else2");
return 1;
} /* if*/
}/* Fim função: LST Verifica Assertiva Ant */
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 */
// 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;
}
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 */
