void TST_Assert( int Expressao , int Linha , char * NomeArq ) { char Msg[ DIM_MSG ] ; if ( Expressao ) { return ; } /* if */ sprintf( Msg , "Assertiva falhou: linha %d arquivo: %s" , Linha , NomeArq ) ; TST_ExibirPrefixo( "\n " , "************************************\n" ) ; TST_NotificarFalha( Msg ) ; TST_ExibirPrefixo( "\n " , "Assertiva Assertiva Assertiva\n" ) ; if ( pArqLog != stdout ) { fclose( pArqLog ) ; pArqLog = stdout ; TST_ExibirPrefixo( "\n " , "************************************\n" ) ; TST_NotificarFalha( Msg ) ; TST_ExibirPrefixo( "\n " , "Assertiva Assertiva Assertiva\n" ) ; } /* if */ exit( 4 ) ; } /* Fim função: TSTG &Assertiva controlada */
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 */
TST_tpCondRet LER_InterpretarComandos( char * ComandoTeste ) { char Parm[ LER_DIM_NOME ] ; int tamParm ; #ifdef _DEBUG TST_ASSERT( Inicializado ) ; #endif /* Tratar declaração de nome */ if ( strcmp( ComandoTeste , DECLARAR_SIMBOLO_CMD ) == 0 ) { if ( ! LER_DeclararParametro( )) { return TST_NotificarFalha( "Não declarou o parâmetro." ) ; } /* if */ return TST_CondRetOK ; } /* fim ativa: Tratar declaração de nome */ /* Tratar exibição de uma declaração */ else if ( strcmp( ComandoTeste , EXIBIR_SIMBOLO_CMD ) == 0 ) { LER_PularComando( ) ; if ( ! LER_LerParmNome( Parm , &tamParm , LER_DIM_NOME )) { return TST_CondRetParm ; } /* if */ LER_ExibirParametro( Parm ) ; return TST_CondRetOK ; } /* fim ativa: Tratar exibição de uma declaração */ /* Tratar comando não é para LER */ return TST_CondRetNaoExecutou ; } /* Fim função: LER &Interpretar comandos de teste */
TST_tpCondRet TBS_ValidarTabela( TBS_tppTabela pTabela ) { unsigned inxHash ; tpLista * pElem ; #ifdef _DEBUG TST_ASSERT( pTabela != NULL ) ; #endif /* Validar existência de dados da cabeça */ if ( pTabela->tamVtHash <= 1 ) { return TST_NotificarFalha( "Tamanho incorreto do vetor de randomização." ) ; } /* if */ if ( pTabela->pVtHash == NULL ) { return TST_NotificarFalha( "Falta vetor de randomização." ) ; } /* if */ if ( pTabela->ObterSimbolo == NULL ) { return TST_NotificarFalha( "Falta função obter simbolo." ) ; } /* if */ /* Validar listas de colisão */ for ( inxHash = 0 ; inxHash < pTabela->tamVtHash ; inxHash ++ ) { /* Validar toda a lista de colisão */ pElem = pTabela->pVtHash[ inxHash ] ; while ( pElem != NULL ) { /* Validar elemento da lista de colisão */ if ( pElem->pDado == NULL ) { return TST_NotificarFalha( "Faltou dado em elemento de lista." ) ; } /* if */ if ( Hash( pTabela->ObterSimbolo( pElem->pDado ) , pTabela->tamVtHash ) != inxHash ) { return TST_NotificarFalha( "Índice has de elemento está incorreto." ) ; } /* if */ if ( pElem->pAnt != NULL ) { if ( pElem->pAnt->pProx != pElem ) { return TST_NotificarFalha( "Erro de encadeamento à esquerda em elemento de lista." ) ; } /* if */ } else { if ( pElem != pTabela->pVtHash[ inxHash ] ) { return TST_NotificarFalha( "Erro de encadeamento origem em elemento de lista." ) ; } /* if */ } /* if */ if ( pElem->pProx != NULL ) { if ( pElem->pProx->pAnt != pElem ) { return TST_NotificarFalha( "Erro de encadeamento à direita em elemento de lista." ) ; } /* if */ } /* if */ pElem = pElem->pProx ; } /* fim repete: Validar toda a lista de colisão */ } /* fim repete: Validar listas de colisão */ return TST_CondRetOK ; } /* Fim função: TBS &Validar tabela de símbolos */
TST_tpCondRet ICNT_EfetuarComadoContagem( char * ComandoTeste ) { char NomeArquivo[ DIM_NOME_ARQ ] ; char NomeContador[ DIM_NOME_CONTADOR ] ; int numLidos , IntEsp , IntObtido ; CNT_tpCondRet CondRetEsp , CondRetEh ; /* Tratar CNT &Inicializar contadores */ if ( strcmp( ComandoTeste , INICIALIZAR_CONTADORES_CMD ) == 0 ) { /* CNT_tpCondRet CNT_InicializarContadores( FILE * pArqLog , char * NomeArquivo ) */ CondRetEsp = CNT_CondRetOK ; numLidos = LER_LerParametros( "si" , NomeArquivo , &CondRetEsp ) ; if ( numLidos < 1 ) { CondRetEsp = CNT_CondRetErro ; } /* if */ if ( ( NomeArquivo[ 0 ] == 0 ) || ( numLidos < 1 )) { CondRetEh = CNT_InicializarContadores( NULL ) ; } else { CondRetEh = CNT_InicializarContadores( NomeArquivo ) ; } /* if */ return TST_CompararInt( CondRetEsp , CondRetEh , "Condição de retorno errada." ) ; } /* fim ativa: Tratar CNT &Inicializar contadores */ /* Tratar CNT &Terminar contadores */ else if ( strcmp( ComandoTeste , TERMINAR_CONTADORES_CMD ) == 0 ) { /* CNT_tpCondRet CNT_TerminarContadores( ) */ CondRetEsp = CNT_CondRetOK ; numLidos = LER_LerParametros( "i" , &CondRetEsp ) ; return TST_CompararInt( CondRetEsp , CNT_TerminarContadores( ) , CondRetErrada ) ; } /* fim ativa: Tratar CNT &Terminar contadores */ /* Tratar CNT &Registrar arquivo acumulador */ if ( strcmp( ComandoTeste , REGISTRAR_ACUMULADOR_CMD ) == 0 ) { /* void CNT_RegistrarAcumulador( char * NomeArquivo ) ; */ numLidos = LER_LerParametros( "s" , NomeArquivo ) ; if ( numLidos != 1 ) { return TST_CondRetParm ; } /* if */ if ( NomeArquivo[ 0 ] == 0 ) { CNT_RegistrarAcumulador( NULL ) ; } else { CNT_RegistrarAcumulador( NomeArquivo ) ; } /* if */ return TST_CondRetOK ; } /* fim ativa: Tratar CNT &Registrar arquivo acumulador */ /* Tratar CNT &Ler arquivo de definição de contadores */ else if ( strcmp( ComandoTeste , LER_CONTADORES_CMD ) == 0 ) { /* int CNT_LerContadores( char * NomeArquivoDefinicao ) */ IntEsp = 0 ; numLidos = LER_LerParametros( "si" , NomeArquivo , &IntEsp ) ; if ( ( numLidos < 1 ) || ( IntEsp < 0 )) { return TST_CondRetParm ; } /* if */ return TST_CompararInt( IntEsp , CNT_LerContadores( NomeArquivo ) , "Número de erros de leitura errado." ) ; } /* fim ativa: Tratar CNT &Ler arquivo de definição de contadores */ /* Tratar CNT &Gravar arquivo de contagem acumulada */ else if ( strcmp( ComandoTeste , GRAVAR_CONTADORES_CMD ) == 0 ) { /* int CNT_GravarContadores( char * NomeArquivo ) */ IntEsp = 0 ; numLidos = LER_LerParametros( "si" , NomeArquivo , &IntEsp ) ; if ( ( numLidos < 1 ) || ( IntEsp < 0 )) { return TST_CondRetParm ; } /* if */ return TST_CompararInt( IntEsp , CNT_GravarContadores( NomeArquivo ) , "Número de erros de gravação errado." ) ; } /* fim ativa: Tratar CNT &Gravar arquivo de contagem acumulada */ /* Tratar CNT &Zerar todos contadores */ else if ( strcmp( ComandoTeste , ZERAR_CONTADORES_CMD ) == 0 ) { /* CNT_tpCondRet CNT_ZerarContadores( ) */ CondRetEsp = CNT_CondRetOK ; numLidos = LER_LerParametros( "i" , &CondRetEsp ) ; return TST_CompararInt( CondRetEsp , CNT_ZerarContadores( ) , CondRetErrada ) ; } /* fim ativa: Tratar CNT &Zerar todos contadores */ /* Tratar CNT &Zerar contador dado */ else if ( strcmp( ComandoTeste , ZERAR_CONTADOR_DADO_CMD ) == 0 ) { /* CNT_tpCondRet CNT_ZerarContador( char * NomeContador ) */ CondRetEsp = CNT_CondRetOK ; numLidos = LER_LerParametros( "si" , NomeContador , &CondRetEsp ) ; if ( numLidos < 1 ) { return TST_CondRetParm ; } /* if */ return TST_CompararInt( CondRetEsp , CNT_ZerarContador( NomeContador ) , CondRetErrada ) ; } /* fim ativa: Tratar CNT &Zerar contador dado */ /* Tratar CNT &Iniciar a contagem */ else if ( strcmp( ComandoTeste , INICIAR_CONTAGEM_CMD ) == 0 ) { /* void CNT_IniciarContagem( ) */ CNT_IniciarContagem( ) ; return TST_CondRetOK ; } /* fim ativa: Tratar CNT &Iniciar a contagem */ /* Tratar CNT &Parar contagem */ else if ( strcmp( ComandoTeste , PARAR_CONTAGEM_CMD ) == 0 ) { /* void CNT_PararContagem( ) */ CNT_PararContagem( ) ; return TST_CondRetOK ; } /* fim ativa: Tratar CNT &Parar contagem */ /* Tratar CNT &Obter valor de contagem */ else if ( strcmp( ComandoTeste , OBTER_CONTAGEM_CMD ) == 0 ) { /* long CNT_ObterContagem( char * NomeContador ) */ numLidos = LER_LerParametros( "si" , NomeContador , &IntEsp ) ; if ( numLidos != 2 ) { return TST_CondRetParm ; } /* if */ return TST_CompararInt( IntEsp , ( int ) CNT_ObterContagem( NomeContador ) , "Valor de contagem errado." ) ; } /* fim ativa: Tratar CNT &Obter valor de contagem */ /* Tratar Exibir valor de contagem */ else if ( strcmp( ComandoTeste , EXIBIR_CONTAGEM_CMD ) == 0 ) { /* long CNT_ObterContagem( char * NomeContador ) */ numLidos = LER_LerParametros( "s" , NomeContador ) ; if ( numLidos != 1 ) { return TST_CondRetParm ; } /* if */ IntObtido = ( int ) CNT_ObterContagem( NomeContador ) ; if ( IntObtido == CNT_CondRetNaoContador ) { TST_NotificarFalha( "Contador desconhecido: " ) ; fprintf( TST_ObterArqLog( ) , "\"%s\"" , NomeContador ) ; return TST_CondRetErro ; } /* if */ TST_ExibirPrefixo( SINALIZA_COMENTARIO , "" ) ; fprintf( TST_ObterArqLog( ) , "Valor do contador \"%s\" é: %d " , NomeContador , IntObtido ) ; return TST_CondRetOK ; } /* fim ativa: Tratar Exibir valor de contagem */ /* Tratar CNT &Obter número de contadores */ else if ( strcmp( ComandoTeste , OBTER_NUM_CONTADORES_CMD ) == 0 ) { /* int CNT_ObterNumeroContadores( ) */ numLidos = LER_LerParametros( "i" , &IntEsp ) ; if ( numLidos != 1 ) { return TST_CondRetParm ; } /* if */ return TST_CompararInt( IntEsp , CNT_ObterNumeroContadores( ) , "Número de contadores errado." ) ; } /* fim ativa: Tratar CNT &Obter número de contadores */ /* Tratar CNT &Obter total de contagem */ else if ( strcmp( ComandoTeste , OBTER_TOTAL_CONTAGEM_CMD ) == 0 ) { /* long CNT_ObterContagemTotal( ) */ numLidos = LER_LerParametros( "i" , &IntEsp ) ; if ( numLidos != 1 ) { return TST_CondRetParm ; } /* if */ return TST_CompararInt( IntEsp , ( int ) CNT_ObterContagemTotal( ) , "Contagem total errada." ) ; } /* fim ativa: Tratar CNT &Obter total de contagem */ /* Tratar CNT &Verificar contagem */ else if ( strcmp( ComandoTeste , VERIFICAR_CONTAGENS_CMD ) == 0 ) { /* int CNT_VerificarContagem( ) */ numLidos = LER_LerParametros( "i" , &IntEsp ) ; if ( numLidos != 1 ) { return TST_CondRetParm ; } /* if */ return TST_CompararInt( IntEsp , CNT_VerificarContagem( ) , "Número de contadores zero errado." ) ; } /* fim ativa: Tratar CNT &Verificar contagem */ return TST_CondRetNaoExecutou ; } /* Fim função: ICNT &Interpretar comandos de contagem */
// 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; }
TST_tpCondRet TST_EfetuarComando(char *ComandoTeste) { int numLidos = -1, CondRetEsp = -1; TST_tpCondRet CondRet; PAS_tppPasso PASSOS[3][MAX_PASSOS]; int PASSOS_SIZE[3]; PAS_CriarPasso(&PASSOS[0][0], NORTE, 2); PASSOS_SIZE[0] = 1; PAS_CriarPasso(&PASSOS[1][0], SUL, 2); PAS_CriarPasso(&PASSOS[1][1], ESTE, 5); PASSOS_SIZE[1] = 2; PAS_CriarPasso(&PASSOS[2][0], OESTE, 2); PAS_CriarPasso(&PASSOS[2][1], NOROESTE, 1); PAS_CriarPasso(&PASSOS[2][2], ESTE, 0); PASSOS_SIZE[2] = 3; /*Testar Ler tipo de movimento*/ if (strcmp (ComandoTeste, LER_TIPO_MOVIMENTO_CMD) == 0) { char *tipoStr; int tipoEsperado; MPEC_tpTipoMovimento tipoObtido; MEM_Alloc(sizeof(tipoStr)*MAX_TIPO_STR, (void **) &tipoStr); numLidos = LER_LerParametros("sii", tipoStr, &tipoEsperado, &CondRetEsp); if (numLidos != 3) { return TST_CondRetParm; } CondRet = ISP_LerTipoMovimento(tipoStr, &tipoObtido); if(CondRet == ISP_CondRetOK) { TST_CompararInt(tipoEsperado, (int) tipoObtido, "Não foi obtido o tipo esperado."); } return CondRet; } /*Testar Ler passos*/ if (strcmp(ComandoTeste, LER_PASSOS_CMD) == 0) { char *passosStr; int iPassosEsperado; LIS_tppLista pPassosEsperado; LIS_tppLista pPassosObtido; MEM_Alloc(sizeof(passosStr)*MAX_PASSOS_STR, (void **) &passosStr); numLidos = LER_LerParametros("sii", passosStr, &iPassosEsperado, &CondRetEsp); if (numLidos != 3) { return TST_CondRetParm; } pPassosEsperado = CriarListaPassos(PASSOS[iPassosEsperado], PASSOS_SIZE[iPassosEsperado]); CondRet = ISP_LerPassos(passosStr, &pPassosObtido); if (CondRet == ISP_CondRetOK) { if (!ListaDePassosSaoIguais(pPassosEsperado, pPassosObtido)) { TST_NotificarFalha("A lista de passos obtida não é igual à esperada"); return TST_CondRetErro; } } return CondRet; } /* Finalizar o teste */ else if (strcmp(ComandoTeste, FIM_CMD) == 0) { MEM_LiberarTodaMemoriaAlocada(); return TST_CondRetOK; } return TST_CondRetNaoConhec; }
TST_tpCondRet TST_EfetuarComando(char *ComandoTeste) { int numLidos = -1, CondRetEsp = -1; TST_tpCondRet CondRet; /*Testar CriarGrafo */ if (strcmp (ComandoTeste, CRIAR_GRAFO_CMD) == 0) { numLidos = LER_LerParametros("i", &CondRetEsp); if (numLidos != 1) { return TST_CondRetParm; } CondRet = GRA_CriarGrafo(&pGrafo, DestruirValor); if(CondRet == GRA_CondRetOK) { CondRet = TST_CompararPonteiroNulo(1, pGrafo, "Erro em ponteiro de nova lista."); return CondRet; } return TST_CondRetErro; } /*Testar Destruir grafo */ else if (strcmp(ComandoTeste, DESTRUIR_GRAFO_CMD) == 0) { numLidos = LER_LerParametros("i", &CondRetEsp); if (numLidos != 1) { return TST_CondRetParm; } CondRet = GRA_DestruirGrafo(&pGrafo); return TST_CompararInt(CondRetEsp, CondRet, "Erro ao destruir grafo"); } /*Testar inserir vertice */ else if (strcmp(ComandoTeste, INS_VERT_CMD) == 0) { char *nome = AlocarEspacoParaNome(); char *pDado = AlocarEspacoParaNome(); numLidos = LER_LerParametros("ssi", nome, pDado, &CondRetEsp); if (numLidos != 3) { return TST_CondRetParm; } CondRet = GRA_InserirVertice(pGrafo, nome, pDado); return TST_CompararInt(CondRetEsp, CondRet, "Condicao de retorno errada ao inserir vértice."); } /*Testar inserir aresta */ else if (strcmp(ComandoTeste, INS_ARESTA_CMD) == 0) { char *nomeAresta = AlocarEspacoParaNome(); char *nomeVerticeOrig = AlocarEspacoParaNome(); char *nomeVerticeDest = AlocarEspacoParaNome(); numLidos = LER_LerParametros("sssi", nomeAresta, nomeVerticeOrig, nomeVerticeDest, &CondRetEsp); if (numLidos != 4) { return TST_CondRetParm; } CondRet = GRA_InserirAresta(pGrafo, nomeAresta, nomeVerticeOrig, nomeVerticeDest); MEM_Free(nomeVerticeOrig); MEM_Free(nomeVerticeDest); return TST_CompararInt(CondRetEsp, CondRet, "Condicao de retorno errada ao inserir aresta."); } /*Testar obter valor do vértice corrente */ else if (strcmp(ComandoTeste, OBTER_VALOR_CMD) == 0) { char *pDadoEsperado = AlocarEspacoParaNome(); char *pDadoObtido; numLidos = LER_LerParametros("si", pDadoEsperado, &CondRetEsp); if (numLidos != 2) { MEM_Free(pDadoEsperado); return TST_CondRetParm; } if (strcmp(pDadoEsperado, SIMBOLO_PARA_NULL) == 0) { pDadoEsperado = NULL; } CondRet = GRA_ObterValorCorrente(pGrafo, (void**) &pDadoObtido); if (CondRetEsp == TST_CondRetOK) { CondRet = TST_CompararString(pDadoEsperado, pDadoObtido, "Valor do elemento errado."); MEM_Free(pDadoEsperado); return CondRet; } else { MEM_Free(pDadoEsperado); if (pDadoObtido != NULL) { return TST_NotificarFalha("Não foi obtido null como conteudo ao ocorrer um erro."); } return TST_CompararInt(CondRetEsp, CondRet, "Não ocorreu o erro esperado na obtenção do conteudo."); } } /*Testar alterar valor do vértice corrente */ else if (strcmp(ComandoTeste, ALTER_VALOR_CMD) == 0) { char *pNovoValor = AlocarEspacoParaNome(); char *pAntigoValor; numLidos = LER_LerParametros("si", pNovoValor, &CondRetEsp); if (numLidos != 2) { return TST_CondRetParm; } GRA_ObterValorCorrente(pGrafo, (void**) &pAntigoValor); MEM_Free(pAntigoValor); CondRet = GRA_AlterarValorCorrente(pGrafo, pNovoValor); return TST_CompararInt(CondRetEsp, CondRet, "Ocorreu um erro ao alterar o valor."); } /*Testar tornar corrente uma origem */ else if (strcmp(ComandoTeste, TORNAR_ORIGEM_CMD) == 0) { numLidos = LER_LerParametros("i", &CondRetEsp); if (numLidos != 1) { return TST_CondRetParm; } CondRet = GRA_TornarCorrenteUmaOrigem(pGrafo); return TST_CompararInt(CondRetEsp, CondRet, "Ocorreu um erro ao tornar o corrente uma origem."); } /*Testar tornar corrente uma origem */ else if (strcmp(ComandoTeste, DEIXAR_ORIGEM_CMD) == 0) { numLidos = LER_LerParametros("i", &CondRetEsp); if (numLidos != 1) { return TST_CondRetParm; } CondRet = GRA_DeixarDeSerOrigem(pGrafo); return TST_CompararInt(CondRetEsp, CondRet, "Ocorreu um erro remover uma origem."); } /*Testar seguir pela aresta */ else if (strcmp(ComandoTeste, IR_ARESTA_CMD) == 0) { char *nomeDaAresta = AlocarEspacoParaNome(); numLidos = LER_LerParametros("si", nomeDaAresta, &CondRetEsp); if (numLidos != 2) { return TST_CondRetParm; } CondRet = GRA_SeguirPelaAresta(pGrafo, nomeDaAresta); MEM_Free(nomeDaAresta); return TST_CompararInt(CondRetEsp, CondRet, "Ocorreu um erro ao ir para vértice adjacente."); } /*Testar ir vertice adjacente */ else if (strcmp(ComandoTeste, IR_VERTICE_CMD) == 0) { char *nomeVertice = AlocarEspacoParaNome(); numLidos = LER_LerParametros("si", nomeVertice, &CondRetEsp); if (numLidos != 2) { return TST_CondRetParm; } CondRet = GRA_IrParaVerticeAdjacente(pGrafo, nomeVertice); MEM_Free(nomeVertice); return TST_CompararInt(CondRetEsp, CondRet, "Ocorreu um erro ao ir para vértice adjacente."); } /*Testar ir para origem */ else if (strcmp(ComandoTeste, IR_ORIGEM_CMD) == 0) { char *nomeVertice = AlocarEspacoParaNome(); numLidos = LER_LerParametros("si", nomeVertice, &CondRetEsp); if (numLidos != 2) { return TST_CondRetParm; } CondRet = GRA_IrParaAOrigem(pGrafo, nomeVertice); MEM_Free(nomeVertice); return TST_CompararInt(CondRetEsp, CondRet, "Ocorreu um erro ao ir para origem."); } /*Testar ir destruir aresta adjacente */ else if (strcmp(ComandoTeste, DESTRUIR_ARESTA_CMD) == 0) { char *nomeAresta = AlocarEspacoParaNome(); numLidos = LER_LerParametros("si", nomeAresta, &CondRetEsp); if (numLidos != 2) { return TST_CondRetParm; } CondRet = GRA_DestruirArestaAdjacente(pGrafo, nomeAresta); MEM_Free(nomeAresta); return TST_CompararInt(CondRetEsp, CondRet, "Ocorreu um erro ao destruir aresta adjacente."); } /*Testar ir destruir aresta adjacente */ else if (strcmp(ComandoTeste, DESTRUIR_VERT_CMD) == 0) { numLidos = LER_LerParametros("i", &CondRetEsp); if (numLidos != 1) { return TST_CondRetParm; } CondRet = GRA_DestruirVerticeCorrente(pGrafo); return TST_CompararInt(CondRetEsp, CondRet, "Ocorreu um erro ao destruir vertice corrente."); } /* Finalizar o teste */ else if (strcmp(ComandoTeste, FIM_CMD) == 0) { MEM_LiberarTodaMemoriaAlocada(); return TST_CondRetOK; } return TST_CondRetNaoConhec; }
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 */