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 */