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; }
static DES_tpCondRet InicializaListas( void ) { DES_tpCondRet CondRet; //Aloca o vetor que vai guardar as cabeças de listas horizontais pDesenho->pListasHorizontais = ( TpLista ** ) malloc( pDesenho->iLinhas * sizeof( TpLista* ) ); if(pDesenho->pListasHorizontais == NULL) return DES_CondRetFaltouMemoria; #ifdef _DEBUG CED_MarcarEspacoAtivo( pDesenho->pListasHorizontais ); #endif //Aloca o vetor que vai guardar as cabeças de listas verticais pDesenho->pListasVerticais = ( TpLista ** ) malloc( pDesenho->iColunas * sizeof( TpLista* ) ); if( pDesenho->pListasVerticais == NULL ) return DES_CondRetFaltouMemoria; #ifdef _DEBUG CED_MarcarEspacoAtivo( pDesenho->pListasVerticais ); #endif // Inicialização das Listas e valores de linha CondRet = InicializaListasHorizontais( ); if(CondRet != DES_CondRetOk) return CondRet; // Inicialização das Listas e valores de coluna CondRet = InicializaListasVerticais( ); if(CondRet != DES_CondRetOk) return CondRet; return DES_CondRetOk; }
TpNoLista * CriarElemento( TpLista * pLista , void * pValor #ifdef _DEBUG , char tipoElemento #endif ) { TpNoLista * pElem ; pElem = ( TpNoLista * ) malloc( sizeof( TpNoLista )) ; if ( pElem == NULL ) { return NULL ; } /* if */ #ifdef _DEBUG CED_MarcarEspacoAtivo( pElem ); #endif pElem->pValor = pValor ; pElem->pAnt = NULL ; pElem->pProx = NULL ; #ifdef _DEBUG pElem->tipoElemento = tipoElemento; #endif pLista->numElementos = pLista->numElementos + 1; return pElem ; } /* Fim função: LST Criar o elemento */
TpLista * LST_CriarLista ( #ifdef _DEBUG char tipoElem #endif ) { TpLista * pLista; pLista = ( TpLista * )malloc( sizeof( TpLista )) ; /* alocar espaço para lista */ if ( pLista== NULL ) { printf ( " Espaço na memória insuficiente " ) ; return NULL ; } /* if */ #ifdef _DEBUG CED_MarcarEspacoAtivo( pLista ); #endif LimparCabeca( pLista #ifdef _DEBUG , tipoElem #endif ) ; /*zerar todos os campos da estrutura.*/ return pLista ; } /* Fim função: LST Criar lista genérica duplamente encadeada*/
tpElemLista * CriarElemento( LIS_tppLista pLista , void * pValor , char * tipo) { tpElemLista * pElem ; pElem = ( tpElemLista * ) malloc( sizeof( tpElemLista )) ; if ( pElem == NULL ) { return NULL ; } /* if */ pElem->pValor = pValor ; pElem->pAnt = NULL ; pElem->pProx = NULL ; #ifdef _DEBUG CED_MarcarEspacoAtivo(pElem); #endif strcpy(pElem->tipo, tipo); pLista->numElem ++ ; return pElem ; } /* Fim função: LIS -Criar o elemento */
DES_tpCondRet DES_RetomaUltimoJogoSalvo( void ) { int i, j; int Linhas, Colunas, Dicas; int CondRet; FILE * ArquivoDesenho = fopen( NOME_JOGO_SALVO, "r" ); if( ArquivoDesenho == NULL ) return DES_CondRetPonteiroArquivoNulo; //Se existe uma estrutura desenho definida, destroi ela antes de criar outra if( pDesenho != NULL ) DES_DestroiDesenho( ); if( fscanf(ArquivoDesenho, "%d %d %d", &Linhas, &Colunas, &Dicas) != 3 ) return DES_CondRetArquivoInvalido; //Verifica se a quantidade de linhas e de colunas são válidas if( Linhas < NUM_LINHAS_MINIMO || Colunas < NUM_COLUNAS_MINIMO || Linhas > NUM_LINHAS_MAXIMO || Colunas > NUM_COLUNAS_MAXIMO ) return DES_CondRetTamanhoInvalido; //Aloca a estrutura desenho pDesenho = ( TpDesenho* ) malloc( sizeof( TpDesenho ) ); //Falhou a alocação de memória if( pDesenho == NULL ) return DES_CondRetFaltouMemoria; #ifdef _DEBUG CED_MarcarEspacoAtivo( pDesenho ); #endif pDesenho->iLinhas = Linhas; pDesenho->iColunas = Colunas; pDesenho->iDicas = Dicas; //Chama o módulo de matriz e guarda o ponteiro na estrutura desenho pDesenho->pMatrizJogo = MAT_CriarMatriz( Linhas, Colunas #ifdef _DEBUG , 'c' #endif ); if( pDesenho->pMatrizJogo == NULL ) return DES_CondRetErroForaDoModuloDesenho; //Gera o esquema de forma aleatória PreencheMatrizUltimoJogo( ArquivoDesenho ); CondRet = InicializaListas( ); if( CondRet != DES_CondRetOk ) return ( DES_tpCondRet ) CondRet; return DES_CondRetOk; }
DES_tpCondRet DES_IniciaDesenho( int NumLinhas, int NumColunas ) { int CondRet; //Se existe uma estrutura desenho definida, destroi ela antes de criar outra if( pDesenho != NULL ) DES_DestroiDesenho( ); //Verifica se a quantidade de linhas e de colunas são válidas if( NumLinhas < NUM_LINHAS_MINIMO || NumColunas < NUM_COLUNAS_MINIMO || NumLinhas > NUM_LINHAS_MAXIMO || NumColunas > NUM_COLUNAS_MAXIMO ) return DES_CondRetTamanhoInvalido; //Aloca a estrutura desenho pDesenho = ( TpDesenho* ) malloc( sizeof( TpDesenho ) ); //Falhou a alocação de memória if( pDesenho == NULL ) return DES_CondRetFaltouMemoria; pDesenho->iLinhas = NumLinhas; pDesenho->iColunas = NumColunas; pDesenho->iDicas = NUM_MAX_DICAS; #ifdef _DEBUG CED_MarcarEspacoAtivo( pDesenho ); #endif //Chama o módulo de matriz e guarda o ponteiro na estrutura desenho pDesenho->pMatrizJogo = MAT_CriarMatriz( NumLinhas, NumColunas #ifdef _DEBUG , 'c' #endif ); if( pDesenho->pMatrizJogo == NULL ) return DES_CondRetErroForaDoModuloDesenho; //Gera o esquema de forma aleatória PreencheAleatorioMatriz( ); CondRet = InicializaListas( ); if( CondRet != DES_CondRetOk ) return ( DES_tpCondRet ) CondRet; return DES_CondRetOk; }
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 */
PILHA_tpCondRet PILHA_CriarPilha(PILHA_tppPilha * pp) { PILHA_tppPilha p = NULL; p = (PILHA_tppPilha)malloc(sizeof(PILHA_tpPilha)); if (!p) return PILHA_CondRetFaltouMemoria; #ifdef _DEBUG CNT_CONTAR("PILHA_CriarPilha"); #endif p->topo = LIS_CriarLista(NULL); p->ExcluirValor = NULL; p->quantidade = 0; *pp = p; #ifdef _DEBUG CED_MarcarEspacoAtivo(pp); #endif return PILHA_CondRetOK; } /* Fim função: PILHA Cria Pilha */
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; }
LIS_tppLista LIS_CriarLista( void ( * ExcluirValor ) ( void * pDado ) ) { LIS_tpLista * pLista = NULL ; pLista = ( LIS_tpLista * ) malloc( sizeof( LIS_tpLista )) ; if ( pLista == NULL ) { return NULL ; } /* if */ #ifdef _DEBUG CED_MarcarEspacoAtivo(pLista); #endif LimparCabeca( pLista ) ; pLista->ExcluirValor = ExcluirValor ; return pLista ; } /* Fim função: LIS &Criar lista */
// 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 */