diff --git a/BAR.c b/BAR.c index 4195e08..71f1cf7 100644 --- a/BAR.c +++ b/BAR.c @@ -21,13 +21,14 @@ #include #include #include -#include "LISTA.h" -#include "PECA.h" + + #define BAR_OWN #include "BAR.h" +#include "LISTA.H" +#include "PECA.h" #undef BAR_OWN - /*********************************************************************** * * $TC Tipo de dados: BAR Descritor da BAR @@ -101,13 +102,17 @@ BAR_tpCondRet BAR_AdicionarPeca(BAR_tppCapturadas pBAR) BAR_tpCondRet BAR_RemoverPeca(BAR_tppCapturadas pBAR) { + pBAR->tamanho--; if(LIS_ExcluirElemento(pBAR->ListaCapturadas) != LIS_CondRetOK) { printf("Erro ao excluir peca da lsita (BAR) \n"); return BAR_CondRetErro; } +<<<<<<< HEAD +======= pBAR->tamanho--; +>>>>>>> refs/remotes/Felipe-Visgou/master return BAR_CondRetOK; } @@ -123,8 +128,8 @@ BAR_tpCondRet BAR_ObterTamanhoBar(BAR_tppCapturadas pBAR, int *tam) *tam = pBAR->tamanho; - if(*tam == 0) - return BAR_CondRetVazia; + //if(*tam == 0) + //return BAR_CondRetVazia; return BAR_CondRetOK; } @@ -154,5 +159,17 @@ BAR_tpCondRet BAR_ObterCorBar(BAR_tppCapturadas pBAR, char *cor) } return BAR_CondRetOK; }*/ -/******** Fim do Módulo de Implementação: BAR Lista de Peças Capturadas *************/ +/*************************************************************************** +* +* Função: TAB &Destruir BAR +* ****/ + +BAR_tpCondRet Bar_DestruirBar(BAR_tppCapturadas pBAR) +{ + LIS_DestruirLista(pBAR->ListaCapturadas); + free(pBAR); + return BAR_CondRetOK; +} + +/******** Fim do Módulo de Implementação: BAR Lista de Peças Capturadas *************/ diff --git a/BAR.h b/BAR.h index 4e14c73..b24f7ff 100644 --- a/BAR.h +++ b/BAR.h @@ -161,6 +161,23 @@ typedef struct BAR_tagCapturadas * BAR_tppCapturadas ; BAR_tpCondRet BAR_ObterCorBar(BAR_tppCapturadas pBAR, char *cor) ; +/*************************************************************************** +* +* Função: TAB &Destruir BAR +* +* $ED Descrição da função +* Destroi a lista BAR. +* +* $EP Parâmetros +* PBar - A BAR que se destruir +* +* $FV Valor retornado +* BAR_CondRetOk +* BAR_CondRetErro +* ****/ + + BAR_tpCondRet Bar_DestruirBar(BAR_tppCapturadas pBAR); + /********************************************************************/ #undef BAR_EXT diff --git a/MODULO BAR/ArcaboucoTeste.lib b/MODULO BAR/ArcaboucoTeste.lib new file mode 100644 index 0000000..41ba199 Binary files /dev/null and b/MODULO BAR/ArcaboucoTeste.lib differ diff --git a/MODULO BAR/BAR.c b/MODULO BAR/BAR.c new file mode 100644 index 0000000..74550fa --- /dev/null +++ b/MODULO BAR/BAR.c @@ -0,0 +1,170 @@ +/*************************************************************************** +* $MCI Módulo de implementação: BAR Peças Capturadas +* +* Arquivo gerado: BAR.c +* Letras identificadoras: BAR +* +* Nome da base de software: Arcabouço para a automação de testes de programas redigidos em C +* +* Projeto: INF 1301 / 1628 Automatização dos testes de módulos C +* Gestor: LES/DI/PUC-Rio +* Autores: fvc + tbm + db +* +* $HA Histórico de evolução: +* Versão Autor Data Observações + 1.0 fvc 18/10 Começo do Desenvolvimento +* +***************************************************************************/ + +#include +#include +#include + + +#define BAR_OWN +#include "BAR.h" +#include "LISTA.H" +#include "PECA.h" +#undef BAR_OWN + +/*********************************************************************** +* +* $TC Tipo de dados: BAR Descritor da BAR +* +* +***********************************************************************/ + +typedef struct BAR_tagCapturadas { + + LIS_tppLista ListaCapturadas; + /* Lista de Peças Capturadas*/ + + char cor; + /* A cor das peças do BAR */ + + int tamanho ; + /* Número de elementos no BAR*/ + +} BAR_tpCapturadas ; + +/***** Código das funções exportadas pelo módulo *****/ + +/*************************************************************************** +* +* Função: TAB &Criar BAR +* ****/ + +BAR_tpCondRet BAR_CriarBAR(BAR_tppCapturadas *pBAR, char cor, void ( * ExcluirValor ) ( void * pDado ) ) +{ + + *pBAR = (BAR_tppCapturadas)malloc(sizeof(BAR_tpCapturadas)); + + if(*pBAR == NULL) + return BAR_CondRetFaltouMemoria; + + (*pBAR)->ListaCapturadas = LIS_CriarLista(ExcluirValor); + (*pBAR)->cor = cor; + (*pBAR)->tamanho = 0; + + return BAR_CondRetOK; +} + +/*************************************************************************** +* +* Função: TAB &Adicionar Peça +* ****/ + +BAR_tpCondRet BAR_AdicionarPeca(BAR_tppCapturadas pBAR) +{ + char cor = pBAR->cor; + tppPeca newPeca; + if(Pec_CriarPeca(&newPeca, cor) != Pec_CondRetOK) + { + printf("Erro ao criar peca (BAR) \n"); + return BAR_CondRetErro; + } + if(LIS_InserirElementoApos(pBAR->ListaCapturadas, newPeca) != LIS_CondRetOK) + { + printf("Erro ao inserir peça na lista (BAR) \n"); + return BAR_CondRetErro; + } + pBAR->tamanho++; + + return BAR_CondRetOK; +} + +/*************************************************************************** +* +* Função: TAB &RemoverPeça +* ****/ + +BAR_tpCondRet BAR_RemoverPeca(BAR_tppCapturadas pBAR) +{ + pBAR->tamanho--; + if(LIS_ExcluirElemento(pBAR->ListaCapturadas) != LIS_CondRetOK) + { + printf("Erro ao excluir peca da lsita (BAR) \n"); + return BAR_CondRetErro; + } + return BAR_CondRetOK; +} + +/*************************************************************************** +* +* Função: TAB &Obter Tamanho BAR +* ****/ + +BAR_tpCondRet BAR_ObterTamanhoBar(BAR_tppCapturadas pBAR, int *tam) +{ + if(tam == NULL) + return BAR_CondRetErro; + + *tam = pBAR->tamanho; + + //if(*tam == 0) + //return BAR_CondRetVazia; + + return BAR_CondRetOK; +} + +/*************************************************************************** +* +* Função: TAB &Obter cor BAR +* ****/ + +BAR_tpCondRet BAR_ObterCorBar(BAR_tppCapturadas pBAR, char *cor) +{ + if(cor == NULL) + return BAR_CondRetErro; + + *cor = pBAR->cor; + + return BAR_CondRetOK; +} + +/*BAR_tpCondRet BAR_ObterListaBAR(BAR_tppCapturadas pBar, LIS_tppLista *pLista) +{ + *pLista = pBar->ListaCapturadas; + if(pLista == NULL || *pLista == NULL) + { + printf("Ponterio para bar eh nulo (BAR) \n"); + return BAR_CondRetErro; + } + return BAR_CondRetOK; +}*/ + +/*************************************************************************** +* +* Função: TAB &Destruir BAR +* ****/ + +BAR_tpCondRet Bar_DestruirBar(BAR_tppCapturadas pBAR) +{ + LIS_DestruirLista(pBAR->ListaCapturadas); + free(pBAR); + return BAR_CondRetOK; +} + +/******** Fim do Módulo de Implementação: BAR Lista de Peças Capturadas *************/ \ No newline at end of file diff --git a/MODULO BAR/BAR.h b/MODULO BAR/BAR.h new file mode 100644 index 0000000..b24f7ff --- /dev/null +++ b/MODULO BAR/BAR.h @@ -0,0 +1,188 @@ +#if ! defined( BAR_ ) +#define BAR_ +/*************************************************************************** +* +* $MCD Módulo de definição: BAR Lista de Peças Capturadas +* +* Arquivo gerado: BAR.h +* Letras identificadoras: BAR +* +* Nome da base de software: Arcabouço para a automação de testes de programas redigidos em C +* +* Projeto: INF 1301 / 1628 Automatização dos testes de módulos C +* Gestor: LES/DI/PUC-Rio +* Autores: fvc + tbm + db +* +* $HA Histórico de evolução: +* Versão Autor Data Observações +* 1.0 fvc 18/10 Começo da implementação +* +* $ED Descrição do módulo +* Implementa uma lista de peças do tabuleiro gamão. +* +***************************************************************************/ + +#if defined( BAR_OWN ) + #define BAR_EXT +#else + #define BAR extern +#endif + +/***** Declarações exportadas pelo módulo *****/ + +/* Tipo referência para uma lista */ + +typedef struct BAR_tagCapturadas * BAR_tppCapturadas ; + + +/*********************************************************************** +* +* $TC Tipo de dados: BAR Condições de retorno +* +* +* $ED Descrição do tipo +* Condições de retorno das funções da lista +* +***********************************************************************/ + + typedef enum { + + BAR_CondRetOK , + /* Concluiu corretamente */ + + BAR_CondRetVazia , + /* BAR não contém elementos */ + + BAR_CondRetErro, + /* Não concluiu corretamente */ + + BAR_CondRetFaltouMemoria + /* Faltou memória ao tentar criar a estrutura*/ + + } BAR_tpCondRet ; + +/*********************************************************************** +* +* $FC Função: BAR &Criar estrutura de peças capturadas +* +* $ED Descrição da função +* Cria uma estrutura para as peças capturadas do jogo de gamão +* +* $EP Parâmetros +* pBAR - Ponteiro da estrutura de peças capturadas passada por referência +* ExcluirValor - ponteiro para a função que processa a +* exclusão do valor referenciado pelo elemento +* a ser excluído. +* Ver descrição do módulo. +* +* $FV Valor retornado +* BAR_CondRetOk +* BAR_CondRetFaltouMemoria +* +***********************************************************************/ + + BAR_tpCondRet BAR_CriarBAR(BAR_tppCapturadas *pBAR, char cor, + void ( * ExcluirValor ) ( void * pDado ) ) ; + +/*********************************************************************** +* +* $FC Função: BAR Adicionar uma peça ao BAR +* +* $ED Descrição da função +* Adiciona uma peça à BAR +* +* $EP Parâmetros +* PBar - A BAR que será adicionada a peça + +* $FV Valor retornado +* BAR_CondRetOk +* BAR_CondRetErro +* +***********************************************************************/ + + BAR_tpCondRet BAR_AdicionarPeca(BAR_tppCapturadas pBAR) ; + +/*********************************************************************** +* +* $FC Função: BAR Remover uma peça ao BAR +* +* $ED Descrição da função +* Remover uma peça à BAR +* +* $EP Parâmetros +* PBar - A BAR que será removida a peça + +* $FV Valor retornado +* BAR_CondRetOk +* BAR_CondRetErro +* +***********************************************************************/ + + BAR_tpCondRet BAR_RemoverPeca(BAR_tppCapturadas pBAR) ; + +/*********************************************************************** +* +* $FC Função: BAR Obter tamanho da BAR +* +* $ED Descrição da função +* Obtem a quantidade de peças na BAR +* +* $EP Parâmetros +* PBar - A BAR que se deseja saber o tamanho +* *tam - Ponteiro de referencia para o tamanho da BAR + +* $FV Valor retornado +* BAR_CondRetOk +* BAR_CondRetVazia +* BAR_CondRetErro +* +***********************************************************************/ + + BAR_tpCondRet BAR_ObterTamanhoBar(BAR_tppCapturadas pBAR, int *tam) ; + +/*********************************************************************** +* +* $FC Função: BAR Obter Cor da BAR +* +* $ED Descrição da função +* Obtem a cor das peças da BAR +* +* $EP Parâmetros +* PBar - A BAR que se deseja saber a cor + *cor - Cor esperada + +* $FV Valor retornado +* BAR_CondRetOk +* BAR_CondRetErro +* +***********************************************************************/ + + BAR_tpCondRet BAR_ObterCorBar(BAR_tppCapturadas pBAR, char *cor) ; + +/*************************************************************************** +* +* Função: TAB &Destruir BAR +* +* $ED Descrição da função +* Destroi a lista BAR. +* +* $EP Parâmetros +* PBar - A BAR que se destruir +* +* $FV Valor retornado +* BAR_CondRetOk +* BAR_CondRetErro +* ****/ + + BAR_tpCondRet Bar_DestruirBar(BAR_tppCapturadas pBAR); + + /********************************************************************/ + +#undef BAR_EXT + +/********** Fim do módulo de definição: BAR Lista de Peças Capturadas **********/ + +#else +#endif diff --git a/MODULO BAR/GENERICO.H b/MODULO BAR/GENERICO.H new file mode 100644 index 0000000..c9d2692 --- /dev/null +++ b/MODULO BAR/GENERICO.H @@ -0,0 +1,588 @@ +#if ! defined( GENERICO_ ) +#define GENERICO_ +/*************************************************************************** +* +* $MCD Módulo de definição: TSTG Controlador de teste genérico +* +* Arquivo gerado: GENERICO.h +* Letras identificadoras: TST +* +* Nome da base de software: Arcabouço para a automação de testes de programas redigidos em C +* Arquivo da base de software: C:\AUTOTEST\PROJETOS\ARCABOUC.BSW +* +* Projeto: INF 1301 / 1628 Automatização dos testes de módulos C +* Gestor: LES/DI/PUC-Rio +* Autores: avs +* +* $HA Histórico de evolução: +* Versão Autor Data Observações +* 4 avs 01/fev/2006 criar linguagem script simbólica +* 3 avs 08/dez/2004 uniformização dos exemplos +* 2 avs 07/jul/2003 unificação de todos os módulos em um só projeto +* 1 avs 16/abr/2003 início desenvolvimento +* +* $ED Descrição do módulo +* O módulo de teste genérico contém um conjunto de funções de +* coordenação, apoio e controle da execução de testes de módulos +* quaisquer. +* +* Embora na prática a função de teste específica seja uma extensão da +* função de teste genérica, a função de teste específica encontra-se em +* outro módulo. Desta forma as alterações necessárias para cada +* módulo a testar concentram-se exclusivamente naquele módulo. +* +* $EIU Interface com o usuário pessoa +* Os seguintes comandos genéricos estão definidos: +* +* linha em branco - faz nada +* +* // - comentário, é impresso no LOG +* +* == - título de caso de teste, o título é impresso no LOG +* +* =recuperar +* - Caso o comando imediatamente anterior ao comando +* =recuperar retorne TST_CondRetOK, obviemanete o comando +* executou corretamente, portanto o comando =recuperar +* reportará uma falha no script de teste, uma vez que não +* foi encontrada a falha esperada ao executar o comando. +* - Caso o comando antecessor retorne TST_CondRetErro, +* ou TST_CondRetParm (erro de parâmetros do comando) +* a falha reportada será desconsiderada, uma vez que +* era esperada. O comando =recuperar destina-se a +* apoiar o teste da corretude dos validadores de +* parâmetros dos comandos e das funções por eles +* ativadas. +* - caso o comando antecessor retorne outras condições, o +* comando =recuperar será tratado como falha. +* +* =bkpt - permite interagir com o depurador utilizado para +* desenvolver os módulos sob teste. O comando =bkpt +* executa um código "dummy" no qual pode ser inserido +* um "breakpoint" do depurador. Desta forma o teste pode +* prosseguir sem interrupção até o comando =bkpt. +* Para isto +* - apague ou desative todos os breakpoints do depurador +* - insira o comando =bkpt no script pouco antes do ponto +* de interrupção desejado +* - usando o depurador, estabeleça um breakpoint na linha de +* código: "Dummy = 0 ;" contida no módulo de teste +* genérico. Esta linha pode ser encontrada +* procurando por "BKPT_CMD" +* - dê partida no programa e espere até chegar ao breakpoint +* associado ao comando "dummy". Agora reative ou instale +* os breakpoints requeridos pela a sessão de depuração. +* e continue depurando +* +* =cancelar +* - termina a interpretação dos comandos de teste. +* Sempre sinaliza falha. +* +* =AceitaFalhasAcumuladas numFalhas +* - caso o contador de falhas registre numFalhas, ele será +* tornado zero. Este comando é similar a =recuperar. +* Difere deste por ser executado desde que o comando +* anterior não tenha reportado erro, tal como acontece +* com todos os comandos, exceto =recuperar. +* O comando permite recuperar falhas sinalizadas por +* módulos de apoio, tais como, leitor de parâmetros, +* contador de passagens e controle de espaço dinâmico. +* Caso o contador de número de falhas contenha um valor +* diferente de numFalhas, será reportado um erro e +* o contador é incrementado de 1. +* +* Os demais comandos são passados para as funções de teste específico. +* Primeiro para as do arcabouço, depois para a específica do módulo +* a testar. A última função de teste específico deve retornar a condição +* TST_CondRetNaoConhec caso não consiga interpretar a diretiva. +* +* $EIM Interface com outros módulos +* A primeira função do arcabouço ("framework") a ser chamada deve a +* sempre ser TST_InicializarTeste. Caso não o seja, ocorrerão erros +* de execução (assert). +* +* Após abra o arquivo de script executando a função +* TST_AbrirArquivoScript. Se for desejado gerar um log abra +* o arquivo corresponente com a função TST_AbrirArquivoLog. +* +* Depois de abrir os arquivos, execute os testes chamando a função +* TST_RealizarTeste. A função de teste genérico lerá todo o arquivo +* de script, retornando após concluir o teste. +* +* Após, termine o teste através da função TST_TerminarTeste. +* Esta função exibe as estatísticas do teste e, caso solicitado, +* acumula essas estatísticas em um arquivo acumulador (ver +* parâmetro /a do programa principal. +* +* As funções "TST_ObterXXX" podem ser utilizadas antes de fechar o +* módulo de teste para exibir o resumo do teste no módulo cliente do +* módulo de controle genérico. +* +* O programa cliente do módulo controle de teste genérico pode +* efetuar as operações acima repetidas vezes, permitindo, assim o +* teste envolvendo diversos arquivos scripts de teste. A saída +* de cada teste deve ser dirigida para um log específico, ou para +* stdout, uma vez que, ao abrir um arquivo log, o seu conteúdo será +* sempre destruído. +* +* O módulo de teste genérico também implementa diversas funções +* de comparação "TST_CompararXXX" use-as no módulo de controle de +* teste específico. Desta forma será assegurado o tratamento uniforme +* de todas as falhas possivelmente encontradas. +* +* O módulo disponibiliza ainda a função TST_ExibirPrefixo +* que gera uma linha de saída obedecendo aos padrões de interface +* estabelecidos. Sendo desejado pode-se adicionar textos à linha +* usando a funcao fprintf( TST_ObterArqLog( ) , ... ). Um exemplo da +* utilidade disso é quando se deseja imprimir informação complementar +* ao interpretar uma determinada diretiva. A função TST_ObterArqLog( ) +* retorna a referência ao arquivo log em uso no momento. +* +* Finalmente, o módulo disponibiliza a função TST_NotificarFalha +* que incrementa o contador de falhas além de emitir uma mensagem +* de erro. +* +***************************************************************************/ + +#if defined( GENERICO_OWN ) + #define GENERICO_EXT +#else + #define GENERICO_EXT extern +#endif + +/***** Declarações exportadas pelo módulo *****/ + +#include "TST_Espc.h" + + +/*********************************************************************** +* +* $FC Função: TSTG &Controlar uma sessão de teste +* +* $ED Descrição da função +* Esta função é o ponto de entrada para a realização do teste. +* Permite que se adicione o arcabouço de teste a um sistema qualquer. +* +* $EP Parâmetros +* $P NomeConstrutoParm +* $P NomeArqScriptParm - deve ser não nulo +* $P NomeArqLogParm - se for nulo, gera a saída na console +* $P NomeArqAcumParm - se não for nulo, acumula as estatísticas no +* arquivo denominado +* +* $FV Valor retornado +* 0 - se o teste ocorreu OK +* 4 - se foram observados erros de dados ou falhas nos testes +* +***********************************************************************/ + + int TST_ControlarSessaoTeste( char * NomeConstrutoParm , + char * NomeArqScriptParm , + char * NomeArqLogParm , + char * NomeArqAcumParm ) ; + + +/*********************************************************************** +* +* $FC Função: TSTG &Comparar booleano +* +* $ED Descrição da função +* Compara valor booleano esperado com valor booleano obtido, +* reportamdo uma falha caso não sejam iguais. +* Note que "!= 0" corresponde a TRUE e "== 0" corresponde a FALSE +* +* $EP Parâmetros +* ValorEsperado - é um valor fornecido como parâmetro do comando +* de teste +* ValorObtido - é o valor retornado pela função em teste +* pMensagem - mensagem explanatória da falha encontrada +* +* $FV Valor retornado +* TST_CondRetErro se o valor esperado não for consistente com o obtido +* TST_CondRetOK se os valores forem consistentes +* +***********************************************************************/ + + TST_tpCondRet TST_CompararBool( int ValorEsperado , + int ValorObtido , + char * pMensagem ) ; + + +/*********************************************************************** +* +* $FC Função: TSTG &Comparar caractere +* +* $ED Descrição da função +* Compara um caractere esperado com um caractere obtido, emitindo mensagem de +* erro caso não sejam iguais. +* +* $EP Parâmetros +* ValorEsperado - é um valor fornecido como parâmetro do comando +* de teste +* ValorObtido - é o valor retornado pela função em teste +* pMensagem - mensagem explanatória da falha encontrada +* +* $FV Valor retornado +* TST_CondRetErro se o valor esperado não for igual ao obtido +* TST_CondRetOK se os valores forem iguais +* +***********************************************************************/ + + TST_tpCondRet TST_CompararChar( char ValorEsperado , + char ValorObtido , + char * pMensagem ) ; + + +/*********************************************************************** +* +* $FC Função: TSTG &Comparar inteiro +* +* $ED Descrição da função +* Compara valor inteiro long esperado com valor inteiro obtido, +* reportamdo uma falha caso não sejam iguais. +* +* $EP Parâmetros +* ValorEsperado - é um valor fornecido como parâmetro do comando +* de teste +* ValorObtido - é o valor retornado pela função em teste +* pMensagem - mensagem explanatória da falha encontrada +* +* $FV Valor retornado +* TST_CondRetErro se o valor esperado não for igual ao obtido +* TST_CondRetOK se os valores forem iguais +* +***********************************************************************/ + + TST_tpCondRet TST_CompararInt( long ValorEsperado , + long ValorObtido , + char * pMensagem ) ; + + +/*********************************************************************** +* +* $FC Função: TSTG &Comparar flutuante +* +* $ED Descrição da função +* Compara valor flutuante esperado com valor flutuante obtido, +* reportando uma falha caso +* 1 - Tolerancia > esperado / obtido ou +* 1 + Tolerancia < esperado / obtido +* +* $EP Parâmetros +* ValorEsperado - é um valor fornecido como parâmetro do comando +* de teste +* ValorObtido - é o valor retornado pela função em teste +* Tolerância - indica os limites da relação entre esperado e obtido. +* Deve ser um valor positivo, menor do que 1. +* Use um valor do tipo 10 ** -n, no qual n é o +* número de dígitos significativos desejado. +* pMensagem - mensagem explanatória da falha encontrada +* +* $FV Valor retornado +* TST_CondRetErro se o valor obtido não estiver dentro do domínio da +* tolerância em torno do valor esperado +* TST_CondRetOK se os valores estiverem dentro da tolerância +* +***********************************************************************/ + + TST_tpCondRet TST_CompararFloat( double ValorEsperado , + double ValorObtido , + double Tolerancia , + char * pMensagem ) ; + + +/*********************************************************************** +* +* $FC Função: TSTG &Comparar string +* +* $ED Descrição da função +* Compara string esperado com string obtido, reportamdo uma falha +* caso não sejam iguais. Ambos os strings devem obedecer o +* padrão C, terminando em zero. +* +* $EP Parâmetros +* ValorEsperado - é um string fornecido como parâmetro do comando +* de teste. +* ValorObtido - é o string retornado pela função em teste +* pMensagem - mensagem explanatória da falha encontrada +* +* $FV Valor retornado +* TST_CondRetErro se o valor esperado não for igual ao obtido +* TST_CondRetOK se os valores forem iguais +* +***********************************************************************/ + + TST_tpCondRet TST_CompararString( char * ValorEsperado , + char * ValorObtido , + char * pMensagem ) ; + + +/*********************************************************************** +* +* $FC Função: TSTG &Comparar espaço +* +* $ED Descrição da função +* Compara espaços de dados, reportando uma falha caso não sejam iguais. +* Esta função pode ser utilizada para comparar qualquer coisa, +* inclusive valores do tipo "struct" +* O tipo do valor é indefinido e os valores serão exibidos em +* formato hexadecimal, caso não sejam iguais +* +* $EP Parâmetros +* ValorEsperado - ponteiro para o espaço que contém o valor esperado +* ValorObtido - ponteiro para o espaço que contém o valor obtido +* TamEspaco - tamanho do espaço a ser comparado +* pMensagem - mensagem explanatória da falha encontrada +* +* $FV Valor retornado +* TST_CondRetErro se o valor esperado não for igual ao obtido +* TST_CondRetOK se os valores forem iguais +* +***********************************************************************/ + + TST_tpCondRet TST_CompararEspaco( void * ValorEsperado , + void * ValorObtido , + int TamEspaco , + char * pMensagem ) ; + + +/*********************************************************************** +* +* $FC Função: TSTG &Comparar ponteiro +* +* $ED Descrição da função +* Compara dois ponteiros emitindo uma mensagem caso não sejam iguais +* +* $FV Valor retornado +* TST_CondRetErro se os dois ponteiros forem diferentes +* TST_CondRetOK se forem iguais +* +***********************************************************************/ + + TST_tpCondRet TST_CompararPonteiro( void * PonteiroEsperado , + void * PonteiroObtido , + char * pMensagem ) ; + + +/*********************************************************************** +* +* $FC Função: TSTG &Comparar ponteiro nulo +* +* $ED Descrição da função +* Verifica +* - quando ModoEsperado == 0 se o PonteiroObtido é nulo +* - quando ModoEsperado != 0 se o PonteiroObtido é não nulo +* +* $FV Valor retornado +* TST_CondRetErro se os dois ponteiros forem diferentes +* TST_CondRetOK se forem iguais +* +***********************************************************************/ + + TST_tpCondRet TST_CompararPonteiroNulo( int ModoEsperado , + void * PonteiroObtido , + char * pMensagem ) ; + + +/*********************************************************************** +* +* $FC Função: TSTG &Assertiva controlada +* +* $ED Descrição da função +* Esta função substitui a função assert de C. +* É utilizada no contexto do arcabouço de teste. +* Ela imprime mensagens mais visíveis tanto no log como na +* janela de comando. +* +* Recomenda-se, no entanto, utilizar a função assert de C em aplicações. +* +* $FV Valor retornado +* Termina a execução do programa com código de retorno == 4 +* +***********************************************************************/ + + #define TST_ASSERT( Expressao ) \ + TST_Assert( Expressao , __LINE__ , __FILE__ ) + + void TST_Assert( int Expressao , int Linha , char * NomeArq ) ; + + +/*********************************************************************** +* +* $FC Função: TSTG &Exibir prefixo da mensagem +* +* $ED Descrição da função +* Imprime o prefixo de mensages de falha ou de informação. +* Não incrementa o contador de falhas. +* Esta função estabelece o padrão de saída das mensagens geradas +* durante os testes. +* +* $EP Parâmetros +* $P Indicador - informa a natureza da mensagem, +* Utilize preferenciamente as constantes definidas em +* TST_ESPEC.H: +* SINALIZA_ERRO ">>>" +* SINALIZA_RECUPERA "<<<" +* SINALIZA_COMENTARIO "!!!" +* $P pMensagem - é a mensagem prefixo a ser gerada. +* +* $EIU Interface com usuário pessoa +* Podem ser acrescentadas mensagens ao prefixo. A função +* TST_ObterArqLog retorna o ponteiro para o arquivo log em uso +* (stdout ou definido pelo usuário) +* +***********************************************************************/ + + void TST_ExibirPrefixo( char * Indicador , char * pMensagem ) ; + + +/*********************************************************************** +* +* $FC Função: TSTG &Notificar falha +* +* $ED Descrição da função +* Exibe uma mensagem de falha no formato padrão do arcabouço. +* A função não exibe os valores esperado e obtido. +* +* $EP Parâmetros +* $P pMensagem - mensdagem explicativa da falha. +* +* $FV Valor retornado +* TST_CondRetErro sempre +* +***********************************************************************/ + + TST_tpCondRet TST_NotificarFalha( char * pMensagem ) ; + + +/*********************************************************************** +* +* $FC Função: TSTG &Incrementar contador de falhas +* +* $ED Descrição da função +* Esta função deve ser usada quando, por alguma razão, precisar-se +* utilizar TST_ExibirPrefixo para exibir uma mensagem de falha. +* As outras funções (comparação, TST_NotificarFalha, etc.) +* incrementam o contador automaticamente. +* +***********************************************************************/ + + void TST_ContarFalhas( ) ; + + +/*********************************************************************** +* +* $FC Função: TSTG &Obter número de casos de teste efetuados +* +* $ED Descrição da função +* Retorna o número de casos de teste lidos. +* Cada caso de teste inicia com o comando "== ". +* +***********************************************************************/ + + int TST_ObterNumCasosTeste( ) ; + + +/*********************************************************************** +* +* $FC Função: TSTG &Obter número de comandos específicos corretamente interpretados +* +* $ED Descrição da função +* Retorna o número de comandos de teste específicos lidos e +* corretamente interpretados. +* Não conta comandos que retornem não OK independentemento do motivo, +* inclusive os comandos saltados após uma falha. +* Também não conta comandos recuperar. +* +***********************************************************************/ + + int TST_ObterNumComandosExecutados( void ) ; + + +/*********************************************************************** +* +* $FC Função: TSTG &Obter número de falhas encontradas +* +* $ED Descrição da função +* Retorna o número de falhas encontrados. +* O módulo de teste específico sinaliza falhas através de +* uma condição de retorno diferente de TST_CondRetOK. +* Além de comparações em erro, são tratados como falhas: +* - comandos de teste em erro, +* - comandos de teste de um dado caso de teste ignorados (saltados) +* - erros encontrados nos instrumentos +* - erros de sintaxe dos comandos de teste +* - qualquer chamada às funções TST_NotificarFalha, ou TST_ContarFalha. +* Portanto, é possível que o número de falhas venha a ser maior do +* que o número de casos de teste existente no script. +* +***********************************************************************/ + + int TST_ObterNumFalhas( void ) ; + + +/*********************************************************************** +* +* $FC Função: TSTG &Obter origem do nome da extensão de arquivo +* +* $ED Descrição da função +* Procura o início do nome da extensão contido no nome do arquivo +* dado por parâmetro +* +* Evite o uso de nomes de arquivos com dois ou mais caracteres ".". +* Isto pode confundir no caso de se desejar a adição de algum nome +* de extensão padrão. +* +* $EP Parâmetros +* $P NomeArqParm - nome de arquivo a ser analisado +* +* $FV Valor retornado +* Ponteiro para o caractere '.' que separa a extensão. +* Será NULL caso o nome do arquivo não contenha extensão. +* +***********************************************************************/ + + char * TST_ObterInicioExtensao( char * NomeArqParm ) ; + + +/*********************************************************************** +* +* $FC Função: TSTG &Obter ponteiro para arquivo LOG +* +* $ED Descrição da função +* Retorna o ponteiro para o FILE do log em uso no momento. +* Será stdout caso não seja definido explicitamente ao chamar a funcao +* TST_ControlarSessaoTeste +* +* $FV Valor retornado +* Ponteiro válido para um arquivo de texto de saída +* +***********************************************************************/ + + FILE * TST_ObterArqLog( void ) ; + + +/*********************************************************************** +* +* $FC Função: TSTG &Exibir um espaço qualquer em formato hexadecimal e char +* +* $ED Descrição da função +* Exibe o conteúdo de um espaço de tamEspaco bytes. A saída contém +* uma coluna em hexadecimal e outra em ASCII +* São exibidos 16 bytes por linha. +* +* $EP Parâmetros +* $P tamEspaco - tamanho em bytes do espaço a exibir +* $P Ponteiro - ponteiro para o primeiro byte do espaço a exibir +* +***********************************************************************/ + + void TST_ExibirEspacoHexa( int tamEspaco , + void * Ponteiro ) ; + +#undef GENERICO_EXT + +/********** Fim do módulo de definição: TSTG Controlador de teste genérico **********/ + +#else +#endif diff --git a/MODULO BAR/LERPARM.H b/MODULO BAR/LERPARM.H new file mode 100644 index 0000000..f12cf3d --- /dev/null +++ b/MODULO BAR/LERPARM.H @@ -0,0 +1,463 @@ +#if ! defined( LerParm_ ) +#define LerParm_ +/*************************************************************************** +* +* $MCD Módulo de definição: LER Ler parâmetros de comandos +* +* Arquivo gerado: LerParm.h +* Letras identificadoras: LER +* +* Nome da base de software: Arcabouço para a automação de testes de programas redigidos em C +* Arquivo da base de software: C:\AUTOTEST\PROJETOS\ARCABOUC.BSW +* +* Projeto: INF 1301 / 1628 Automatização dos testes de módulos C +* Gestor: LES/DI/PUC-Rio +* Autores: avs +* +* $HA Histórico de evolução: +* Versão Autor Data Observações +* 4 avs 01/fev/2006 criar linguagem script simbólica +* 3 avs 08/dez/2004 uniformização dos exemplos +* 2 avs 07/jul/2003 unificação de todos os módulos em um só projeto +* 1 avs 16/abr/2003 início desenvolvimento +* +* $ED Descrição do módulo +* Provê funções para a leitura e análise léxica dos comandos de teste. +* Pressupõe-se que cada comando de teste esteja integralmente em +* uma linha. +* Cada comando de teste inicia com o caractere '=' seguido de um string +* que identifica o comando. +* Cada comando pode requerer zero ou mais parâmetros que se encontram na +* mesma linha que o comando. +* Parâmetros podem ser literis ou simbólicos. +* Os parâmetros simbólicos precisam ser declarados antes de serem +* utilizados. +* Os parâmetros têm tipo e a leitura deve respeitar esses tipos. +* +* Se for do interesse do programador, módulos de teste específico +* podem ler e processar por conta própria linhas do script. Isto +* pode ser necessário quando um módulo necessita de um grande +* número de parâmetros ou de dados especiais. +* +* $EIU Interface com o usuário pessoa +* Este módulo interpreta os comandos de teste globalmente disponíveis: +* +* =declararparm +* declara o parâmetro do definido com o valor +* pode ser um de: +* i - inteiro (long) +* f - flutuante (double) +* c - caractere +* s - string +* O valor de literal tem que estar em conformidade com o tipo +* +* =exibirdeclaracao +* exibe a declaração do parâmetro em formato "dump de memória" +* +* Literais devem obedecer às regras léxicas utilizadas pela linguagem C. +* +* Estes comandos sempre estarão disponíveis. Os demais comandos de +* teste estão impementados no módulo TESTLER específico para este módulo. +* +***************************************************************************/ + +#if defined( LerParm_OWN ) + #define LerParm_EXT +#else + #define LerParm_EXT extern +#endif + +/***** Declarações exportadas pelo módulo *****/ + +#define LER_DIM_NOME 32 +#define LER_DIM_STRING 500 +#define LER_DIM_BUFFER 250 + + +/*********************************************************************** +* +* $TC Tipo de dados: LER Condições de retorno +* +* +***********************************************************************/ + + typedef enum { + + LER_CondRetOK , + /* Ler retorno OK */ + + LER_CondRetNaoAbriu + /* Ler não abriu arquivo */ + + } LER_tpCondRet ; + +/***** Dados exportados pelo módulo *****/ + + /* Estrutura de dados: *LER Dados globais públicos */ + + LerParm_EXT int LER_TamBuffer ; + /* Tamanho do string contido no buffer de leitura + * + *$ED Descrição + * Contém o número total de caracteres do buffer, excluindo o zero. + * Jamais altere este valor. */ + + LerParm_EXT int LER_InxBuffer ; + /* Cursor do buffer de leitura + * + *$ED Descrição + * O cursor de leitura indexa o primeiro caractere não lido contido + * no buffer. + * O cursor é zerado sempre que uma nova linha for lida. + * O cursor é avançado ao ler um parâmetro, sendo colocado no + * primeiro caractere imediatamente após ao parâmetro lido. + * Evite acessar caracteres quando LER_InxBuffer > LER_TamBuffer */ + + LerParm_EXT char LER_Buffer[ LER_DIM_BUFFER + 1 ] ; + /* Buffer de leitura + * + *$ED Descrição + * Contém a linha corrente do script a ser processada. + * Jamais altere o valor do buffer. */ + + +/*********************************************************************** +* +* $FC Função: LER &Inicializar módulo LerParm +* +* $ED Descrição da função +* Inicializa o módulo. +* Deve ser chamada antes de iniciar a análise de comandos. +* Deve ser chamada uma única vez no início ou após terminar o módulo. +* +***********************************************************************/ + + int LER_InicializarLeitura( void ) ; + + +/*********************************************************************** +* +* $FC Função: LER &Terminar módulo LerParm +* +* $ED Descrição da função +* Fecha o arquivo de leitura e sinaliza módulo de leitura não +* inicializado. +* Após esta função somente poderá ser chamada a funçãp +* LER_InicializarLeitura +* +***********************************************************************/ + + void LER_TerminarLeitura( void ) ; + + +/*********************************************************************** +* +* $FC Função: LER &Obter nome do arquivo script +* +* $FV Valor retornado +* Retorna o ponteiro para o nome do arquivo script sendo processado. +* Deve-se tomar cuidado para não alterar este nome. +* Será NULL se nãa tem arquivo aberto ou o módulo não está inicializado. +* +***********************************************************************/ + + char * LER_ObterNomeArqScript( void ) ; + + +/*********************************************************************** +* +* $FC Função: LER &Obter número de linhas lidas até o momento +* +***********************************************************************/ + + int LER_ObterNumLinhas( void ) ; + + +/*********************************************************************** +* +* $FC Função: LER &Abrir arquivo script de teste +* +* $ED Descrição da função +* Abre o arquivo que contém o script de teste. +* A extensão default do arquivo de comandos script de teste é +* ".script" e será acrescida ao nome do arquivo caso este não +* contenha nome de extensão. +* +* $EP Parâmetros +* $P NomeArqParm - nome do arquivo contendo o script de teste +* +* $FV Valor retornado +* LER_CondRetOK - caso tenha sido possível abrir o arquivo. +* LER_CondRetNaoAbriu - caso tenha ocorrido algum erro. +* Não há discriminação do erro encontrado. +* +***********************************************************************/ + + LER_tpCondRet LER_AbrirArquivoScript( char * NomeArqParm ) ; + + +/*********************************************************************** +* +* $FC Função: LER &Ler linha script eliminando brancos ao final +* +* $ED Descrição da função +* Lê uma linha do arquivo script e elimina os caracteres branco, +* fim de linha, tabulação etc. do final da linha lida. +* +* $FV Valor retornado +* Retorna o tamanho da linha lida. +* Será: +* -1 caso tenha ocorrido fim de arquivo. +* -2 caso tenha ocorrido algum problema de leitura. +* +***********************************************************************/ + + int LER_LerLinhaScript( void ) ; + + +/*********************************************************************** +* +* $FC Função: LER &Interpretar comandos de teste +* +* $ED Descrição da função +* Interpreta os comandos de teste disponibilizados pelo módulo +* de leitura. +* +* Ver a descrição do módulo para mais detalhes +* +* $EP Parâmetros +* $P - Comando de teste a ser interpretado +* +* $FV Valor retornado +* TST_CondRetOK - caso tenha interpretado corretamente +* TST_CondRetNaoExecutou - caso o comando de teste a interpretar +* não pertença ao conjunto de LER +* TST_CondRetErro - caso o comando de teste é do conjunto de LER +* e está sintaticamente errado. +* Neste caso é gerada uma mensagem de erro no +* log. +* +***********************************************************************/ + + TST_tpCondRet LER_InterpretarComandos( char * ComandoTeste ) ; + + +/*********************************************************************** +* +* $FC Função: LER &Declarar parâmetro simbólico +* +* $EP Parâmetros +* Interpreta uma linha de comando de teste contendo uma declaração de +* nome simbólico. +* Todas as declarações têm o formato: +* =declararparm +* em que o deve estar consistente com o +* São geradas mensagens de erro no log de teste caso a declaração +* não possa ser realizada. +* +* $FV Valor retornado +* TRUE - se a declaração ocorreu +* FALSE - caso contrário +* +***********************************************************************/ + + int LER_DeclararParametro( void ) ; + + +/*********************************************************************** +* +* $FC Função: LER &Exibir declaração de símbolo +* +* $ED Descrição da função +* Exibe o Símbolo e o valor associado ao símbolo, sendo que este +* é exibido em hexadecimal. +* +***********************************************************************/ + + void LER_ExibirParametro( char * Simbolo ) ; + + +/*********************************************************************** +* +* $FC Função: LER &Ler linha de parâmetros +* +* $ED Descrição da função +* Lê um número variável de parâmetros +* +* $EP Parâmetros +* $P Tipos é um string contendo a identificação dos tipos dos parâmetros +* a serem lidos. +* $P ... Os demais parâmetros são referências (ponteiros) para os +* espaços onde deverão ser armazenados os valores lidos. +* +* Tal como em scanf deve-se tomar o cuidado de assegurar que a lista +* de referência e o string de tipos tenha o mesmo tamanho +* e que os indicadores de tipo sejam consistentes com a referência +* posicionalmente correspondentes. +* +* Ao ler um campo, primeiro procura-se ler um nome de parâmetro já +* declarado. Caso isto seja possível e o tipo esteja correto +* é "lido" o valor contido no parâmetro. +* Caso não seja possível, tenta ler um literal em acordo com o tipo +* dado. +* +* Gera mensagens de erro para parâmetros desconhecidos, sintaxe errada +* e tipo inconsistente com o solicitado no correspondente caractere no +* string Tipos. +* +* $FV Valor retornado +* Retorna o número de campos lidos até concluir ou até encontrar +* um erro. +* +***********************************************************************/ + + int LER_LerParametros( char * Tipos , ... ) ; + + +/*********************************************************************** +* +* $FC Função: LER &Ler parâmetro caractere +* +* $EP Parâmetros +* $P Parm é um ponteiro para um caractere que receberá o valor lido +* +* $FV Valor retornado +* TRUE - se leu +* FALSE - se ocorreu algum erro +* +* $FGP Tipos e Variáveis globais externas do próprio módulo +* inxBuffer - é avançado para o primeiro caractere branco imediatamente +* a seguir do caractere lido +* +* $EIU Interface com usuário pessoa +* Um caractere deve vir entre aspas simples. Valem os caracteres de controle +* \n \r \t \a \v \f \\ \' \" \? e \0 +* São geradas mensagens de erro no log +* +***********************************************************************/ + + int LER_LerParmChar( char * Parm ) ; + + +/*********************************************************************** +* +* $FC Função: LER &Ler parâmetro inteiro +* +* $EP Parâmetros +* $P Parm é um ponteiro para um int que receberá o valor lido +* +* $FV Valor retornado +* TRUE - se leu +* FALSE - se ocorreu algum erro +* +* $FGP Tipos e Variáveis globais externas do próprio módulo +* inxBuffer - é avançado para o primeiro caractere branco imediatamente +* a seguir do int lido +* +* $EIU Interface com usuário pessoa +* São geradas mensagens de erro no log +* +***********************************************************************/ + + int LER_LerParmInt( int * Parm ) ; + + +/*********************************************************************** +* +* $FC Função: LER &Ler parâmetro flutuante +* +* $EP Parâmetros +* $P Parm é um ponteiro para um double que receberá o valor lido +* +* $FV Valor retornado +* TRUE - se leu +* FALSE - se ocorreu algum erro +* +* $FGP Tipos e Variáveis globais externas do próprio módulo +* inxBuffer - é avançado para o primeiro caractere branco imediatamente +* a seguir do double lido +* +* $EIU Interface com usuário pessoa +* São válidas todas as formas de literal double aceitas pelo scanf. +* São geradas mensagens de erro no log +* +***********************************************************************/ + + int LER_LerParmDouble( double * Parm ) ; + + +/*********************************************************************** +* +* $FC Função: LER &Ler parâmetro nome +* +* $EP Parâmetros +* $P Parm é um ponteiro para um caractere que receberá o nome lido +* $P tamString é o tamanho do nome que foi lido +* $P dimString é o tamanho máximo que o nome poderá ter, já +* descontado o zero final +* +* $FV Valor retornado +* TRUE - se leu +* FALSE - se ocorreu algum erro +* +* $FGP Tipos e Variáveis globais externas do próprio módulo +* inxBuffer - é avançado para o primeiro caractere branco imediatamente +* a seguir do nome lido +* +* $EIU Interface com usuário pessoa +* São válidas as mesmas regras de nomes C. +* São geradas mensagens de erro no log +* +***********************************************************************/ + + int LER_LerParmNome( char * Parm , int * tamNome , int dimNome ) ; + + +/*********************************************************************** +* +* $FC Função: LER &Ler parâmetro string +* +* $EP Parâmetros +* $P Parm é um ponteiro para um caractere que receberá o string lido +* $P tamString é o tamanho do string que foi lido +* $P dimString é o tamanho máximo que o string poderá ter, já +* descontado o zero final +* +* $FV Valor retornado +* TRUE - se leu +* FALSE - se ocorreu algum erro +* +* $FGP Tipos e Variáveis globais externas do próprio módulo +* inxBuffer - é avançado para o primeiro caractere branco imediatamente +* a seguir do string lido +* +* $EIU Interface com usuário pessoa +* Um string deve vir entre aspas duplas. +* Um string pode conter caracteres de controle +* \n \r \t \a \v \f \\ \' \" \? e \0 +* +* São geradas mensagens de erro no log +* +***********************************************************************/ + + int LER_LerParmString( char * Parm , int * tamString , int dimString ) ; + + +/*********************************************************************** +* +* $FC Função: LER &Pular comando de teste +* +* $ED Descrição da função +* Avança o cursor do buffer de leitura por cima de um comando de teste. +* Todos os comandos de teste principiam com o prefixo '=' +* +***********************************************************************/ + + void LER_PularComando( void ) ; + +#undef LerParm_EXT + +/********** Fim do módulo de definição: LER Ler parâmetros de comandos **********/ + +#else +#endif diff --git a/MODULO BAR/LISTA.C b/MODULO BAR/LISTA.C new file mode 100644 index 0000000..e7f04e5 --- /dev/null +++ b/MODULO BAR/LISTA.C @@ -0,0 +1,571 @@ +/*************************************************************************** +* $MCI Módulo de implementação: LIS Lista duplamente encadeada +* +* Arquivo gerado: LISTA.c +* Letras identificadoras: LIS +* +* Nome da base de software: Arcabouço para a automação de testes de programas redigidos em C +* Arquivo da base de software: D:\AUTOTEST\PROJETOS\LISTA.BSW +* +* Projeto: INF 1301 / 1628 Automatização dos testes de módulos C +* Gestor: LES/DI/PUC-Rio +* Autores: avs +* +* $HA Histórico de evolução: +* Versão Autor Data Observações +* 4 avs 01/fev/2006 criar linguagem script simbólica +* 3 avs 08/dez/2004 uniformização dos exemplos +* 2 avs 07/jul/2003 unificação de todos os módulos em um só projeto +* 1 avs 16/abr/2003 início desenvolvimento +* +***************************************************************************/ + +#include +#include +#include +#include +#include + +#define LISTA_OWN +#include "LISTA.h" +#undef LISTA_OWN + +/*********************************************************************** +* +* $TC Tipo de dados: LIS Elemento da lista +* +* +***********************************************************************/ + + typedef struct tagElemLista { + + void * pValor ; + /* Ponteiro para o valor contido no elemento */ + + struct tagElemLista * pAnt ; + /* Ponteiro para o elemento predecessor */ + + struct tagElemLista * pProx ; + /* Ponteiro para o elemento sucessor */ + + } tpElemLista ; + +/*********************************************************************** +* +* $TC Tipo de dados: LIS Descritor da cabeça de lista +* +* +***********************************************************************/ + + typedef struct LIS_tagLista { + + tpElemLista * pOrigemLista ; + /* Ponteiro para a origem da lista */ + + tpElemLista * pFimLista ; + /* Ponteiro para o final da lista */ + + tpElemLista * pElemCorr ; + /* Ponteiro para o elemento corrente da lista */ + + int numElem ; + /* Número de elementos da lista */ + + void ( * ExcluirValor ) ( void * pValor ) ; + /* Ponteiro para a função de destruição do valor contido em um elemento */ + + } LIS_tpLista ; + +/***** Protótipos das funções encapuladas no módulo *****/ + + static void LiberarElemento( LIS_tppLista pLista , + tpElemLista * pElem ) ; + + static tpElemLista * CriarElemento( LIS_tppLista pLista , + void * pValor ) ; + + static void LimparCabeca( LIS_tppLista pLista ) ; + +/***** Código das funções exportadas pelo módulo *****/ + +/*************************************************************************** +* +* Função: LIS &Criar lista +* ****/ + + 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 */ + + LimparCabeca( pLista ) ; + + pLista->ExcluirValor = ExcluirValor ; + + return pLista ; + + } /* Fim função: LIS &Criar lista */ + +/*************************************************************************** +* +* Função: LIS &Destruir lista +* ****/ + + void LIS_DestruirLista( LIS_tppLista pLista ) + { + + #ifdef _DEBUG + assert( pLista != NULL ) ; + #endif + + LIS_EsvaziarLista( pLista ) ; + + free( pLista ) ; + + } /* Fim função: LIS &Destruir lista */ + +/*************************************************************************** +* +* Função: LIS &Esvaziar lista +* ****/ + + void LIS_EsvaziarLista( LIS_tppLista pLista ) + { + + tpElemLista * pElem ; + tpElemLista * pProx ; + + #ifdef _DEBUG + assert( pLista != NULL ) ; + #endif + + pElem = pLista->pOrigemLista ; + while ( pElem != NULL ) + { + pProx = pElem->pProx ; + LiberarElemento( pLista , pElem ) ; + pElem = pProx ; + } /* while */ + + LimparCabeca( pLista ) ; + + } /* Fim função: LIS &Esvaziar lista */ + +/*************************************************************************** +* +* Função: LIS &Inserir elemento antes +* ****/ + + LIS_tpCondRet LIS_InserirElementoAntes( LIS_tppLista pLista , + void * pValor ) + { + + tpElemLista * pElem ; + + #ifdef _DEBUG + assert( pLista != NULL ) ; + #endif + + /* Criar elemento a inerir antes */ + + pElem = CriarElemento( pLista , pValor ) ; + if ( pElem == NULL ) + { + return LIS_CondRetFaltouMemoria ; + } /* if */ + + /* Encadear o elemento antes do elemento corrente */ + + if ( pLista->pElemCorr == NULL ) + { + pLista->pOrigemLista = pElem ; + pLista->pFimLista = pElem ; + } else + { + if ( pLista->pElemCorr->pAnt != NULL ) + { + pElem->pAnt = pLista->pElemCorr->pAnt ; + pLista->pElemCorr->pAnt->pProx = pElem ; + } else + { + pLista->pOrigemLista = pElem ; + } /* if */ + + pElem->pProx = pLista->pElemCorr ; + pLista->pElemCorr->pAnt = pElem ; + } /* if */ + + pLista->pElemCorr = pElem ; + + return LIS_CondRetOK ; + + } /* Fim função: LIS &Inserir elemento antes */ + +/*************************************************************************** +* +* Função: LIS &Inserir elemento após +* ****/ + + LIS_tpCondRet LIS_InserirElementoApos( LIS_tppLista pLista , + void * pValor ) + + { + + tpElemLista * pElem ; + + #ifdef _DEBUG + assert( pLista != NULL ) ; + #endif + + /* Criar elemento a inerir após */ + + pElem = CriarElemento( pLista , pValor ) ; + if ( pElem == NULL ) + { + return LIS_CondRetFaltouMemoria ; + } /* if */ + + /* Encadear o elemento após o elemento */ + + if ( pLista->pElemCorr == NULL ) + { + pLista->pOrigemLista = pElem ; + pLista->pFimLista = pElem ; + } else + { + if ( pLista->pElemCorr->pProx != NULL ) + { + pElem->pProx = pLista->pElemCorr->pProx ; + pLista->pElemCorr->pProx->pAnt = pElem ; + } else + { + pLista->pFimLista = pElem ; + } /* if */ + + pElem->pAnt = pLista->pElemCorr ; + pLista->pElemCorr->pProx = pElem ; + + } /* if */ + + pLista->pElemCorr = pElem ; + + return LIS_CondRetOK ; + + } /* Fim função: LIS &Inserir elemento após */ + +/*************************************************************************** +* +* Função: LIS &Excluir elemento +* ****/ + + LIS_tpCondRet LIS_ExcluirElemento( LIS_tppLista pLista ) + { + + tpElemLista * pElem ; + + #ifdef _DEBUG + assert( pLista != NULL ) ; + #endif + + if ( pLista->pElemCorr == NULL ) + { + return LIS_CondRetListaVazia ; + } /* if */ + + pElem = pLista->pElemCorr ; + + /* Desencadeia à esquerda */ + + if ( pElem->pAnt != NULL ) + { + pElem->pAnt->pProx = pElem->pProx ; + pLista->pElemCorr = pElem->pAnt ; + } else { + pLista->pElemCorr = pElem->pProx ; + pLista->pOrigemLista = pLista->pElemCorr ; + } /* if */ + + /* Desencadeia à direita */ + + if ( pElem->pProx != NULL ) + { + pElem->pProx->pAnt = pElem->pAnt ; + } else + { + pLista->pFimLista = pElem->pAnt ; + } /* if */ + + LiberarElemento( pLista , pElem ) ; + + return LIS_CondRetOK ; + + } /* Fim função: LIS &Excluir elemento */ + +/*************************************************************************** +* +* Função: LIS &Obter referência para o valor contido no elemento +* ****/ + + void * LIS_ObterValor( LIS_tppLista pLista ) + { + + #ifdef _DEBUG + assert( pLista != NULL ) ; + #endif + + if ( pLista->pElemCorr == NULL ) + { + return NULL ; + } /* if */ + + return pLista->pElemCorr->pValor ; + + } /* Fim função: LIS &Obter referência para o valor contido no elemento */ + +/*************************************************************************** +* +* Função: LIS &Ir para o elemento inicial +* ****/ + + void IrInicioLista( LIS_tppLista pLista ) + { + + #ifdef _DEBUG + assert( pLista != NULL ) ; + #endif + + pLista->pElemCorr = pLista->pOrigemLista ; + + } /* Fim função: LIS &Ir para o elemento inicial */ + +/*************************************************************************** +* +* Função: LIS &Ir para o elemento final +* ****/ + + void IrFinalLista( LIS_tppLista pLista ) + { + + #ifdef _DEBUG + assert( pLista != NULL ) ; + #endif + + pLista->pElemCorr = pLista->pFimLista ; + + } /* Fim função: LIS &Ir para o elemento final */ + +/*************************************************************************** +* +* Função: LIS &Avançar elemento +* ****/ + + LIS_tpCondRet LIS_AvancarElementoCorrente( LIS_tppLista pLista , + int numElem ) + { + + int i ; + + tpElemLista * pElem ; + + #ifdef _DEBUG + assert( pLista != NULL ) ; + #endif + + /* Tratar lista vazia */ + + if ( pLista->pElemCorr == NULL ) + { + + return LIS_CondRetListaVazia ; + + } /* fim ativa: Tratar lista vazia */ + + /* Tratar avançar para frente */ + + if ( numElem > 0 ) + { + + pElem = pLista->pElemCorr ; + for( i = numElem ; i > 0 ; i-- ) + { + if ( pElem == NULL ) + { + break ; + } /* if */ + pElem = pElem->pProx ; + } /* for */ + + if ( pElem != NULL ) + { + pLista->pElemCorr = pElem ; + return LIS_CondRetOK ; + } /* if */ + + pLista->pElemCorr = pLista->pFimLista ; + return LIS_CondRetFimLista ; + + } /* fim ativa: Tratar avançar para frente */ + + /* Tratar avançar para trás */ + + else if ( numElem < 0 ) + { + + pElem = pLista->pElemCorr ; + for( i = numElem ; i < 0 ; i++ ) + { + if ( pElem == NULL ) + { + break ; + } /* if */ + pElem = pElem->pAnt ; + } /* for */ + + if ( pElem != NULL ) + { + pLista->pElemCorr = pElem ; + return LIS_CondRetOK ; + } /* if */ + + pLista->pElemCorr = pLista->pOrigemLista ; + return LIS_CondRetFimLista ; + + } /* fim ativa: Tratar avançar para trás */ + + /* Tratar não avançar */ + + return LIS_CondRetOK ; + + } /* Fim função: LIS &Avançar elemento */ + +/*************************************************************************** +* +* Função: LIS &Procurar elemento contendo valor +* ****/ + + LIS_tpCondRet LIS_ProcurarValor( LIS_tppLista pLista , + void * pValor ) + { + + tpElemLista * pElem ; + + #ifdef _DEBUG + assert( pLista != NULL ) ; + #endif + + if ( pLista->pElemCorr == NULL ) + { + return LIS_CondRetListaVazia ; + } /* if */ + + for ( pElem = pLista->pElemCorr ; + pElem != NULL ; + pElem = pElem->pProx ) + { + if ( pElem->pValor == pValor ) + { + pLista->pElemCorr = pElem ; + return LIS_CondRetOK ; + } /* if */ + } /* for */ + + return LIS_CondRetNaoAchou ; + + } /* Fim função: LIS &Procurar elemento contendo valor */ + + +/*************************************************************************** +* +* Função: LIS &Obter o tamanho da lista +* ****/ + LIS_tpCondRet LIS_ObterTamanho( LIS_tppLista pLista,int * num) + { + *num = pLista->numElem; + return LIS_CondRetOK ; + } /* Fim função: LIS &Obter referência para o tamanho da lista*/ + + +/***** Código das funções encapsuladas no módulo *****/ + + +/*********************************************************************** +* +* $FC Função: LIS -Liberar elemento da lista +* +* $ED Descrição da função +* Elimina os espaços apontados pelo valor do elemento e o +* próprio elemento. +* +***********************************************************************/ + + void LiberarElemento( LIS_tppLista pLista , + tpElemLista * pElem ) + { + + if ( ( pLista->ExcluirValor != NULL ) + && ( pElem->pValor != NULL )) + { + pLista->ExcluirValor( pElem->pValor ) ; + } /* if */ + + free( pElem ) ; + + pLista->numElem-- ; + + } /* Fim função: LIS -Liberar elemento da lista */ + + +/*********************************************************************** +* +* $FC Função: LIS -Criar o elemento +* +***********************************************************************/ + + tpElemLista * CriarElemento( LIS_tppLista pLista , + void * pValor ) + { + + tpElemLista * pElem ; + + pElem = ( tpElemLista * ) malloc( sizeof( tpElemLista )) ; + if ( pElem == NULL ) + { + return NULL ; + } /* if */ + + pElem->pValor = pValor ; + pElem->pAnt = NULL ; + pElem->pProx = NULL ; + + pLista->numElem ++ ; + + return pElem ; + + } /* Fim função: LIS -Criar o elemento */ + + +/*********************************************************************** +* +* $FC Função: LIS -Limpar a cabeça da lista +* +***********************************************************************/ + + void LimparCabeca( LIS_tppLista pLista ) + { + + pLista->pOrigemLista = NULL ; + pLista->pFimLista = NULL ; + pLista->pElemCorr = NULL ; + pLista->numElem = 0 ; + + } /* Fim função: LIS -Limpar a cabeça da lista */ + +/********** Fim do módulo de implementação: LIS Lista duplamente encadeada **********/ + diff --git a/MODULO BAR/LISTA.H b/MODULO BAR/LISTA.H new file mode 100644 index 0000000..0d7f1cc --- /dev/null +++ b/MODULO BAR/LISTA.H @@ -0,0 +1,365 @@ +#if ! defined( LISTA_ ) +#define LISTA_ +/*************************************************************************** +* +* $MCD Módulo de definição: LIS Lista duplamente encadeada +* +* Arquivo gerado: LISTA.h +* Letras identificadoras: LIS +* +* Nome da base de software: Arcabouço para a automação de testes de programas redigidos em C +* Arquivo da base de software: D:\AUTOTEST\PROJETOS\LISTA.BSW +* +* Projeto: INF 1301 / 1628 Automatização dos testes de módulos C +* Gestor: LES/DI/PUC-Rio +* Autores: avs +* +* $HA Histórico de evolução: +* Versão Autor Data Observações +* 4 avs 01/fev/2006 criar linguagem script simbólica +* 3 avs 08/dez/2004 uniformização dos exemplos +* 2 avs 07/jul/2003 unificação de todos os módulos em um só projeto +* 1 avs 16/abr/2003 início desenvolvimento +* +* $ED Descrição do módulo +* Implementa listas genéricas duplamente encadeadas. +* Podem existir n listas em operação simultaneamente. +* As listas possuem uma cabeça encapsulando o seu estado. +* +* Cada lista é homogênea quanto ao tipo dos dados que armazena. +* Cada elemento da lista referencia o valor que contém. +* +* Os ponteiros para os dados são copiados para elementos da lista. +* Não é copiado o valor apontado por estes ponteiros. +* +* O controle da destruição do valor de um elemento a ser excluído +* é realizado por uma função fornecida pelo usuário. +* +* Cada lista referencia uma função que determina como devem ser +* desalocados os dados nela contidos. +* +* A função de liberação dos valores contidos nos elementos deve +* assegurar a liberação de todos os espaços referênciados pelo +* valor contido em um elemento. +* Esta função é chamada antes de se desalocar um elemento +* de uma lista. +* Caso não seja necessário desalocar o valor referenciado pelo +* elemento, o ponteiro para a função de liberação poderá ser NULL . +* Caso o elemento da lista seja a única âncora do valor referenciado, +* esta função deve promover a destruição (free) desse valor e +* de todos os dados nele ancorados. +* +***************************************************************************/ + +#if defined( LISTA_OWN ) + #define LISTA_EXT +#else + #define LISTA_EXT extern +#endif + +/***** Declarações exportadas pelo módulo *****/ + +/* Tipo referência para uma lista */ + +typedef struct LIS_tagLista * LIS_tppLista ; + + +/*********************************************************************** +* +* $TC Tipo de dados: LIS Condições de retorno +* +* +* $ED Descrição do tipo +* Condições de retorno das funções da lista +* +***********************************************************************/ + + typedef enum { + + LIS_CondRetOK , + /* Concluiu corretamente */ + + LIS_CondRetListaVazia , + /* A lista não contém elementos */ + + LIS_CondRetFimLista , + /* Foi atingido o fim de lista */ + + LIS_CondRetNaoAchou , + /* Não encontrou o valor procurado */ + + LIS_CondRetFaltouMemoria, + /* Faltou memória ao tentar criar um elemento de lista */ + + LIS_CondRetErro + /* Nao executou corretamente */ + + } LIS_tpCondRet ; + + +/*********************************************************************** +* +* $FC Função: LIS &Criar lista +* +* $ED Descrição da função +* Cria uma lista genérica duplamente encadeada. +* Os possíveis tipos são desconhecidos a priori. +* A tipagem é implicita. +* Não existe identificador de tipo associado à lista. +* +* $EP Parâmetros +* ExcluirValor - ponteiro para a função que processa a +* exclusão do valor referenciado pelo elemento +* a ser excluído. +* Ver descrição do módulo. +* +* $FV Valor retornado +* Se executou corretamente retorna o ponteiro para a lista. +* Este ponteiro será utilizado pelas funções que manipulem esta lista. +* +* Se ocorreu algum erro, por exemplo falta de memória ou dados errados, +* a função retornará NULL. +* Não será dada mais informação quanto ao problema ocorrido. +* +***********************************************************************/ + + LIS_tppLista LIS_CriarLista( + void ( * ExcluirValor ) ( void * pDado ) ) ; + + +/*********************************************************************** +* +* $FC Função: LIS &Destruir lista +* +* $ED Descrição da função +* Destrói a lista fornecida. +* O parâmetro ponteiro para a lista não é modificado. +* Se ocorrer algum erro durante a destruição, a lista resultará +* estruturalmente incorreta. +* OBS. não existe previsão para possíveis falhas de execução. +* +* $FV Valor retornado +* LIS_CondRetOK - destruiu sem problemas +* +***********************************************************************/ + + void LIS_DestruirLista( LIS_tppLista pLista ) ; + + +/*********************************************************************** +* +* $FC Função: LIS &Esvaziar lista +* +* $ED Descrição da função +* Elimina todos os elementos, sem contudo eliminar a lista +* +* $EP Parâmetros +* pLista - ponteiro para a lista a ser esvaziada +* +***********************************************************************/ + + void LIS_EsvaziarLista( LIS_tppLista pLista ) ; + + +/*********************************************************************** +* +* $FC Função: LIS &Inserir elemento antes +* +* $ED Descrição da função +* Insere novo elemento antes do elemento corrente. +* Caso a lista esteja vazia, insere o primeiro elemento da lista. +* +* $EP Parâmetros +* pLista - ponteiro para a lista onde deve ser inserido o elemento +* pValor - ponteiro para o valor do novo elemento +* Pode ser NULL +* +* $FV Valor retornado +* LIS_CondRetOK +* LIS_CondRetFaltouMemoria +* +***********************************************************************/ + + LIS_tpCondRet LIS_InserirElementoAntes( LIS_tppLista pLista , + void * pValor ) ; + + +/*********************************************************************** +* +* $FC Função: LIS &Inserir elemento após +* +* $ED Descrição da função +* Insere novo elemento apás o elemento corrente. +* Caso a lista esteja vazia, insere o primeiro elemento da lista. +* +* $EP Parâmetros +* Parâmetros +* pLista - ponteiro para a lista onde deve ser inserido o elemento +* pValor - ponteiro para o valor do novo elemento +* Pode ser NULL +* +* +* $FV Valor retornado +* Valor retornado +* LIS_CondRetOK +* LIS_CondRetFaltouMemoria +* +***********************************************************************/ + + LIS_tpCondRet LIS_InserirElementoApos( LIS_tppLista pLista , void * pValor ); + + +/*********************************************************************** +* +* $FC Função: LIS &Excluir elemento +* +* $ED Descrição da função +* Exclui o elemento corrente da lista dada. +* Se existir o elemento aa esquerda do corrente será o novo corrente. +* Se não existir e existir o elemento à direita, este se tornará corrente. +* Se este também não existir a lista tornou-se vazia. +* +* $EP Parâmetros +* pLista - ponteiro para a lista na qual deve excluir. +* +* $FV Valor retornado +* LIS_CondRetOK +* LIS_CondRetListaVazia +* +***********************************************************************/ + + LIS_tpCondRet LIS_ExcluirElemento( LIS_tppLista pLista ) ; + + +/*********************************************************************** +* +* $FC Função: LIS &Obter referência para o valor contido no elemento +* +* $ED Descrição da função +* Obtem a referência para o valor contido no elemento corrente da lista +* +* $EP Parâmetros +* pLista - ponteiro para a lista de onde se quer o valor +* +* $FV Valor retornado +* não NULL - se o elemento corrente existe +* NULL - se a lista estiver vazia +* Pode retornar NULL se o valor inserido no elemento for NULL. +* +***********************************************************************/ + + void * LIS_ObterValor( LIS_tppLista pLista ) ; + + +/*********************************************************************** +* +* $FC Função: LIS &Ir para o elemento inicial +* +* $ED Descrição da função +* Torna corrente o primeiro elemento da lista. +* Faz nada se a lista está vazia. +* +* $EP Parâmetros +* pLista - ponteiro para a lista a manipular +* +***********************************************************************/ + + void IrInicioLista( LIS_tppLista pLista ) ; + + +/*********************************************************************** +* +* $FC Função: LIS &Ir para o elemento final +* +* $ED Descrição da função +* Torna corrente o elemento final da lista. +* Faz nada se a lista está vazia. +* +* $EP Parâmetros +* pLista - ponteiro para a lista a manipular +* +***********************************************************************/ + + void IrFinalLista( LIS_tppLista pLista ) ; + + +/*********************************************************************** +* +* $FC Função: LIS &Avançar elemento +* +* $ED Descrição da função +* Avança o elemento corrente numElem elementos na lista +* Se numElem for positivo avança em direção ao final +* Se numElem for negativo avança em direção ao início +* numElem pode ser maior do que o númro de elementos existentes na +* direção desejada +* Se numElem for zero somente verifica se a lista está vazia +* +* $EP Parâmetros +* pLista - ponteiro para a lista a ser manipulada +* numElem - o número de elementos a andar +* +* $FV Valor retornado +* CondRetOK - se numElem elementos tiverem sido andados +* CondRetFimLista - se encontrou o fim da lista antes de andar numElem +* elementos +* CondRetListaVazia - se a lista está vazia +* +***********************************************************************/ + + LIS_tpCondRet LIS_AvancarElementoCorrente( LIS_tppLista pLista ,int numElem ) ; + + +/*********************************************************************** +* +* $FC Função: LIS &Procurar elemento contendo valor +* +* $ED Descrição da função +* Procura o elemento que referencia o valor dado. +* A função compara ponteiro e não conteúdo apontado. +* +* $EP Parâmetros +* pLista - ponteiro para a lista onde procura +* pValor - ponteiro para o valor procurado +* Pode ser NULL +* +* $FV Valor retornado +* LIS_CondRetOK - se encontrou. +* O elemento corrente é o primeiro elemento do +* elemento corrente inclusive para o fim da lista +* e que contém o ponteiro procurado +* +* LIS_CondRetNaoEncontrou - se o ponteiro não foi encontrado +* O elemento corrente continua o mesmo +* LIS_CondRetListaVazia - se a lista estiver vazia +* +***********************************************************************/ + + LIS_tpCondRet LIS_ProcurarValor( LIS_tppLista pLista , + void * pValor ) ; + +/*********************************************************************** +* +* $FC Função: LIS &Obgter TAmanho da lista +* +* $ED Descrição da função +* Atribui a variável tam o tamanho da lista +* +* $EP Parâmetros +* pLista - ponteiro para a lista onde procura +* tam - ponteiro de referencia para a tamanho da lista +* +* $FV Valor retornado +* LIS_CondRetOK - se ponteiros sao validos +* +* LIS_CondRetErro - ponteiros sao invalidos +***********************************************************************/ + + LIS_tpCondRet LIS_ObterTamanho( LIS_tppLista pLista, int * tam); + +#undef LISTA_EXT + +/********** Fim do módulo de definição: LIS Lista duplamente encadeada **********/ + +#else +#endif diff --git a/MODULO BAR/PECA.C b/MODULO BAR/PECA.C new file mode 100644 index 0000000..bf24f92 --- /dev/null +++ b/MODULO BAR/PECA.C @@ -0,0 +1,89 @@ +/*************************************************************************** +* $MCI Módulo de implementação: PEC Estrutura Peca +* +* Arquivo gerado: PECA.C +* Letras identificadoras: PEC +* +* Nome da base de software: Exemplo de teste automatizado +* +* Projeto: Disciplinas INF 1628 / 1301 +* Gestor: DI/PUC-Rio +* Autores: fvc - Felipe Vieira Côrtes +* tbm - Tássio Borges de Miranda +* db - Daniela Brazão +* +* $HA Histórico de evolução: +* Versão Autor Data Observações +* 1.0 tbm 14/set/2015 Início do desenvolvimento +* +***************************************************************************/ + + +#include +#include +#include + +#define PECA_OWN +#include "PECA.h" +#undef PECA_OWN + +/*********************************************************************** +* +* $TC Tipo de dados: PECPnt Descritor do dados de ponto. +* +* $ED Descrição do tipo +* Descreve a estrutura de peça +***********************************************************************/ + +typedef struct tgPeca{ + char cor; +} tpPeca; + + +/***** Dados encapsulados no módulo *****/ + +// vazio + +/***** Código das funções exportadas pelo módulo *****/ + +/*************************************************************************** +* +* Função: Pec Criar Peça +* ****/ + +Pec_tpCondRet Pec_CriarPeca(tppPeca * PecCriado, char CorDaNovaPeca) +{ + *PecCriado= (tppPeca)malloc(sizeof(struct tgPeca)); + + if(PecCriado == NULL) + return Pec_CondRetFaltouMemoria; + + (*PecCriado)->cor = CorDaNovaPeca; + + return Pec_CondRetOK; +} + +/*************************************************************************** +* +* Função: PEC Destruir Peça +* ****/ + +Pec_tpCondRet Pec_DestruirPeca(tppPeca Peca) +{ + + free(Peca); + return Pec_CondRetOK; +} + +/*************************************************************************** +* +* Função: PEC Obter Cor +* ****/ + +Pec_tpCondRet Pec_ObterCor(tppPeca Peca, char *cor) +{ + *cor = Peca->cor; + return Pec_CondRetOK; +} + +/*********** Fim do módulo de implementação: Módulo DadoPontos **************/ diff --git a/MODULO BAR/PECA.h b/MODULO BAR/PECA.h new file mode 100644 index 0000000..2458e5e --- /dev/null +++ b/MODULO BAR/PECA.h @@ -0,0 +1,97 @@ +/*************************************************************************** +* +* $MCD Módulo de definição: Módulo Peça +* +* Arquivo gerado: PECA.H +* Letras identificadoras: PEC +* +* Nome da base de software: Exemplo de teste automatizado +* +* Projeto: Disciplinas INF 1628 / 1301 +* Gestor: DI/PUC-Rio +* Autores: fvc - Felipe Vieira Côrtes +* tbm - Tássio Borges de Miranda +* db - Daniela Brazão + +* +* $HA Histórico de evolução: +* Versão Autor Data Observações +* 1.00 tbm 14/09/2015 Início do desenvolvimento +* +* $ED Descrição do módulo +* Este módulo implementa um conjunto simples de funções para manipular a peça +* alem de descrever sua estrutura. +* +***************************************************************************/ + +#if defined( PECA_OWN ) + #define PECA_EXT +#else + #define PECA_EXT extern +#endif + +typedef struct tgPeca * tppPeca; + +/*********************************************************************** +* +* $TC Tipo de dados: MAT Condicoes de retorno +* +* +***********************************************************************/ + + typedef enum { + + Pec_CondRetOK = 0 , + /* Executou correto */ + + Pec_CondRetErro = 1 , + /* Estrutura do DadoPontos está errada */ + + Pec_CondRetMatrizNaoExiste = 2 , + /* DadoPontos não existe */ + + Pec_CondRetFaltouMemoria = 3 + /* Faltou memória ao alocar dados */ + + } Pec_tpCondRet ; + +/*********************************************************************** +* +* $FC Função: PEC Criar Peça +* +* $ED Descrição da função +* Cria uma nova peça +* $FV Valor retonado +* Pec_CondRetOK +* Pec_CondRetFaltouMemoria +* +***********************************************************************/ + + Pec_tpCondRet Pec_CriarPeca(tppPeca * PecCriado1, char CorDaNovaPeca); + +/*********************************************************************** +* +* $FC Função: PEC Destruir Peça +* +* $ED Descrição da função +* Destroi uma peça +* $FV Valor retonado +* Pec_CondRetOK +* Pec_CondRetFaltouMemoria +* +***********************************************************************/ + + Pec_tpCondRet Pec_DestruirPeca(tppPeca Peca); + +/*********************************************************************** +* +* $FC Função: PEC Obter Cor +* +* $ED Descrição da função +* Obtem cor de uma peca +* $FV Valor retonado +* Pec_CondRetOK +* Pec_CondRetFaltouMemoria +* +***********************************************************************/ +Pec_tpCondRet Pec_ObterCor(tppPeca Peca, char *cor); \ No newline at end of file diff --git a/MODULO BAR/TESTBAR.c b/MODULO BAR/TESTBAR.c new file mode 100644 index 0000000..dbc2d47 --- /dev/null +++ b/MODULO BAR/TESTBAR.c @@ -0,0 +1,219 @@ +/*************************************************************************** +* $MCI Módulo de implementação: Módulo de teste específico + +* Módulo criado para operar com listas +* +* Arquivo gerado: TESTBAR.C +* Letras identificadoras: TBar +* +* Nome da base de software: Exemplo de teste automatizado +* +* Projeto: Disciplinas INF 1628 / 1301 +* Gestor: DI/PUC-Rio +* Autores: fvc - Felipe Vieira Cortes +* tbm - Tássio Borges de Miranda +* db - Daniela Brazão +* +* $HA Histórico de evolução: +* Versão Autor Data Observações +* 4.00 tbm 23/10/2015 Módulo criado para operar com listas +* +* $ED Descrição do módulo +* Este módulo contém as funções específicas para o teste do +* módulo Bar. +* +* $EIU Interface com o usuário pessoa +* Comandos de teste específicos para testar o módulo BAR: + +* =criarbar - Chama a função BAR_tpCondRet BAR_CriarBAR() +* =obtercorbar - Chama a função BAR_tpCondRet BAR_AdicionarPeca(BAR_tppCapturadas pBAR) +* =obtertamanhobar - Chama a função BAR_tpCondRet BAR_RemoverPeca(BAR_tppCapturadas pBAR) +* =removerbar - Chama a função BAR_tpCondRet BAR_ObterTamanhoBar(BAR_tppCapturadas pBAR, int *tam) +* =addbar - Chama a função BAR_tpCondRet BAR_ObterCorBar(BAR_tppCapturadas pBAR, char *cor) +* =destruirbar - Chama a função BAR_tpCondRet Bar_DestruirBar(BAR_tppCapturadas pBAR) +* +***************************************************************************/ + +#include +#include +#include + +#include "BAR.h" +#include "LISTA.H" +#include "GENERICO.H" +#include "LERPARM.H" +#include "PECA.h" +#include "TST_ESPC.H" + + +/* Tabela dos nomes dos comandos de teste específicos */ +#define MAX 5 +#define DIM_VET_BAR 2 +#define CRIAR_BAR_CMD "=criarbar" +#define REMOVER_BAR_CMD "=removerbar" +#define OBTER_COR_BAR_CMD "=obtercorbar" +#define ADD_BAR_CMD "=addbar" +#define OBTER_TAM_BAR_CMD "=obtertamanhobar" +#define DESTRUIR_BAR_CMD "=destruirbar" + +BAR_tppCapturadas BarCap [DIM_VET_BAR]; + +/***** Protótipos das funções encapuladas no módulo *****/ + + static void DestruirValor( void * pValor ) ; + +/***** Código das funções exportadas pelo módulo *****/ + + +/*********************************************************************** +* +* $FC Função: TPec Efetuar operações de teste específicas para o Modulo Peca +* +* $ED Descrição da função +* Efetua os diversos comandos de teste específicos para o módulo +* Peca sendo testado. +* +* $EP Parâmetros +* $P ComandoTeste - String contendo o comando +* +* $FV Valor retornado +* Ver TST_tpCondRet definido em TST_ESPC.H +* +***********************************************************************/ + + TST_tpCondRet TST_EfetuarComando( char * ComandoTeste ) + { + + int CondRetObtido = BAR_CondRetOK ; + int CondRetEsperada = BAR_CondRetFaltouMemoria ; + /* inicializa para qualquer coisa */ + + char ValorEsperado = '?' ; + char ValorObtido = '!' ; + char ValorDado = '\0' ; + char corEsperada = 'x'; + char corRecebida; + int NumLidos = -1 ; + int i = 0; + int inxpec, tamanhobar,tamanhobaresp; + + TST_tpCondRet Ret; + TST_tpCondRet CondRet; + + /* Testar Bar Criar Bar */ + if ( strcmp( ComandoTeste , CRIAR_BAR_CMD ) == 0 ) + { + + NumLidos = LER_LerParametros( "ici" , + &inxpec, &corRecebida, &CondRetEsperada ) ; + if ( NumLidos != 3 ) + { + return TST_CondRetParm ; + } /* if */ + + if(inxpec > 5 || inxpec < 0) return TST_CondRetErro; + + CondRetObtido = BAR_CriarBAR(&BarCap[inxpec],corRecebida,DestruirValor); + + return TST_CompararInt( CondRetEsperada , CondRetObtido , + "Retorno errado ao criar BAR." ); + + } /* fim ativa: Testar BAR Criar BAr */ + + /* Testar Bar Remover Bar */ + else if ( strcmp( ComandoTeste , REMOVER_BAR_CMD ) == 0 ) + { + + NumLidos = LER_LerParametros( "ii" , &inxpec, &CondRetEsperada ) ; + if ( NumLidos != 2 ) + { + return TST_CondRetParm ; + } /* if */ + + CondRetObtido = BAR_RemoverPeca(BarCap[inxpec]) ; + + return TST_CompararInt( CondRetEsperada , CondRetObtido , + "Retorno errado ao Removar Bar." ); + + } /* fim ativa: Testar Bar Remover Bar */ + + /* Testar Bar Obter cor da Bar */ + else if ( strcmp( ComandoTeste , OBTER_COR_BAR_CMD ) == 0 ) + { + + NumLidos = LER_LerParametros( "ici",&inxpec,&corEsperada, &CondRetEsperada ) ; + if ( NumLidos != 3 ) + { + return TST_CondRetParm ; + } /* if */ + CondRetObtido = BAR_ObterCorBar(BarCap[inxpec],&corRecebida) ; + + Ret = TST_CompararChar( corRecebida , corEsperada , + "Valor do elemento errado, diferente do esperado" ) ; + + if ( Ret != TST_CondRetOK ) + { + return Ret ; + } /* if */ + + return TST_CompararChar(CondRetObtido, CondRetEsperada, "Retorno errado ao obter o cor do BAR."); + + } /* fim ativa: Testar Bar Obter cor da Bar */ + + /* Testar Bar AddBar */ + else if ( strcmp( ComandoTeste , ADD_BAR_CMD ) == 0 ) + { + + NumLidos = LER_LerParametros( "ii" , &inxpec, &CondRetEsperada ) ; + if ( NumLidos != 2 ) + { + return TST_CondRetParm ; + } /* if */ + + CondRetObtido = BAR_AdicionarPeca(BarCap[inxpec]) ; + + return TST_CompararInt( CondRetEsperada , CondRetObtido , + "Retorno errado ao obter cor da BAR." ); + + } + /*Fim da ativa: Testar Bar addbar*/ + + /* Testar obter tamanho BAR*/ + else if( strcmp ( ComandoTeste , OBTER_TAM_BAR_CMD) == 0) + { + NumLidos = LER_LerParametros( "iii" , &inxpec,&tamanhobaresp, &CondRetEsperada); + if ( NumLidos != 3 ) + return TST_CondRetParm; + + CondRetObtido = BAR_ObterTamanhoBar(BarCap[inxpec],&tamanhobar); + + CondRet = TST_CompararInt(tamanhobaresp,tamanhobar,"Tamanho do elemento errado, diferente do esperado"); + + if ( CondRet != TST_CondRetOK ) + return CondRet; + + return TST_CompararInt( CondRetEsperada , CondRetObtido, "Retorno errado ao obter tamanho bar."); + } + /*Fim da ativa: Testar Bar tamanhoBAR*/ + + /*Testar Destruir Bar*/ + + else if( strcmp ( ComandoTeste , DESTRUIR_BAR_CMD) == 0) + { + NumLidos = LER_LerParametros( "ii" , &inxpec, &CondRetEsperada); + if ( NumLidos != 2 ) + return TST_CondRetParm; + + CondRetObtido = Bar_DestruirBar(BarCap[inxpec]); + + return TST_CompararInt( CondRetEsperada , CondRetObtido, "Retorno errado ao destruir BAR."); + } + + /*Fim da ativa: Testar Destuir Bar*/ + return TST_CondRetNaoConhec ; + } /* Fim função: TPec Efetuar operações de teste específicas para Peca */ + +void DestruirValor( void * pValor ) + { + free( pValor ) ; + } \ No newline at end of file diff --git a/MODULO BAR/TST_ESPC.H b/MODULO BAR/TST_ESPC.H new file mode 100644 index 0000000..987ff8e --- /dev/null +++ b/MODULO BAR/TST_ESPC.H @@ -0,0 +1,320 @@ +#if ! defined( Tst_Espc_ ) +#define Tst_Espc_ +/*************************************************************************** +* +* $MCD Módulo de definição: TSTE Interface de teste específico +* +* Arquivo gerado: Tst_Espc.h +* +* Nome da base de software: Arcabouço para a automação de testes de programas redigidos em C +* Arquivo da base de software: C:\AUTOTEST\PROJETOS\ARCABOUC.BSW +* +* Projeto: INF 1301 / 1628 Automatização dos testes de módulos C +* Gestor: LES/DI/PUC-Rio +* Autores: avs +* +* $HA Histórico de evolução: +* Versão Autor Data Observações +* 4 avs 01/fev/2006 criar linguagem script simbólica +* 3 avs 08/dez/2004 uniformização dos exemplos +* 2 avs 07/jul/2003 unificação de todos os módulos em um só projeto +* 1 avs 16/abr/2003 início desenvolvimento +* +* $ED Descrição do módulo +* Este módulo consta somente do módulo de definição de todos os módulos +* de teste específicos a serem desenvolvidos, e também da especificação +* do tipo de condições de retorno deste módulo. +* +* Ele estabelece a interface a ser utilizada pelo módulo de teste +* genérico com todos os módulos de teste específico a serem +* desenvolvidos. +* +* Os módulos de teste específico devem sempre incluir este módulo +* de definição e, idealmente, não devem adicionar mais itens +* à interface. +* +* O módulo de teste específico contém a função de teste de um +* determinado módulo ou conjunto de módulos. Mais especificamente, +* contém a função que interpreta os comandos de teste que exercitarão +* as funções do(s) módulo(s) em teste. +* +* Poderá conter também diversas funções auxiliares requeridas para +* realizar os testes, vide "contexto" a seguir. +* +* O contexto é formado por variáveis e estruturas auxiliares necessárias +* para que se possa efetuar todos os comandos de teste. +* Por exemplo pode-se desejar testar várias instâncias de uma +* mesma estrutura. Uma forma de resolver isto é criar um vetor +* global static +* de n elementos em que cada elemento aponta para a cabeça de +* uma determinada instância dessa estrutura. Para realizar um +* teste relativo a uma determinada instância, torna-se necessário +* selecioná-la através de um índice contido no comando de teste. +* Este parâmetro, embora seja um índice, é na realidade o identificador +* da instância da estrutura a ser manipulada (idEstrutura). +* +* Caso o módulo em teste requeira um contexto, este deverá ser +* estabelecido no presente módulo. Para tal devem ser declaradas +* variáveis e estruturas encapsuladas e devem ser incluídos comandos +* de teste capazes de manipular o contexto. +* +* Uma das formas para estabelecer o contexto seria a de incluir +* no mçodulo de teste específico comando semelhantes a: +* +* =iniciaXXX que inicializa o contexto do módulo sob teste para +* vazio. Este comando deve ser utilizado uma única vez +* logo ao inciar a execução do teste. +* =reset restaura o contexto para vazio. Este comando usualmente +* assumirá que o contexto a esvaziar esteja correto. +* O comando deverá liberar os espaços alocados aos +* elementos, anular as referências a ele, inicializar +* valores de vetores de referências, etc. +* O comando tem utilidade especial ao segmentar um teste +* em partes estanques e ao controlar vazamento de +* memória. +* =terminaXXX este comando destrói todo o contexto e não o +* reinicializa. O objetivo é poder verificar vazamento +* de memória. +* +* Evidentemente, outra forma seria a de alterar as funções de +* inicialização e término do módulo de teste genérico o que é pouco +* recomendável pois viola o princípio de um mesmo módulo genérico +* servir para testar todos os construtos. +* +* Para cada função do módulo a ser testado deve existir pelo menos +* um comando de teste. Em alguns casos pode ser interessante criar +* comandos que armazenem, alterem ou consultem variáveis de +* estado do próprio módulo de teste. Ver os comentários sobre +* contexto acima. Ou seja, podem existir comandos de teste que +* têm o propósito de agir sobre o contexto e, não, o de efetuar +* um determinado teste. Alguns desses comandos podem inclusive +* realizar verificações entre um resultado esperado e existente +* no contexto. +* +* Todos os controles de consistência dos parâmetros dos comandos +* de teste devem ser realizados no módulo de teste específico. +* Recomenda-se que seja sempre retornado TST_CondRetParm, +* sinalizando erro de sintaxe do comando de teste ou valores +* não permitidos. Deve ser sempre assumido que os parâmetros +* podem estar em erro. Ou seja, o controle da integridade dos +* comando é mandatória. +* +* Caso seja necessário emitir mensagens especiais, +* deve ser utilizada a função genérica "TST_ExibirPrefixo". +* Caso seja desejado acrescentar um texto a alguma mensagem já exibida, +* (prefixo, ou comparar), utilize a função +* fprintf( TST_ObterArqLog( ) , "..." , ... ) +* na qual não deve ocorrer avanço de linha ou nova linha ("\n" ou "\r") +* no parâmetro indicador de formato (2o. parâmetro). Essa comvenção +* assegura a consistência do aspecto das mensagens com o restante do +* programa de teste. +* +* Cada comando deve ser completamente interpretado pelo seu +* respectivo fragmento de interpretação. Ou seja, não deverá ser +* retornado para o módulo genérico qualquer dado adicional à +* condição de retorno da função de teste específico. Veja +* "TST_ExibirPrefixo" acima, caso seja desejado adicionar detalhes +* à mensagen já exibida. +* +* A função TST_NotificarFalha sempre registra uma falha, enquanto que +* a função TST_ExibirPrefixo pode ser usada para emitir mensagens +* de informação ou mesmo de advertência. Caso a função TST_ExibirPrefixo +* seja utilizada para sinalizar uma falha, é necessário chamar +* também a função TST_ContarFalha( ) para que seja notificada a falha. +* Isto não é necessário no caso da função TST_NotificarFalha, pois +* esta sempre conta falhas. +* +* As funções a testar que retornem um valor sempre devem ter +* este valor verificado, mesmo que seja uma condição de retorno. +* Utilize para isto uma das funções " Comparar" do arcabouço. +* Caso uma função retorne dois ou mais valores, incluindo +* a condição de retorno, utilize um código semelhante ao +* descrito a seguir. +* +* Seja +* FuncATestar( p1, p2, p3 ... ) => v1, v2, ... +* a função a ser testada e, v1, v2, ... os dados retornados de +* alguma forma (valor retornado, parâmetro por referência, variável +* global). Assumindo que v1 seja o valor retornado. +* +* v1Obtido = FuncATestar( ... +* CondRet = TST_CompararXXX( v1Obtido , v1Esperado , "mensagem 1" ) ; +* if ( CondRet != TST_CondRetOK ) +* { +* return CondRet ; +* } +* +* CondRet = TST_CompararXXX( v2Obtido , v2Esperado , "mensagem 2" ) ; +* if ( CondRet != TST_CondRetOK ) +* { +* return CondRet ; +* } +* ... +* +* TST_CompararXXX( vnObtido , vnEsperado , "mensagem n" ) ; +* +***************************************************************************/ + +#if defined( Tst_Espc_OWN ) + #define Tst_Espc_EXT +#else + #define Tst_Espc_EXT extern +#endif + +/***** Declarações exportadas pelo módulo *****/ + +#define SINALIZA_ERRO ">>>" +#define SINALIZA_RECUPERA "<<<" +#define SINALIZA_COMENTARIO "!!!" + + +/*********************************************************************** +* +* $TC Tipo de dados: TST Cond ret módulo de teste específico +* +* +* $ED Descrição do tipo +* Este tipo enumera todas as condições de retorno que podem ser +* geradas pela função de teste específica. +* +***********************************************************************/ + + typedef enum { + + TST_CondRetOK , + /* Comando de teste executou corretamente */ + + TST_CondRetErro , + /* Comando de teste encontrou uma ou mais falhas + * + *$ED Descrição + * Esta condição sinaliza que um ou mais resultados da execução + * da função sob teste resultou em um valor diferente do esperado. */ + + TST_CondRetParm , + /* Comando de teste está com a sintaxe em erro + * + *$ED Descrição + * A presente condição de retorno deve ser retornada caso a sintaxe + * ou os valores do comando de teste estiverem em erro. + * + * Todos os fragmentos de interpretação devem: + * - realizar a análise dos parâmetros do comando + * - verificar se todos os parâmetros foram lidos + * - verificar se os valores dos parâmetros estão corretos + * por exemplo: verificar se os índices de acesso a elementos + * estão dentro dos limites dos correspondentes vetores. + * - efetuar a função a testar + * - verificar se os resultados retornados por esta função estão + * corretos */ + + TST_CondRetNaoExecutou , + /* Comando de teste não se destina ao presente interpretador + * + *$ED Descrição + * Esta condição deve ser retornada por todas as funções de interpretação + * de comandos de teste relativas a módulos do próprio arcabouço, + * caso não tenha sido encontrado um comando válido. Isso permite + * estabelecer um "daisy chain" de interpretadores em que cada qual + * tenha finalidade específica no contexto do arcabouço. */ + + TST_CondRetNaoConhec , + /* Comando de teste não é conhecido + * + *$ED Descrição + * Esta condição deve ser retornada por todas as funções de interpretação + * de casos de teste específico visando determinado módulo em teste, + * sempre que esse interpretador não consiga identificar o comando. + * + * Cabe salientar a diferença entre TST_CondRetNaoExecutou e + * TST_CondRetNaoConhec. A primeira corresponde à não interpretação + * de um comando possivelmente válido em interpretadores subsequentes. + * A segunda corresponde a comandos não válidos considerando todos + * os interpretadores. */ + + TST_CondRetNaoImplementado , + /* Comando de teste não implementado + * + *$ED Descrição + * Esta condição deve ser retornada ao interpretar um comando de teste + * específico ainda não implementado. + * + * Recomenda-se que o desenvolvimento dos módulos sob teste e do + * correpondente módulo de teste específico se dê incrementalmente. + * Consequentemente diversos comandos não estarão implementados + * no início do desenvolvimento. Esta incompleteza poderá ser + * sinalizada com esta condição de retorno. */ + + TST_CondRetMemoria + /* Faltou memória para executar o comando + * + *$ED Descrição + * Esta condição deve ser retornada caso tenha ocorrido algum erro + * quando o módulo de teste específico tentar alocar memória ou + * outro recurso. */ + + } TST_tpCondRet ; + + +/*********************************************************************** +* +* $FC Função: TSTE &Efetuar comandos de teste específicos +* +* $ED Descrição da função +* Efetua os diversos comandos de teste específicos para o módulo +* sendo testado. +* +* Cada módulo de teste específico deve desenvolver esta função. +* Poderá conter diversas outras conforme necessário. No entanto +* estas devem todas ser funções encapsuladas no módulo (static) +* +* Freqüentemente é necessário desenvolver um contexto para o teste. +* Por exemplo, pode ser necessário tratar n elementos disponibilizados +* pelo módulo sob teste. Neste caso deveria ser criado um vetor +* global com referências para estas elemento. Ao iniciar os teste +* este vetor deverá ser inicializado. Ao terminar, os elementos do +* vetor referenciando algum elemento devem ser destruídos. +* +* Todos os controles de consistência devem ser realizados no +* módulo de teste específico. +* +* A função TST_EfetuarComando( ) deve retornar as condições de retorno +* identificadas no tipo TST_tpCondRet. +* +* As funções do módulo sob teste que retornam algum valor sempre +* devem sempre ter este valor verificado, mesmo sendo uma condição de +* retorno. Para fazer a vereficação da corretude, recomenda-se +* utilizar as funções TST_CompararXXX definidas no módulo genérico. +* Assegura-se assim a uniformidade da saída gerada durante o teste. +* +* Para realizar a análise de um comando de teste recomenda-se +* utilizar as funções definidas no módulo LerParm. Elas, além +* de realizarem a análise léxica, permitem o uso intercambiável +* de parâmetros simbólicos ou literais. Também realizam a +* verificação da corretude dos tipos dos parâmetros, contribuindo +* assim para a redução de erros de redação de scripts de teste +* que possam passar despercebidos. +* +* As funções a serem testadas que requeiram algum argumento, devem +* ser chamadas com valores (parâmetros) extraídos do comando de +* teste sendo executado. Use sempre as funções do módulo LerParm +* para realizar a análise sintática. +* +* $EP Parâmetros +* $P ComandoTeste - String contendo o comando +* +* $FV Valor retornado +* TST_CondRetXXX - veja a descriÓcão dos possíveis valores +* retornados na especificação do correspondente +* enum +* +***********************************************************************/ + + TST_tpCondRet TST_EfetuarComando( char * ComandoTeste ) ; + +#undef Tst_Espc_EXT + +/********** Fim do módulo de definição: TSTE Interface de teste específico **********/ + +#else +#endif diff --git a/MODULO BAR/Teste.script b/MODULO BAR/Teste.script new file mode 100644 index 0000000..b0afe22 --- /dev/null +++ b/MODULO BAR/Teste.script @@ -0,0 +1,36 @@ +// Script: TesteLista.script +// Autor: Arndt von Staa, Tassio Miranda +// Data: 23/10/2015 +// + +==Criar BAR Branco +=criarbar 1 'b' 0 + +==Criar BAR Preto +=criarbar 2 'p' 0 + +==Obter Cor do BAR Branco +=obtercorbar 1 'b' 0 + +==Obter Cor do BAR Preto +=obtercorbar 2 'p' 0 + +==Aumentar o BAR Branco em 2 peças +=addbar 1 0 +=addbar 1 0 + +==Obter Tamaho do BAR Branco com 2 pecas +=obtertamanhobar 1 2 0 + +==Remover 2 peças do BAR Branco +=removerbar 1 0 +=removerbar 1 0 + +==Obter Tamaho do BAR Branco com 0 pecas +=obtertamanhobar 1 0 0 + +==Destruir BAR Branco +=destruirbar 1 0 + +==Destruir BAR Preto +=destruirbar 2 0 diff --git a/MODULO PF/ArcaboucoTeste.lib b/MODULO PF/ArcaboucoTeste.lib new file mode 100644 index 0000000..41ba199 Binary files /dev/null and b/MODULO PF/ArcaboucoTeste.lib differ diff --git a/MODULO PF/GENERICO.H b/MODULO PF/GENERICO.H new file mode 100644 index 0000000..dcf7430 --- /dev/null +++ b/MODULO PF/GENERICO.H @@ -0,0 +1,713 @@ +#if ! defined( GENERICO_ ) +#define GENERICO_ +/*************************************************************************** +* +* $MCD Módulo de definição: TSTG Controlador de teste genérico +* +* Arquivo gerado: GENERICO.h +* Letras identificadoras: TST +* +* Nome da base de software: Arcabouço para a automação de testes de programas redigidos em C +* Arquivo da base de software: C:\AUTOTEST\PROJETOS\INSTRUM.BSW +* +* Projeto: INF 1301 / 1628 Automatização dos testes de módulos C +* Gestor: LES/DI/PUC-Rio +* Autores: avs +* +* $HA Histórico de evolução: +* Versão Autor Data Observações +* 4 avs 01/fev/2006 criar linguagem script simbólica +* 3 avs 08/dez/2004 uniformização dos exemplos +* 2 avs 07/jul/2003 unificação de todos os módulos em um só projeto +* 1 avs 16/abr/2003 início desenvolvimento +* +* $ED Descrição do módulo +* O módulo de teste genérico contém um conjunto de funções de +* coordenação, apoio e controle da execução de testes de módulos +* quaisquer. +* +* Embora na prática a função de teste específica seja uma extensão da +* função de teste genérica, a função de teste específica encontra-se em +* outro módulo. Desta forma as alterações necessárias para cada +* módulo a testar concentram-se exclusivamente naquele módulo. +* +* $EIU Interface com o usuário pessoa +* Os seguintes comandos genéricos estão definidos: +* +* linha em branco - faz nada +* +* // - comentário, é impresso no LOG +* +* == - título de caso de teste, o título é impresso no LOG +* +* =recuperar +* - Caso o comando imediatamente anterior ao comando +* =recuperar retorne TST_CondRetOK, obviemanete o comando +* executou corretamente, portanto o comando =recuperar +* reportará uma falha no script de teste, uma vez que não +* foi encontrada a falha esperada ao executar o comando. +* - Caso o comando antecessor retorne TST_CondRetErro, +* ou TST_CondRetParm (erro de parâmetros do comando) +* a falha reportada será desconsiderada, uma vez que +* era esperada. O comando =recuperar destina-se a +* apoiar o teste da corretude dos validadores de +* parâmetros dos comandos e das funções por eles +* ativadas. +* - caso o comando antecessor retorne outras condições, o +* comando =recuperar será tratado como falha. +* +* =bkpt - permite interagir com o depurador utilizado para +* desenvolver os módulos sob teste. O comando =bkpt +* executa um código "dummy" no qual pode ser inserido +* um "breakpoint" do depurador. Desta forma o teste pode +* prosseguir sem interrupção até o comando =bkpt. +* Para isto +* - apague ou desative todos os breakpoints do depurador +* - insira o comando =bkpt no script pouco antes do ponto +* de interrupção desejado +* - usando o depurador, estabeleça um breakpoint na linha de +* código: "Dummy = 0 ;" contida no módulo de teste +* genérico. Esta linha pode ser encontrada +* procurando por "BKPT_CMD" +* - dê partida no programa e espere até chegar ao breakpoint +* associado ao comando "dummy". Agora reative ou instale +* os breakpoints requeridos pela a sessão de depuração. +* e continue depurando +* +* =cancelar +* - termina a interpretação dos comandos de teste. +* Sempre sinaliza falha. +* +* =AceitaFalhasAcumuladas numFalhas +* - caso o contador de falhas registre numFalhas, ele será +* tornado zero. Este comando é similar a =recuperar. +* Difere deste por ser executado desde que o comando +* anterior não tenha reportado erro, tal como acontece +* com todos os comandos, exceto =recuperar. +* O comando permite recuperar falhas sinalizadas por +* módulos de apoio, tais como, leitor de parâmetros, +* contador de passagens e controle de espaço dinâmico. +* Caso o contador de número de falhas contenha um valor +* diferente de numFalhas, será reportado um erro e +* o contador é incrementado de 1. +* +* Os demais comandos são passados para as funções de teste específico. +* Primeiro para as do arcabouço, depois para a específica do módulo +* a testar. A última função de teste específico deve retornar a condição +* TST_CondRetNaoConhec caso não consiga interpretar a diretiva. +* +* $EIM Interface com outros módulos +* A primeira função do arcabouço ("framework") a ser chamada deve a +* sempre ser TST_InicializarTeste. Caso não o seja, ocorrerão erros +* de execução (assert). +* +* Após abra o arquivo de script executando a função +* TST_AbrirArquivoScript. Se for desejado gerar um log abra +* o arquivo corresponente com a função TST_AbrirArquivoLog. +* +* Depois de abrir os arquivos, execute os testes chamando a função +* TST_RealizarTeste. A função de teste genérico lerá todo o arquivo +* de script, retornando após concluir o teste. +* +* Após, termine o teste através da função TST_TerminarTeste. +* Esta função exibe as estatísticas do teste e, caso solicitado, +* acumula essas estatísticas em um arquivo acumulador (ver +* parâmetro /a do programa principal. +* +* As funções "TST_ObterXXX" podem ser utilizadas antes de fechar o +* módulo de teste para exibir o resumo do teste no módulo cliente do +* módulo de controle genérico. +* +* O programa cliente do módulo controle de teste genérico pode +* efetuar as operações acima repetidas vezes, permitindo, assim o +* teste envolvendo diversos arquivos scripts de teste. A saída +* de cada teste deve ser dirigida para um log específico, ou para +* stdout, uma vez que, ao abrir um arquivo log, o seu conteúdo será +* sempre destruído. +* +* O módulo de teste genérico também implementa diversas funções +* de comparação "TST_CompararXXX" use-as no módulo de controle de +* teste específico. Desta forma será assegurado o tratamento uniforme +* de todas as falhas possivelmente encontradas. +* +* O módulo disponibiliza ainda a função TST_ExibirPrefixo +* que gera uma linha de saída obedecendo aos padrões de interface +* estabelecidos. Sendo desejado pode-se adicionar textos à linha +* usando a funcao fprintf( TST_pArqLog , ... ). Um exemplo disso +* é quando se deseja imprimir informação complementar ao interpretar +* uma determinada diretiva. +* +* Finalmente, o módulo disponibiliza a função TST_NotificarFalha +* que incrementa o contador de falhas além de emitir uma mensagem +* de erro. +* +***************************************************************************/ + +#if defined( GENERICO_OWN ) + #define GENERICO_EXT +#else + #define GENERICO_EXT extern +#endif + +/***** Declarações exportadas pelo módulo *****/ + +#include "TST_Espc.h" + + +/*********************************************************************** +* +* $TC Tipo de dados: TST Cond ret módulo de teste genérico +* +* +***********************************************************************/ + + typedef enum { + + TST_CondOK , + /* Generico executou correto */ + + TST_CondNaoAbriu + /* Genérico não abriu arquivo */ + + } TST_tpCond ; + + +/*********************************************************************** +* +* $FC Função: TSTG &Inicializar o módulo de teste +* +* $ED Descrição da função +* Inicializa todas as variáveis globais exportadas e encapsuladas +* do módulo de teste genérico. +* +* Embora pouco recomendável (ver descrição do módulo TesteSpc) +* esta função pode ser alterada para assegurar o estabelecimento +* do contexto inicial do módulo TesteSpc. Este deve conter uma +* função de inicialização a ser chamada pela presente função. +* +***********************************************************************/ + + void TST_InicializarTeste( void ) ; + + +/*********************************************************************** +* +* $FC Função: TSTG &Terminar a execução do módulo de teste +* +* $ED Descrição da função +* Fecha todos os arquivos e desaloca todos os espaços de dados +* alocados sob controle do módulo de teste genérico +* +***********************************************************************/ + + void TST_TerminarTeste( void ) ; + + +/*********************************************************************** +* +* $FC Função: TSTG &Obter origem do nome da extensão de arquivo +* +* $ED Descrição da função +* Procura o início do nome da extensão contido no nome do arquivo +* dado por parâmetro +* +* Evite o uso de nomes de arquivos com dois ou mais caracteres ".". +* Isto pode confundir no caso de se desejar a adição de algum nome +* de extensão padrão. +* +* $EP Parâmetros +* $P NomeArqParm - nome de arquivo a ser analisado +* +* $FV Valor retornado +* Ponteiro para o caractere '.' que separa a extensão. +* Será NULL caso o nome do arquivo não contenha extensão. +* +***********************************************************************/ + + char * TST_ObterInicioExtensao( char * NomeArqParm ) ; + + +/*********************************************************************** +* +* $FC Função: TSTG &Abrir arquivo log +* +* $ED Descrição da função +* Abre o arquivo log a ser utilizado como saída durante os testes. +* Todas as saídas geradas pelo módulo de teste são dirigidos para +* este arquivo. Caso não tenha sido aberto, será utilizado o +* arquivo stdout. +* +* A extensão default do arquivo log é ".log" e será acrescida ao nome +* do arquivo caso este não contenha nome de extensão. +* +* $EP Parâmetros +* $P NomeArqParm - nome do arquivo. Pode (deve) ser um nome relativo +* ao diretório corrente. Caso o arquivo +* exista, será destruido sem perguntar se pode. +* +* $FV Valor retornado +* TST_CondRetOK - abriu corretamente +* TST_CondRetNaoAbriu - ocorreu algum problema ao tentar abrir. +* O problema não é descriminado. +* O arquivo de saída do log volta a ser stdout +* +* $EIU Interface com usuário pessoa +* Esta função deve ser chamada antes de iniciar a execução dos testes. +* +***********************************************************************/ + + TST_tpCondRet TST_AbrirArquivoLog( char * NomeArqParm ) ; + + +/*********************************************************************** +* +* $FC Função: TSTG &Obter ponteiro para arquivo LOG +* +* $ED Descrição da função +* Retorna o ponteiro para o FILE do log. +* Será stdout caso não seja definido explicitamente por +* TSTG_DefinirLog +* +* $FV Valor retornado +* Ponteiro válido para um arquivo de texto de saída +* +***********************************************************************/ + + FILE * TST_ObterArqLog( void ) ; + + +/*********************************************************************** +* +* $FC Função: TSTG &Registrar nome do arquivo acumulador +* +* $ED Descrição da função +* Registra o nome do arquivo acumulador. Este arquivo é utilizado +* para acumular as estatísticas de um teste formado por um conjunto +* de massas de teste. Cada massa de teste gera o seu conjunto de +* estatísticas de execução. O arquivo acumulador acumula estas +* estatísticas permitindo ver o total de todas as massas de teste. +* +* $EIU Interface com usuário pessoa +* O arquivo acumulador tem serventia somente se o teste é formado +* por um conjunto de duas ou mais massas de teste. +* Antes de executar a primeira deve ser apagado o arquivo acumulador. +* Após terminar a execução da última massa de teste exiba o resultado +* como o programa "ExbeEstat" que faz parte do arcabouço. +* +***********************************************************************/ + + void TST_RegistrarArquivoAcumulador( char * pNomeArquivoAcumulador ) ; + + +/*********************************************************************** +* +* $FC Função: TSTG &Interpretar toda a massa de teste +* +* $ED Descrição da função +* Interpreta o arquivo de diretivas (script) de teste já aberto +* +* A função de teste é dividida em três classes de comandos: +* +* - os de teste genérico, que coordenam e controlam a realização do +* teste. Estes comandos são interpretados por esta função. +* - os de teste e controle de módulos componentes do arcabouço. +* Estes comandos são interpretados por funções de teste específicas +* para cada um dos módulos componentes. +* - os de teste específico do módulo (ou módulos) a ser testado. +* O módulo de teste específico interpreta os comandos projetados +* para realizar os testes do módulo a testar. +* +* A função de teste genérico lê um arquivo de diretivas de teste. +* Cada linha deste arquivo é um comando de teste. +* A função de teste lê uma a uma as linhas do arquivo, limpa os +* caracteres em branco no final da linha e procura interpretar o +* comando. +* +* As funções de teste específicas comunicam os resultados da execução +* de cada comando por meio de uma condição de retorno. +* +* Cada linha do arquivo script de teste corresponde a um comando de +* teste. +* +* Caso seja encontrada uma falha não esperada (ver comando =recuperar) +* os restantes comandos do caso de teste serão ignorados e contados +* como problemas. +* +* A sintaxe utilizada pelos comandos de teste é semelhante a assembler. +* Esta sintaxe facilita a análise: +* +* = +* +* em que: +* = - todos os comandos a serem interpretados iniciam +* com este caractere +* - é o string que identifica o comando +* - são zero ou mais itens a serem utilizados +* pelo comando de teste. Os itens devem, de preferência, +* ser separados um do outro por um caractere "espaço" +* +* Deve ser adotado o seguinte padrão de uso: +* +* - procure sempre utlizar uma das funções TST_CompararXXX, na forma: +* return TST_CompararXXX( valoresperado, funcao a testar , mensagem ) +* +* - as funções de comparação fornecidas sempre geram as mensagens no +* padrão estipulado +* +* - quando não for possível utilizar uma função de comparação, reporte +* a falha, esperadas ou não, através da função +* TST_ImprimirPrefixo( Mensagem ) +* +* - a seguir mostre o valor esperado e o obtido +* +* - Informações relativas a falhas dos testes são sinalizadas por +* uma mensagem iniciando com ">>>" o número da linha do comando de teste +* e o número de falhas encontradas até o momento. +* +* - Informações relativas à execução dos testes são sinalizadas por +* uma mensagem iniciando com "!!!". +* +* $FV Valor retornado +* TST_CondRetErro - caso tenha sido encontrado um ou mais problemas +* TST_CondRetOK - caso o teste tenha terminado com zero problemas +* não esperados. +* +* $FGP Tipos e Variáveis globais externas do próprio módulo +* pArqScript - deve referenciar o arquivo script aberto +* pArqLog - deve referenciar o arquivo log aberto +* +***********************************************************************/ + + TST_tpCondRet TST_RealizarTeste( char * Construto ) ; + + +/*********************************************************************** +* +* $FC Função: TSTG &Obter número de casos de teste efetuados +* +* $ED Descrição da função +* Retorna o número de casos de teste lidos. +* Cada caso de teste inicia com o comando "== ". +* +***********************************************************************/ + + int TST_ObterNumCasosTeste( ) ; + + +/*********************************************************************** +* +* $FC Função: TSTG &Obter número de comandos específicos corretamente interpretados +* +* $ED Descrição da função +* Retorna o número de comandos de teste específicos lidos e +* corretamente interpretados. Não conta comandos que retornem não OK +* independentemento do motivo. Também não conta comandos recuperar. +* +***********************************************************************/ + + int ObterNumComandosExecutados( void ) ; + + +/*********************************************************************** +* +* $FC Função: TSTG &Obter número de problemas encontrados +* +* $ED Descrição da função +* Retorna o número de problemas encontrados. +* O módulo de teste específico sinaliza problemas através de +* uma condição de retorno diferente de TST_CondRetOK. +* São tratados como problema também comandos de teste em erro, +* e todos os comandos de teste de um dado caso de teste ignorados +* em virtude de alguma falha encontrada. +* Portanto, é possível que o número de problemas venha a ser maior do +* que o número de casos de teste existente no script. +* +***********************************************************************/ + + int TST_ObterNumFalhas( void ) ; + + +/*********************************************************************** +* +* $FC Função: TSTG &Incrementar contador de falhas +* +***********************************************************************/ + + void TST_ContarFalhas( ) ; + + +/*********************************************************************** +* +* $FC Função: TSTG &Comparar booleano +* +* $ED Descrição da função +* Compara valor booleano esperado com valor booleano obtido, +* reportamdo uma falha caso não sejam iguais. +* Note que "!= 0" corresponde a TRUE e "== 0" corresponde a FALSE +* +* $EP Parâmetros +* ValorEsperado - é um valor fornecido como parâmetro do comando +* de teste +* ValorObtido - é o valor retornado pela função em teste +* pMensagem - mensagem explanatória da falha encontrada +* +* $FV Valor retornado +* TST_CondRetErro se o valor esperado não for consistente com o obtido +* TST_CondRetOK se os valores forem consistentes +* +***********************************************************************/ + + TST_tpCondRet TST_CompararBool( int ValorEsperado , + int ValorObtido , + char * pMensagem ) ; + + +/*********************************************************************** +* +* $FC Função: TSTG &Comparar caractere +* +* $ED Descrição da função +* Compara um caractere esperado com um caractere obtido, emitindo mensagem de +* erro caso não sejam iguais. +* +* $EP Parâmetros +* ValorEsperado - é um valor fornecido como parâmetro do comando +* de teste +* ValorObtido - é o valor retornado pela função em teste +* pMensagem - mensagem explanatória da falha encontrada +* +* $FV Valor retornado +* TST_CondRetErro se o valor esperado não for igual ao obtido +* TST_CondRetOK se os valores forem iguais +* +***********************************************************************/ + + TST_tpCondRet TST_CompararChar( char ValorEsperado , + char ValorObtido , + char * pMensagem ) ; + + +/*********************************************************************** +* +* $FC Função: TSTG &Comparar inteiro +* +* $ED Descrição da função +* Compara valor inteiro long esperado com valor inteiro obtido, +* reportamdo uma falha caso não sejam iguais. +* +* $EP Parâmetros +* ValorEsperado - é um valor fornecido como parâmetro do comando +* de teste +* ValorObtido - é o valor retornado pela função em teste +* pMensagem - mensagem explanatória da falha encontrada +* +* $FV Valor retornado +* TST_CondRetErro se o valor esperado não for igual ao obtido +* TST_CondRetOK se os valores forem iguais +* +***********************************************************************/ + + TST_tpCondRet TST_CompararInt( long ValorEsperado , + long ValorObtido , + char * pMensagem ) ; + + +/*********************************************************************** +* +* $FC Função: TSTG &Comparar flutuante +* +* $ED Descrição da função +* Compara valor flutuante esperado com valor flutuante obtido, +* reportando uma falha caso +* 1 - Tolerancia > esperado / obtido ou +* 1 + Tolerancia < esperado / obtido +* +* $EP Parâmetros +* ValorEsperado - é um valor fornecido como parâmetro do comando +* de teste +* ValorObtido - é o valor retornado pela função em teste +* Tolerância - indica os limites da relação entre esperado e obtido. +* Deve ser um valor positivo, menor do que 1. +* Use um valor do tipo 10 ** -n, no qual n é o +* número de dígitos significativos desejado. +* pMensagem - mensagem explanatória da falha encontrada +* +* $FV Valor retornado +* TST_CondRetErro se o valor obtido não estiver dentro do domínio da +* tolerância em torno do valor esperado +* TST_CondRetOK se os valores estiverem dentro da tolerância +* +***********************************************************************/ + + TST_tpCondRet TST_CompararFloat( double ValorEsperado , + double ValorObtido , + double Tolerancia , + char * pMensagem ) ; + + +/*********************************************************************** +* +* $FC Função: TSTG &Comparar string +* +* $ED Descrição da função +* Compara string esperado com string obtido, reportamdo uma falha +* caso não sejam iguais. Ambos os strings devem obedecer o +* padrão C, terminando em zero. +* +* $EP Parâmetros +* ValorEsperado - é um string fornecido como parâmetro do comando +* de teste. +* ValorObtido - é o string retornado pela função em teste +* pMensagem - mensagem explanatória da falha encontrada +* +* $FV Valor retornado +* TST_CondRetErro se o valor esperado não for igual ao obtido +* TST_CondRetOK se os valores forem iguais +* +***********************************************************************/ + + TST_tpCondRet TST_CompararString( char * ValorEsperado , + char * ValorObtido , + char * pMensagem ) ; + + +/*********************************************************************** +* +* $FC Função: TSTG &Comparar espaço +* +* $ED Descrição da função +* Compara espaços de dados, reportando uma falha caso não sejam iguais. +* Esta função pode ser utilizada para comparar qualquer coisa, +* inclusive valores do tipo "struct" +* O tipo do valor é indefinido e os valores serão exibidos em +* formato hexadecimal, caso não sejam iguais +* +* $EP Parâmetros +* ValorEsperado - ponteiro para o espaço que contém o valor esperado +* ValorObtido - ponteiro para o espaço que contém o valor obtido +* TamEspaco - tamanho do espaço a ser comparado +* pMensagem - mensagem explanatória da falha encontrada +* +* $FV Valor retornado +* TST_CondRetErro se o valor esperado não for igual ao obtido +* TST_CondRetOK se os valores forem iguais +* +***********************************************************************/ + + TST_tpCondRet TST_CompararEspaco( void * ValorEsperado , + void * ValorObtido , + int TamEspaco , + char * pMensagem ) ; + + +/*********************************************************************** +* +* $FC Função: TSTG &Comparar ponteiro +* +* $ED Descrição da função +* Compara dois ponteiros emitindo uma mensagem caso não sejam iguais +* +* $FV Valor retornado +* TST_CondRetErro se os dois ponteiros forem diferentes +* TST_CondRetOK se forem iguais +* +***********************************************************************/ + + TST_tpCondRet TST_CompararPonteiro( void * PonteiroEsperado , + void * PonteiroObtido , + char * pMensagem ) ; + + +/*********************************************************************** +* +* $FC Função: TSTG &Comparar ponteiro nulo +* +* $ED Descrição da função +* Verifica +* - quando ModoEsperado é 0 se o ponteiro é nulo +* - quando ModoEsperado não é 0 se o ponteiro é não nulo +* +* $FV Valor retornado +* TST_CondRetErro se os dois ponteiros forem diferentes +* TST_CondRetOK se forem iguais +* +***********************************************************************/ + + TST_tpCondRet TST_CompararPonteiroNulo( int ModoEsperado , + void * PonteiroObtido , + char * pMensagem ) ; + + +/*********************************************************************** +* +* $FC Função: TSTG &Assertiva controlada +* +* $ED Descrição da função +* Esta função substitui a função assert de C. +* É utilizada no contexto do arcabouço de teste. +* Ela imprime mensagens mais visíveis tanto no log como na +* janela de comando. +* +* Recomenda-se, no entanto, utilizar a função assert de C em aplicações. +* +* $FV Valor retornado +* Termina a execução do programa com código de retorno == 4 +* +***********************************************************************/ + + #define TST_ASSERT( Expressao ) \ + TST_Assert( Expressao , __LINE__ , __FILE__ ) + + void TST_Assert( int Expressao , int Linha , char * NomeArq ) ; + + +/*********************************************************************** +* +* $FC Função: TSTG &Notificar falha +* +* $ED Descrição da função +* Exibe uma mensagem de falha no formato padrão do arcabouço. +* +* $FV Valor retornado +* TST_CondRetErro sempre +* +***********************************************************************/ + + TST_tpCondRet TST_NotificarFalha( char * pMensagem ) ; + + +/*********************************************************************** +* +* $FC Função: TSTG &Exibir prefixo da mensagem +* +* $ED Descrição da função +* Imprime o prefixo de mensages de falha +* +* $EH Hipóteses assumidas pela função +* O contador de falhas é incrementado somente pela função de teste +* genérica e após à conclusão da interpretação do comando. +* +***********************************************************************/ + + void TST_ExibirPrefixo( char * Indicador , char * pMensagem ) ; + + +/*********************************************************************** +* +* $FC Função: TSTG &Exibir um espaço qualquer em formato hexadecimal e char +* +* $EP Parâmetros +* $P tamEspaco - tamanho em bytes do espaço a exibir +* $P Ponteiro - ponteiro para o primeiro byte do espaço a exibir +* +***********************************************************************/ + + void TST_ExibirEspacoHexa( int tamEspaco , + void * Ponteiro ) ; + +#undef GENERICO_EXT + +/********** Fim do módulo de definição: TSTG Controlador de teste genérico **********/ + +#else +#endif diff --git a/MODULO PF/LERPARM.H b/MODULO PF/LERPARM.H new file mode 100644 index 0000000..a15de36 --- /dev/null +++ b/MODULO PF/LERPARM.H @@ -0,0 +1,291 @@ +#if ! defined( LerParm_ ) +#define LerParm_ +/*************************************************************************** +* +* $MCD Módulo de definição: LER Ler parâmetros de comandos +* +* Arquivo gerado: LerParm.h +* Letras identificadoras: LER +* +* Nome da base de software: Arcabouço para a automação de testes de programas redigidos em C +* Arquivo da base de software: C:\AUTOTEST\PROJETOS\INSTRUM.BSW +* +* Projeto: INF 1301 / 1628 Automatização dos testes de módulos C +* Gestor: LES/DI/PUC-Rio +* Autores: avs +* +* $HA Histórico de evolução: +* Versão Autor Data Observações +* 4 avs 01/fev/2006 criar linguagem script simbólica +* 3 avs 08/dez/2004 uniformização dos exemplos +* 2 avs 07/jul/2003 unificação de todos os módulos em um só projeto +* 1 avs 16/abr/2003 início desenvolvimento +* +* $ED Descrição do módulo +* Le parâmetros contidos em um buffer. +* Os parâmetros podem ser simbólicos ou literais. +* Parâmetros simbólicos devem ser declarados antes de serem utilizados. +* +***************************************************************************/ + +#if defined( LerParm_OWN ) + #define LerParm_EXT +#else + #define LerParm_EXT extern +#endif + +/***** Declarações exportadas pelo módulo *****/ + +#define LER_DIM_NOME 32 +#define LER_DIM_STRING 500 +#define LER_DIM_BUFFER 250 + + +/*********************************************************************** +* +* $TC Tipo de dados: LER Condições de retorno +* +* +***********************************************************************/ + + typedef enum { + + LER_CondRetOK , + /* Ler retorno OK */ + + LER_CondRetNaoAbriu + /* Ler não abriu arquivo */ + + } LER_tpCondRet ; + +/***** Dados exportados pelo módulo *****/ + + /* Estrutura de dados: *LER Dados globais públicos */ + + LerParm_EXT int LER_TamBuffer ; + /* Tamanho do string contido no buffer de leitura */ + + LerParm_EXT char LER_Buffer[ LER_DIM_BUFFER + 1 ] ; + /* Buffer de leitura */ + + +/*********************************************************************** +* +* $FC Função: LER &Inicializar módulo LerParm +* +* $ED Descrição da função +* Inicializa o módulo. +* Deve ser chamada antes de iniciar a análise de comandos. +* Deve ser chamada uma única vez no início ou após terminar o módulo. +* +***********************************************************************/ + + int LER_InicializarLeitura( void ) ; + + +/*********************************************************************** +* +* $FC Função: LER &Obter nome do arquivo script +* +***********************************************************************/ + + char * LER_ObterNomeArqScript( void ) ; + + +/*********************************************************************** +* +* $FC Função: LER &Interpretar comandos de teste +* +* $ED Descrição da função +* Interpreta os comandos de teste disponibilizados pelo módulo +* de leitura. +* +* Ver a descrição do módulo para mais detalhes +* +***********************************************************************/ + + TST_tpCondRet LER_InterpretarComandos( char * ComandoTeste ) ; + + +/*********************************************************************** +* +* $FC Função: LER &Terminar módulo LerParm +* +***********************************************************************/ + + void LER_TerminarLeitura( void ) ; + + +/*********************************************************************** +* +* $FC Função: LER &Abrir arquivo script de teste +* +* $ED Descrição da função +* Abre o arquivo que contém o script de teste. +* A extensão default do arquivo de comandos script de teste é +* ".script" e será acrescida ao nome do arquivo caso este não +* contenha nome de extensão. +* +* $EP Parâmetros +* $P NomeArqParm - nome do arquivo contendo o script de teste +* +* $FV Valor retornado +* LER_CondRetOK - caso tenha sido possível abrir o arquivo. +* LER_CondRetNaoAbriu - caso tenha ocorrido algum erro. +* Não há discriminação do erro encontrado. +* +***********************************************************************/ + + LER_tpCondRet LER_AbrirArquivoScript( char * NomeArqParm ) ; + + +/*********************************************************************** +* +* $FC Função: LER &Fechar arquivo script +* +***********************************************************************/ + + void LER_FecharScript( void ) ; + + +/*********************************************************************** +* +* $FC Função: LER &Declarar parâmetro simbólico +* +***********************************************************************/ + + int LER_DeclararParametro( void ) ; + + +/*********************************************************************** +* +* $FC Função: LER &Exibir declaração de símbolo +* +***********************************************************************/ + + void LER_ExibirParametro( char * Simbolo ) ; + + +/*********************************************************************** +* +* $FC Função: LER &Ler linha script eliminando brancos ao final +* +* $ED Descrição da função +* Lê uma linha do arquivo script e elimina os caracteres branco, +* fim de linha, tabulação etc. do final da linha lida. +* +* $FV Valor retornado +* Retorna o tamanho da linha lida. +* Será: +* -1 caso tenha ocorrido fim de arquivo. +* -2 caso tenha ocorrido algum problema de leitura. +* +***********************************************************************/ + + int LER_LerLinhaScript( void ) ; + + +/*********************************************************************** +* +* $FC Função: LER &Obter número de linhas lidas até o momento +* +***********************************************************************/ + + int LER_ObterNumLinhas( void ) ; + + +/*********************************************************************** +* +* $FC Função: LER &Ler linha de parâmetros +* +* $ED Descrição da função +* Lê um número variável de parâmetros +* +* $EP Parâmetros +* Tipos é um string contendo a identificação dos tipos dos parâmetros +* a serem lidos. +* ... Os demais parâmetros são referências (ponteiros) para os +* espaços onde deverão ser armazenados os valores lidos. +* +* Tal como em scanf deve-se tomar o cuidado de assegurar que a lista +* de referência e o string de tipos tenha o mesmo tamanho +* e que os indicadores de tipo sejam consistentes com a referência +* posicionalmente correspondente. +* +* Ao ler um campo primeiro procura ler um nome de parâmetro já +* declarado. Caso isto seja possível e o tipo esteja correto +* é " lido" o valor contido no parâmetro +* Caso não seja possível tenta ler um literal em acordo com o tipo +* dado. +* +* Gera mensagens de erro para parâmetros desconhecidos, sintaxe errada +* e tipo inconsistente com o solicitado. +* +* $FV Valor retornado +* Retorna o número de campos lidos até concluir ou até encontrar +* um erro. +* +***********************************************************************/ + + int LER_LerParametros( char * Tipos , ... ) ; + + +/*********************************************************************** +* +* $FC Função: LER &Ler parâmetro caractere +* +***********************************************************************/ + + int LER_LerParmChar( char * Parm ) ; + + +/*********************************************************************** +* +* $FC Função: LER &Ler parâmetro flutuante +* +***********************************************************************/ + + int LER_LerParmDouble( double * Parm ) ; + + +/*********************************************************************** +* +* $FC Função: LER &Ler parâmetro nome +* +***********************************************************************/ + + int LER_LerParmNome( char * Parm , int * tamNome , int dimNome ) ; + + +/*********************************************************************** +* +* $FC Função: LER &Ler parâmetro inteiro +* +***********************************************************************/ + + int LER_LerParmInt( int * Parm ) ; + + +/*********************************************************************** +* +* $FC Função: LER &Ler parâmetro string +* +***********************************************************************/ + + int LER_LerParmString( char * Parm , int * tamString , int dimString ) ; + + +/*********************************************************************** +* +* $FC Função: LER &Pular comando de teste +* +***********************************************************************/ + + void LER_PularComando( void ) ; + +#undef LerParm_EXT + +/********** Fim do módulo de definição: LER Ler parâmetros de comandos **********/ + +#else +#endif diff --git a/MODULO PF/LISTA.C b/MODULO PF/LISTA.C new file mode 100644 index 0000000..2e9726d --- /dev/null +++ b/MODULO PF/LISTA.C @@ -0,0 +1,570 @@ +/*************************************************************************** +* $MCI Módulo de implementação: LIS Lista duplamente encadeada +* +* Arquivo gerado: LISTA.c +* Letras identificadoras: LIS +* +* Nome da base de software: Arcabouço para a automação de testes de programas redigidos em C +* Arquivo da base de software: D:\AUTOTEST\PROJETOS\LISTA.BSW +* +* Projeto: INF 1301 / 1628 Automatização dos testes de módulos C +* Gestor: LES/DI/PUC-Rio +* Autores: avs +* +* $HA Histórico de evolução: +* Versão Autor Data Observações +* 4 avs 01/fev/2006 criar linguagem script simbólica +* 3 avs 08/dez/2004 uniformização dos exemplos +* 2 avs 07/jul/2003 unificação de todos os módulos em um só projeto +* 1 avs 16/abr/2003 início desenvolvimento +* +***************************************************************************/ + +#include +#include +#include +#include +#include + +#define LISTA_OWN +#include "LISTA.h" +#undef LISTA_OWN + +/*********************************************************************** +* +* $TC Tipo de dados: LIS Elemento da lista +* +* +***********************************************************************/ + + typedef struct tagElemLista { + + void * pValor ; + /* Ponteiro para o valor contido no elemento */ + + struct tagElemLista * pAnt ; + /* Ponteiro para o elemento predecessor */ + + struct tagElemLista * pProx ; + /* Ponteiro para o elemento sucessor */ + + } tpElemLista ; + +/*********************************************************************** +* +* $TC Tipo de dados: LIS Descritor da cabeça de lista +* +* +***********************************************************************/ + + typedef struct LIS_tagLista { + + tpElemLista * pOrigemLista ; + /* Ponteiro para a origem da lista */ + + tpElemLista * pFimLista ; + /* Ponteiro para o final da lista */ + + tpElemLista * pElemCorr ; + /* Ponteiro para o elemento corrente da lista */ + + int numElem ; + /* Número de elementos da lista */ + + void ( * ExcluirValor ) ( void * pValor ) ; + /* Ponteiro para a função de destruição do valor contido em um elemento */ + + } LIS_tpLista ; + +/***** Protótipos das funções encapuladas no módulo *****/ + + static void LiberarElemento( LIS_tppLista pLista , + tpElemLista * pElem ) ; + + static tpElemLista * CriarElemento( LIS_tppLista pLista , + void * pValor ) ; + + static void LimparCabeca( LIS_tppLista pLista ) ; + +/***** Código das funções exportadas pelo módulo *****/ + +/*************************************************************************** +* +* Função: LIS &Criar lista +* ****/ + + 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 */ + + LimparCabeca( pLista ) ; + + pLista->ExcluirValor = ExcluirValor ; + + return pLista ; + + } /* Fim função: LIS &Criar lista */ + +/*************************************************************************** +* +* Função: LIS &Destruir lista +* ****/ + + void LIS_DestruirLista( LIS_tppLista pLista ) + { + + #ifdef _DEBUG + assert( pLista != NULL ) ; + #endif + + LIS_EsvaziarLista( pLista ) ; + + free( pLista ) ; + + } /* Fim função: LIS &Destruir lista */ + +/*************************************************************************** +* +* Função: LIS &Esvaziar lista +* ****/ + + void LIS_EsvaziarLista( LIS_tppLista pLista ) + { + + tpElemLista * pElem ; + tpElemLista * pProx ; + + #ifdef _DEBUG + assert( pLista != NULL ) ; + #endif + + pElem = pLista->pOrigemLista ; + while ( pElem != NULL ) + { + pProx = pElem->pProx ; + LiberarElemento( pLista , pElem ) ; + pElem = pProx ; + } /* while */ + + LimparCabeca( pLista ) ; + + } /* Fim função: LIS &Esvaziar lista */ + +/*************************************************************************** +* +* Função: LIS &Inserir elemento antes +* ****/ + + LIS_tpCondRet LIS_InserirElementoAntes( LIS_tppLista pLista , + void * pValor ) + { + + tpElemLista * pElem ; + + #ifdef _DEBUG + assert( pLista != NULL ) ; + #endif + + /* Criar elemento a inerir antes */ + + pElem = CriarElemento( pLista , pValor ) ; + if ( pElem == NULL ) + { + return LIS_CondRetFaltouMemoria ; + } /* if */ + + /* Encadear o elemento antes do elemento corrente */ + + if ( pLista->pElemCorr == NULL ) + { + pLista->pOrigemLista = pElem ; + pLista->pFimLista = pElem ; + } else + { + if ( pLista->pElemCorr->pAnt != NULL ) + { + pElem->pAnt = pLista->pElemCorr->pAnt ; + pLista->pElemCorr->pAnt->pProx = pElem ; + } else + { + pLista->pOrigemLista = pElem ; + } /* if */ + + pElem->pProx = pLista->pElemCorr ; + pLista->pElemCorr->pAnt = pElem ; + } /* if */ + + pLista->pElemCorr = pElem ; + + return LIS_CondRetOK ; + + } /* Fim função: LIS &Inserir elemento antes */ + +/*************************************************************************** +* +* Função: LIS &Inserir elemento após +* ****/ + + LIS_tpCondRet LIS_InserirElementoApos( LIS_tppLista pLista , + void * pValor ) + + { + + tpElemLista * pElem ; + + #ifdef _DEBUG + assert( pLista != NULL ) ; + #endif + + /* Criar elemento a inerir após */ + + pElem = CriarElemento( pLista , pValor ) ; + if ( pElem == NULL ) + { + return LIS_CondRetFaltouMemoria ; + } /* if */ + + /* Encadear o elemento após o elemento */ + + if ( pLista->pElemCorr == NULL ) + { + pLista->pOrigemLista = pElem ; + pLista->pFimLista = pElem ; + } else + { + if ( pLista->pElemCorr->pProx != NULL ) + { + pElem->pProx = pLista->pElemCorr->pProx ; + pLista->pElemCorr->pProx->pAnt = pElem ; + } else + { + pLista->pFimLista = pElem ; + } /* if */ + + pElem->pAnt = pLista->pElemCorr ; + pLista->pElemCorr->pProx = pElem ; + + } /* if */ + + pLista->pElemCorr = pElem ; + + return LIS_CondRetOK ; + + } /* Fim função: LIS &Inserir elemento após */ + +/*************************************************************************** +* +* Função: LIS &Excluir elemento +* ****/ + + LIS_tpCondRet LIS_ExcluirElemento( LIS_tppLista pLista ) + { + + tpElemLista * pElem ; + + #ifdef _DEBUG + assert( pLista != NULL ) ; + #endif + + if ( pLista->pElemCorr == NULL ) + { + return LIS_CondRetListaVazia ; + } /* if */ + + pElem = pLista->pElemCorr ; + + /* Desencadeia à esquerda */ + + if ( pElem->pAnt != NULL ) + { + pElem->pAnt->pProx = pElem->pProx ; + pLista->pElemCorr = pElem->pAnt ; + } else { + pLista->pElemCorr = pElem->pProx ; + pLista->pOrigemLista = pLista->pElemCorr ; + } /* if */ + + /* Desencadeia à direita */ + + if ( pElem->pProx != NULL ) + { + pElem->pProx->pAnt = pElem->pAnt ; + } else + { + pLista->pFimLista = pElem->pAnt ; + } /* if */ + + LiberarElemento( pLista , pElem ) ; + + return LIS_CondRetOK ; + + } /* Fim função: LIS &Excluir elemento */ + +/*************************************************************************** +* +* Função: LIS &Obter referência para o valor contido no elemento +* ****/ + + void * LIS_ObterValor( LIS_tppLista pLista ) + { + + #ifdef _DEBUG + assert( pLista != NULL ) ; + #endif + + if ( pLista->pElemCorr == NULL ) + { + return NULL ; + } /* if */ + + return pLista->pElemCorr->pValor ; + + } /* Fim função: LIS &Obter referência para o valor contido no elemento */ + +/*************************************************************************** +* +* Função: LIS &Ir para o elemento inicial +* ****/ + + void IrInicioLista( LIS_tppLista pLista ) + { + + #ifdef _DEBUG + assert( pLista != NULL ) ; + #endif + + pLista->pElemCorr = pLista->pOrigemLista ; + + } /* Fim função: LIS &Ir para o elemento inicial */ + +/*************************************************************************** +* +* Função: LIS &Ir para o elemento final +* ****/ + + void IrFinalLista( LIS_tppLista pLista ) + { + + #ifdef _DEBUG + assert( pLista != NULL ) ; + #endif + + pLista->pElemCorr = pLista->pFimLista ; + + } /* Fim função: LIS &Ir para o elemento final */ + +/*************************************************************************** +* +* Função: LIS &Avançar elemento +* ****/ + + LIS_tpCondRet LIS_AvancarElementoCorrente( LIS_tppLista pLista , + int numElem ) + { + + int i ; + + tpElemLista * pElem ; + + #ifdef _DEBUG + assert( pLista != NULL ) ; + #endif + + /* Tratar lista vazia */ + + if ( pLista->pElemCorr == NULL ) + { + + return LIS_CondRetListaVazia ; + + } /* fim ativa: Tratar lista vazia */ + + /* Tratar avançar para frente */ + + if ( numElem > 0 ) + { + + pElem = pLista->pElemCorr ; + for( i = numElem ; i > 0 ; i-- ) + { + if ( pElem == NULL ) + { + break ; + } /* if */ + pElem = pElem->pProx ; + } /* for */ + + if ( pElem != NULL ) + { + pLista->pElemCorr = pElem ; + return LIS_CondRetOK ; + } /* if */ + + pLista->pElemCorr = pLista->pFimLista ; + return LIS_CondRetFimLista ; + + } /* fim ativa: Tratar avançar para frente */ + + /* Tratar avançar para trás */ + + else if ( numElem < 0 ) + { + + pElem = pLista->pElemCorr ; + for( i = numElem ; i < 0 ; i++ ) + { + if ( pElem == NULL ) + { + break ; + } /* if */ + pElem = pElem->pAnt ; + } /* for */ + + if ( pElem != NULL ) + { + pLista->pElemCorr = pElem ; + return LIS_CondRetOK ; + } /* if */ + + pLista->pElemCorr = pLista->pOrigemLista ; + return LIS_CondRetFimLista ; + + } /* fim ativa: Tratar avançar para trás */ + + /* Tratar não avançar */ + + return LIS_CondRetOK ; + + } /* Fim função: LIS &Avançar elemento */ + +/*************************************************************************** +* +* Função: LIS &Procurar elemento contendo valor +* ****/ + + LIS_tpCondRet LIS_ProcurarValor( LIS_tppLista pLista , + void * pValor ) + { + + tpElemLista * pElem ; + + #ifdef _DEBUG + assert( pLista != NULL ) ; + #endif + + if ( pLista->pElemCorr == NULL ) + { + return LIS_CondRetListaVazia ; + } /* if */ + + for ( pElem = pLista->pElemCorr ; + pElem != NULL ; + pElem = pElem->pProx ) + { + if ( pElem->pValor == pValor ) + { + pLista->pElemCorr = pElem ; + return LIS_CondRetOK ; + } /* if */ + } /* for */ + + return LIS_CondRetNaoAchou ; + + } /* Fim função: LIS &Procurar elemento contendo valor */ + + +/*************************************************************************** +* +* Função: LIS &Obter o tamanho da lista +* ****/ + int LIS_ObterTamanho( LIS_tppLista pLista) + { + return pLista->numElem; + } /* Fim função: LIS &Obter referência para o tamanho da lista*/ + + +/***** Código das funções encapsuladas no módulo *****/ + + +/*********************************************************************** +* +* $FC Função: LIS -Liberar elemento da lista +* +* $ED Descrição da função +* Elimina os espaços apontados pelo valor do elemento e o +* próprio elemento. +* +***********************************************************************/ + + void LiberarElemento( LIS_tppLista pLista , + tpElemLista * pElem ) + { + + if ( ( pLista->ExcluirValor != NULL ) + && ( pElem->pValor != NULL )) + { + pLista->ExcluirValor( pElem->pValor ) ; + } /* if */ + + free( pElem ) ; + + pLista->numElem-- ; + + } /* Fim função: LIS -Liberar elemento da lista */ + + +/*********************************************************************** +* +* $FC Função: LIS -Criar o elemento +* +***********************************************************************/ + + tpElemLista * CriarElemento( LIS_tppLista pLista , + void * pValor ) + { + + tpElemLista * pElem ; + + pElem = ( tpElemLista * ) malloc( sizeof( tpElemLista )) ; + if ( pElem == NULL ) + { + return NULL ; + } /* if */ + + pElem->pValor = pValor ; + pElem->pAnt = NULL ; + pElem->pProx = NULL ; + + pLista->numElem ++ ; + + return pElem ; + + } /* Fim função: LIS -Criar o elemento */ + + +/*********************************************************************** +* +* $FC Função: LIS -Limpar a cabeça da lista +* +***********************************************************************/ + + void LimparCabeca( LIS_tppLista pLista ) + { + + pLista->pOrigemLista = NULL ; + pLista->pFimLista = NULL ; + pLista->pElemCorr = NULL ; + pLista->numElem = 0 ; + + } /* Fim função: LIS -Limpar a cabeça da lista */ + +/********** Fim do módulo de implementação: LIS Lista duplamente encadeada **********/ + diff --git a/MODULO PF/LISTA.H b/MODULO PF/LISTA.H new file mode 100644 index 0000000..2dadefc --- /dev/null +++ b/MODULO PF/LISTA.H @@ -0,0 +1,368 @@ +#if ! defined( LISTA_ ) +#define LISTA_ +/*************************************************************************** +* +* $MCD Módulo de definição: LIS Lista duplamente encadeada +* +* Arquivo gerado: LISTA.h +* Letras identificadoras: LIS +* +* Nome da base de software: Arcabouço para a automação de testes de programas redigidos em C +* Arquivo da base de software: D:\AUTOTEST\PROJETOS\LISTA.BSW +* +* Projeto: INF 1301 / 1628 Automatização dos testes de módulos C +* Gestor: LES/DI/PUC-Rio +* Autores: avs +* +* $HA Histórico de evolução: +* Versão Autor Data Observações +* 4 avs 01/fev/2006 criar linguagem script simbólica +* 3 avs 08/dez/2004 uniformização dos exemplos +* 2 avs 07/jul/2003 unificação de todos os módulos em um só projeto +* 1 avs 16/abr/2003 início desenvolvimento +* +* $ED Descrição do módulo +* Implementa listas genéricas duplamente encadeadas. +* Podem existir n listas em operação simultaneamente. +* As listas possuem uma cabeça encapsulando o seu estado. +* +* Cada lista é homogênea quanto ao tipo dos dados que armazena. +* Cada elemento da lista referencia o valor que contém. +* +* Os ponteiros para os dados são copiados para elementos da lista. +* Não é copiado o valor apontado por estes ponteiros. +* +* O controle da destruição do valor de um elemento a ser excluído +* é realizado por uma função fornecida pelo usuário. +* +* Cada lista referencia uma função que determina como devem ser +* desalocados os dados nela contidos. +* +* A função de liberação dos valores contidos nos elementos deve +* assegurar a liberação de todos os espaços referênciados pelo +* valor contido em um elemento. +* Esta função é chamada antes de se desalocar um elemento +* de uma lista. +* Caso não seja necessário desalocar o valor referenciado pelo +* elemento, o ponteiro para a função de liberação poderá ser NULL . +* Caso o elemento da lista seja a única âncora do valor referenciado, +* esta função deve promover a destruição (free) desse valor e +* de todos os dados nele ancorados. +* +***************************************************************************/ + +#if defined( LISTA_OWN ) + #define LISTA_EXT +#else + #define LISTA_EXT extern +#endif + +/***** Declarações exportadas pelo módulo *****/ + +/* Tipo referência para uma lista */ + +typedef struct LIS_tagLista * LIS_tppLista ; + + +/*********************************************************************** +* +* $TC Tipo de dados: LIS Condições de retorno +* +* +* $ED Descrição do tipo +* Condições de retorno das funções da lista +* +***********************************************************************/ + + typedef enum { + + LIS_CondRetOK , + /* Concluiu corretamente */ + + LIS_CondRetListaVazia , + /* A lista não contém elementos */ + + LIS_CondRetFimLista , + /* Foi atingido o fim de lista */ + + LIS_CondRetNaoAchou , + /* Não encontrou o valor procurado */ + + LIS_CondRetFaltouMemoria, + /* Faltou memória ao tentar criar um elemento de lista */ + + LIS_CondRetErro + /* Nao executou corretamente */ + + } LIS_tpCondRet ; + + +/*********************************************************************** +* +* $FC Função: LIS &Criar lista +* +* $ED Descrição da função +* Cria uma lista genérica duplamente encadeada. +* Os possíveis tipos são desconhecidos a priori. +* A tipagem é implicita. +* Não existe identificador de tipo associado à lista. +* +* $EP Parâmetros +* ExcluirValor - ponteiro para a função que processa a +* exclusão do valor referenciado pelo elemento +* a ser excluído. +* Ver descrição do módulo. +* +* $FV Valor retornado +* Se executou corretamente retorna o ponteiro para a lista. +* Este ponteiro será utilizado pelas funções que manipulem esta lista. +* +* Se ocorreu algum erro, por exemplo falta de memória ou dados errados, +* a função retornará NULL. +* Não será dada mais informação quanto ao problema ocorrido. +* +***********************************************************************/ + + LIS_tppLista LIS_CriarLista( + void ( * ExcluirValor ) ( void * pDado ) ) ; + + +/*********************************************************************** +* +* $FC Função: LIS &Destruir lista +* +* $ED Descrição da função +* Destrói a lista fornecida. +* O parâmetro ponteiro para a lista não é modificado. +* Se ocorrer algum erro durante a destruição, a lista resultará +* estruturalmente incorreta. +* OBS. não existe previsão para possíveis falhas de execução. +* +* $FV Valor retornado +* LIS_CondRetOK - destruiu sem problemas +* +***********************************************************************/ + + void LIS_DestruirLista( LIS_tppLista pLista ) ; + + +/*********************************************************************** +* +* $FC Função: LIS &Esvaziar lista +* +* $ED Descrição da função +* Elimina todos os elementos, sem contudo eliminar a lista +* +* $EP Parâmetros +* pLista - ponteiro para a lista a ser esvaziada +* +***********************************************************************/ + + void LIS_EsvaziarLista( LIS_tppLista pLista ) ; + + +/*********************************************************************** +* +* $FC Função: LIS &Inserir elemento antes +* +* $ED Descrição da função +* Insere novo elemento antes do elemento corrente. +* Caso a lista esteja vazia, insere o primeiro elemento da lista. +* +* $EP Parâmetros +* pLista - ponteiro para a lista onde deve ser inserido o elemento +* pValor - ponteiro para o valor do novo elemento +* Pode ser NULL +* +* $FV Valor retornado +* LIS_CondRetOK +* LIS_CondRetFaltouMemoria +* +***********************************************************************/ + + LIS_tpCondRet LIS_InserirElementoAntes( LIS_tppLista pLista , + void * pValor ) ; + + +/*********************************************************************** +* +* $FC Função: LIS &Inserir elemento após +* +* $ED Descrição da função +* Insere novo elemento apás o elemento corrente. +* Caso a lista esteja vazia, insere o primeiro elemento da lista. +* +* $EP Parâmetros +* Parâmetros +* pLista - ponteiro para a lista onde deve ser inserido o elemento +* pValor - ponteiro para o valor do novo elemento +* Pode ser NULL +* +* +* $FV Valor retornado +* Valor retornado +* LIS_CondRetOK +* LIS_CondRetFaltouMemoria +* +***********************************************************************/ + + LIS_tpCondRet LIS_InserirElementoApos( LIS_tppLista pLista , + void * pValor ) + ; + + +/*********************************************************************** +* +* $FC Função: LIS &Excluir elemento +* +* $ED Descrição da função +* Exclui o elemento corrente da lista dada. +* Se existir o elemento aa esquerda do corrente será o novo corrente. +* Se não existir e existir o elemento à direita, este se tornará corrente. +* Se este também não existir a lista tornou-se vazia. +* +* $EP Parâmetros +* pLista - ponteiro para a lista na qual deve excluir. +* +* $FV Valor retornado +* LIS_CondRetOK +* LIS_CondRetListaVazia +* +***********************************************************************/ + + LIS_tpCondRet LIS_ExcluirElemento( LIS_tppLista pLista ) ; + + +/*********************************************************************** +* +* $FC Função: LIS &Obter referência para o valor contido no elemento +* +* $ED Descrição da função +* Obtem a referência para o valor contido no elemento corrente da lista +* +* $EP Parâmetros +* pLista - ponteiro para a lista de onde se quer o valor +* +* $FV Valor retornado +* não NULL - se o elemento corrente existe +* NULL - se a lista estiver vazia +* Pode retornar NULL se o valor inserido no elemento for NULL. +* +***********************************************************************/ + + void * LIS_ObterValor( LIS_tppLista pLista ) ; + + +/*********************************************************************** +* +* $FC Função: LIS &Ir para o elemento inicial +* +* $ED Descrição da função +* Torna corrente o primeiro elemento da lista. +* Faz nada se a lista está vazia. +* +* $EP Parâmetros +* pLista - ponteiro para a lista a manipular +* +***********************************************************************/ + + void IrInicioLista( LIS_tppLista pLista ) ; + + +/*********************************************************************** +* +* $FC Função: LIS &Ir para o elemento final +* +* $ED Descrição da função +* Torna corrente o elemento final da lista. +* Faz nada se a lista está vazia. +* +* $EP Parâmetros +* pLista - ponteiro para a lista a manipular +* +***********************************************************************/ + + void IrFinalLista( LIS_tppLista pLista ) ; + + +/*********************************************************************** +* +* $FC Função: LIS &Avançar elemento +* +* $ED Descrição da função +* Avança o elemento corrente numElem elementos na lista +* Se numElem for positivo avança em direção ao final +* Se numElem for negativo avança em direção ao início +* numElem pode ser maior do que o númro de elementos existentes na +* direção desejada +* Se numElem for zero somente verifica se a lista está vazia +* +* $EP Parâmetros +* pLista - ponteiro para a lista a ser manipulada +* numElem - o número de elementos a andar +* +* $FV Valor retornado +* CondRetOK - se numElem elementos tiverem sido andados +* CondRetFimLista - se encontrou o fim da lista antes de andar numElem +* elementos +* CondRetListaVazia - se a lista está vazia +* +***********************************************************************/ + + LIS_tpCondRet LIS_AvancarElementoCorrente( LIS_tppLista pLista , + int numElem ) ; + + +/*********************************************************************** +* +* $FC Função: LIS &Procurar elemento contendo valor +* +* $ED Descrição da função +* Procura o elemento que referencia o valor dado. +* A função compara ponteiro e não conteúdo apontado. +* +* $EP Parâmetros +* pLista - ponteiro para a lista onde procura +* pValor - ponteiro para o valor procurado +* Pode ser NULL +* +* $FV Valor retornado +* LIS_CondRetOK - se encontrou. +* O elemento corrente é o primeiro elemento do +* elemento corrente inclusive para o fim da lista +* e que contém o ponteiro procurado +* +* LIS_CondRetNaoEncontrou - se o ponteiro não foi encontrado +* O elemento corrente continua o mesmo +* LIS_CondRetListaVazia - se a lista estiver vazia +* +***********************************************************************/ + + LIS_tpCondRet LIS_ProcurarValor( LIS_tppLista pLista , + void * pValor ) ; + +/*********************************************************************** +* +* $FC Função: LIS &Obgter TAmanho da lista +* +* $ED Descrição da função +* Atribui a variável tam o tamanho da lista +* +* $EP Parâmetros +* pLista - ponteiro para a lista onde procura +* tam - ponteiro de referencia para a tamanho da lista +* +* $FV Valor retornado +* LIS_CondRetOK - se ponteiros sao validos +* +* LIS_CondRetErro - ponteiros sao invalidos +***********************************************************************/ + + int LIS_ObterTamanho( LIS_tppLista pLista); + +#undef LISTA_EXT + +/********** Fim do módulo de definição: LIS Lista duplamente encadeada **********/ + +#else +#endif diff --git a/MODULO PF/PECA.C b/MODULO PF/PECA.C new file mode 100644 index 0000000..1a4ecb5 --- /dev/null +++ b/MODULO PF/PECA.C @@ -0,0 +1,94 @@ +/*************************************************************************** +* $MCI Módulo de implementação: PEC Estrutura Peca +* +* Arquivo gerado: PECA.C +* Letras identificadoras: PEC +* +* Nome da base de software: Exemplo de teste automatizado +* +* Projeto: Disciplinas INF 1628 / 1301 +* Gestor: DI/PUC-Rio +* Autores: fvc - Felipe Vieira Côrtes +* tbm - Tássio Borges de Miranda +* db - Daniela Brazão +* +* $HA Histórico de evolução: +* Versão Autor Data Observações +* 1.0 tbm 14/set/2015 Início do desenvolvimento +* +***************************************************************************/ + + +#include +#include +#include + +#define PECA_OWN +#include "PECA.h" +#undef PECA_OWN + +/*********************************************************************** +* +* $TC Tipo de dados: PECPnt Descritor do dados de ponto. +* +* $ED Descrição do tipo +* Descreve a estrutura de peça +***********************************************************************/ + +typedef struct tgPeca{ + char cor; +} tpPeca; + + +/***** Dados encapsulados no módulo *****/ + +// vazio + +/***** Código das funções exportadas pelo módulo *****/ + +/*************************************************************************** +* +* Função: Pec Criar Peça +* ****/ + +Pec_tpCondRet Pec_CriarPeca(tppPeca * PecCriado, char CorDaNovaPeca) +{ + *PecCriado= (tppPeca)malloc(sizeof(struct tgPeca)); + + if(PecCriado == NULL) + return Pec_CondRetFaltouMemoria; + + (*PecCriado)->cor = CorDaNovaPeca; + + return Pec_CondRetOK; +} + +/*************************************************************************** +* +* Função: PEC Destruir Peça +* ****/ + +Pec_tpCondRet Pec_DestruirPeca(tppPeca Peca) +{ + + free(Peca); + return Pec_CondRetOK; +} + +/*************************************************************************** +* +* Função: PEC Obter Cor +* ****/ + +Pec_tpCondRet Pec_ObterCor(tppPeca Peca, char *cor) +{ + if((Peca->cor != 'b') && (Peca->cor != 'p')) + { + printf("Cor obtida estah errada \n"); + return Pec_CondRetErro; + } + *cor = Peca->cor; + return Pec_CondRetOK; +} + +/*********** Fim do módulo de implementação: Módulo DadoPontos **************/ diff --git a/MODULO PF/PECA.h b/MODULO PF/PECA.h new file mode 100644 index 0000000..2458e5e --- /dev/null +++ b/MODULO PF/PECA.h @@ -0,0 +1,97 @@ +/*************************************************************************** +* +* $MCD Módulo de definição: Módulo Peça +* +* Arquivo gerado: PECA.H +* Letras identificadoras: PEC +* +* Nome da base de software: Exemplo de teste automatizado +* +* Projeto: Disciplinas INF 1628 / 1301 +* Gestor: DI/PUC-Rio +* Autores: fvc - Felipe Vieira Côrtes +* tbm - Tássio Borges de Miranda +* db - Daniela Brazão + +* +* $HA Histórico de evolução: +* Versão Autor Data Observações +* 1.00 tbm 14/09/2015 Início do desenvolvimento +* +* $ED Descrição do módulo +* Este módulo implementa um conjunto simples de funções para manipular a peça +* alem de descrever sua estrutura. +* +***************************************************************************/ + +#if defined( PECA_OWN ) + #define PECA_EXT +#else + #define PECA_EXT extern +#endif + +typedef struct tgPeca * tppPeca; + +/*********************************************************************** +* +* $TC Tipo de dados: MAT Condicoes de retorno +* +* +***********************************************************************/ + + typedef enum { + + Pec_CondRetOK = 0 , + /* Executou correto */ + + Pec_CondRetErro = 1 , + /* Estrutura do DadoPontos está errada */ + + Pec_CondRetMatrizNaoExiste = 2 , + /* DadoPontos não existe */ + + Pec_CondRetFaltouMemoria = 3 + /* Faltou memória ao alocar dados */ + + } Pec_tpCondRet ; + +/*********************************************************************** +* +* $FC Função: PEC Criar Peça +* +* $ED Descrição da função +* Cria uma nova peça +* $FV Valor retonado +* Pec_CondRetOK +* Pec_CondRetFaltouMemoria +* +***********************************************************************/ + + Pec_tpCondRet Pec_CriarPeca(tppPeca * PecCriado1, char CorDaNovaPeca); + +/*********************************************************************** +* +* $FC Função: PEC Destruir Peça +* +* $ED Descrição da função +* Destroi uma peça +* $FV Valor retonado +* Pec_CondRetOK +* Pec_CondRetFaltouMemoria +* +***********************************************************************/ + + Pec_tpCondRet Pec_DestruirPeca(tppPeca Peca); + +/*********************************************************************** +* +* $FC Função: PEC Obter Cor +* +* $ED Descrição da função +* Obtem cor de uma peca +* $FV Valor retonado +* Pec_CondRetOK +* Pec_CondRetFaltouMemoria +* +***********************************************************************/ +Pec_tpCondRet Pec_ObterCor(tppPeca Peca, char *cor); \ No newline at end of file diff --git a/MODULO PF/PecasFinalizadas.c b/MODULO PF/PecasFinalizadas.c new file mode 100644 index 0000000..68c8f22 --- /dev/null +++ b/MODULO PF/PecasFinalizadas.c @@ -0,0 +1,146 @@ +/*************************************************************************** +* $MCI Módulo de implementação: PF Peças Finalizadas +* +* Arquivo gerado: PF.c +* Letras identificadoras: PF +* +* Nome da base de software: Arcabouço para a automação de testes de programas redigidos em C +* +* Projeto: INF 1301 / 1628 Automatização dos testes de módulos C +* Gestor: LES/DI/PUC-Rio +* Autores: fvc + tbm + db +* +* $HA Histórico de evolução: +* Versão Autor Data Observações + 1.0 fvc 18/10 Começo do Desenvolvimento +* +***************************************************************************/ + +#include +#include +#include +#include "LISTA.h" +#include "PECA.h" + +#define PF_OWN +#include "PecasFinalizadas.h" +#undef PF_OWN + + +/*********************************************************************** +* +* $TC Tipo de dados: PF Descritor da estrutura de peças finalizadas +* +* +***********************************************************************/ + +typedef struct PF_tagFinalizadas { + + LIS_tppLista ListaFinalizadas; + /* Lista de Peças Finalizadas*/ + + char cor; + /* A cor das peças da estrutura */ + + int tamanho ; + /* Número de elementos na lista */ + +} PF_tpFinalizadas ; + +/***** Código das funções exportadas pelo módulo *****/ + +/*************************************************************************** +* +* Função: PF &Criar PF +* ****/ + +PF_tpCondRet PF_CriarPF(PF_tppFinalizadas *pPF, char cor, + void ( * ExcluirValor ) ( void * pDado ) ) +{ + + *pPF = (PF_tppFinalizadas)malloc(sizeof(PF_tpFinalizadas)); + + if(*pPF == NULL) + return PF_CondRetFaltouMemoria; + + (*pPF)->ListaFinalizadas = LIS_CriarLista(ExcluirValor); + (*pPF)->cor = cor; + (*pPF)->tamanho = 0; + + return PF_CondRetOK; +} + +/*************************************************************************** +* +* Função: PF &Adicionar Peça +* ****/ + +PF_tpCondRet PF_AdicionarPecaPF(PF_tppFinalizadas pPF) +{ + char cor = pPF->cor; + tppPeca newPeca; + if(Pec_CriarPeca(&newPeca, cor) != Pec_CondRetOK) + { + printf("Erro ao criar peca (PF) \n"); + return PF_CondRetErro; + } + if(LIS_InserirElementoApos(pPF->ListaFinalizadas, newPeca) != LIS_CondRetOK) + { + printf("Erro ao inserir peça na lista (PF) \n"); + return PF_CondRetErro; + } + pPF->tamanho++; + + return PF_CondRetOK; +} + + +/*************************************************************************** +* +* Função: PF &Obter Tamanho PF +* ****/ + +PF_tpCondRet PF_ObterTamanhoPF(PF_tppFinalizadas pPF, int *tam) +{ + if(tam == NULL) + return PF_CondRetErro; + + *tam = pPF->tamanho; + + if(*tam == 0) + return PF_CondRetVazia; + + return PF_CondRetOK; +} + +/*************************************************************************** +* +* Função: PF &Obter cor PF +* ****/ + +PF_tpCondRet PF_ObterCorPF(PF_tppFinalizadas pPF, char *cor) +{ + if(cor == NULL) + return PF_CondRetErro; + + *cor = pPF->cor; + + return PF_CondRetOK; +} + +/*************************************************************************** +* +* Função: PF &Destruir PF +* ****/ + +PF_tpCondRet PF_DestruirPF(PF_tppFinalizadas pPF) +{ + LIS_DestruirLista(pPF->ListaFinalizadas); + free(pPF); + return PF_CondRetOK; +} + + +/******** Fim do Módulo de Implementação: PF Lista de Peças Finalizadas *************/ \ No newline at end of file diff --git a/MODULO PF/PecasFinalizadas.h b/MODULO PF/PecasFinalizadas.h new file mode 100644 index 0000000..3c677e3 --- /dev/null +++ b/MODULO PF/PecasFinalizadas.h @@ -0,0 +1,168 @@ +#if ! defined( PF_ ) +#define PF_ +/*************************************************************************** +* +* $MCD Módulo de definição: OF Lista de Peças Finalizadas +* +* Arquivo gerado: PecasFinalizadas.h +* Letras identificadoras: PF +* +* Nome da base de software: Arcabouço para a automação de testes de programas redigidos em C +* +* Projeto: INF 1301 / 1628 Automatização dos testes de módulos C +* Gestor: LES/DI/PUC-Rio +* Autores: fvc + tbm + db +* +* $HA Histórico de evolução: +* Versão Autor Data Observações +* 1.0 fvc 18/10 Começo da implementação +* +* $ED Descrição do módulo +* Implementa uma lista de peças do tabuleiro gamão. +* +***************************************************************************/ + +#if defined( PF_OWN ) + #define PF_EXT +#else + #define PF extern +#endif + +/***** Declarações exportadas pelo módulo *****/ + +/* Tipo referência para a estrutura de pecas finalizadas */ + +typedef struct PF_tagFinalizadas * PF_tppFinalizadas; + + +/*********************************************************************** +* +* $TC Tipo de dados: PF Condições de retorno +* +* +* $ED Descrição do tipo +* Condições de retorno das funções do módulo de peças Finalizadas +* +***********************************************************************/ + + typedef enum { + + PF_CondRetOK , + /* Concluiu corretamente */ + + PF_CondRetVazia , + /* PF não contém elementos */ + + PF_CondRetErro, + /* Não concluiu corretamente */ + + PF_CondRetFaltouMemoria + /* Faltou memória ao tentar criar a estrutura*/ + + } PF_tpCondRet ; + +/*********************************************************************** +* +* $FC Função: PF &Criar estrutura de peças Finalizadas + +* $ED Descrição da função +* Cria uma estrutura para as peças Finalizadas do jogo de gamão +* +* $EP Parâmetros +* pPF - Ponteiro da estrutura de peças finalizadas passada por referência +* ExcluirValor - ponteiro para a função que processa a +* exclusão do valor referenciado pelo elemento +* a ser excluído. +* Ver descrição do módulo. +* +* $FV Valor retornado +* PF_CondRetOk +* PF_CondRetFaltouMemoria +* +***********************************************************************/ + + PF_tpCondRet PF_CriarPF(PF_tppFinalizadas *pPF, char cor, + void ( * ExcluirValor ) ( void * pDado ) ) ; + +/*********************************************************************** +* +* $FC Função: PF Adicionar uma peça ao PF +* +* $ED Descrição da função +* Adiciona uma peça a lista de peças finalizadas +* +* $EP Parâmetros +* pPF - A estrutura que será adicionada a peça + +* $FV Valor retornado +* PF_CondRetOk +* PF_CondRetErro +* +***********************************************************************/ + + PF_tpCondRet PF_AdicionarPecaPF(PF_tppFinalizadas pPF) ; + +/*********************************************************************** +* +* $FC Função: PF Obter tamanho da lista de peças finalizadas +* +* $ED Descrição da função +* Obtem a quantidade de peças na lista +* +* $EP Parâmetros +* pPF - A estrutura que se deseja saber o tamanho +* *tam - Ponteiro de referencia para o tamanho da PF + +* $FV Valor retornado +* PF_CondRetOk +* PF_CondRetVazia +* PF_CondRetErro +* +***********************************************************************/ + + PF_tpCondRet PF_ObterTamanhoPF(PF_tppFinalizadas pPF, int *tam) ; + +/*********************************************************************** +* +* $FC Função: PF Obter Cor da PF +* +* $ED Descrição da função +* Obtem a cor das peças da PF +* +* $EP Parâmetros +* pPF - A PF que se deseja saber a cor + *cor - Cor esperada + +* $FV Valor retornado +* PF_CondRetOk +* PF_CondRetErro +* +***********************************************************************/ + + PF_tpCondRet PF_ObterCorPF(PF_tppFinalizadas pPF, char *cor) ; + +/*********************************************************************** +* +* $FC Função: PF Destruir PF +* +* $ED Descrição da função +* Destroi a lista de peças finalizadas +* +* $EP Parâmetros +* pPF - A PF que se deseja destruir +* $FV Valor retornado +* PF_CondRetOk +* PF_CondRetErro +* +***********************************************************************/ + + PF_tpCondRet PF_DestruirPF(PF_tppFinalizadas pPF) ; + +#undef PF_EXT + +/********** Fim do módulo de definição: PF Lista de Peças Finalizadas **********/ + +#else +#endif diff --git a/MODULO PF/TESTPECFINAL.C b/MODULO PF/TESTPECFINAL.C new file mode 100644 index 0000000..38b13a4 --- /dev/null +++ b/MODULO PF/TESTPECFINAL.C @@ -0,0 +1,198 @@ +/*************************************************************************** +* $MCI Módulo de implementação: Módulo de teste específico + +* Módulo criado para operar com listas +* +* Arquivo gerado: TESTBAR.C +* Letras identificadoras: TBar +* +* Nome da base de software: Exemplo de teste automatizado +* +* Projeto: Disciplinas INF 1628 / 1301 +* Gestor: DI/PUC-Rio +* Autores: fvc - Felipe Vieira Cortes +* tbm - Tássio Borges de Miranda +* +* $HA Histórico de evolução: +* Versão Autor Data Observações +* 4.00 tbm 23/10/2015 Módulo criado para operar com listas +* +* $ED Descrição do módulo +* Este módulo contém as funções específicas para o teste do +* módulo peças finalizadas. +* +* $EIU Interface com o usuário pessoa +* Comandos de teste específicos para testar o módulo BAR: + +* =criarpf - Chama a função BAR_tpCondRet BAR_CriarBAR() +* =obtercorpf - Chama a função BAR_tpCondRet BAR_AdicionarPeca(BAR_tppCapturadas pBAR) +* =obtertamanhopf - Chama a função BAR_tpCondRet BAR_RemoverPeca(BAR_tppCapturadas pBAR) +* =addpf - Chama a função BAR_tpCondRet BAR_ObterCorBar(BAR_tppCapturadas pBAR, char *cor) +* =destruirpf - Chama a função BAR_tpCondRet Bar_DestruirBar(BAR_tppCapturadas pBAR) +* +***************************************************************************/ + +#include +#include +#include + +#include "PecasFinalizadas.h" +#include "LISTA.H" +#include "GENERICO.H" +#include "LERPARM.H" +#include "PECA.h" +#include "TST_ESPC.H" + + +/* Tabela dos nomes dos comandos de teste específicos */ +#define MAX 5 +#define DIM_VET_PF 2 +#define CRIAR_PF_CMD "=criarpf" +#define OBTER_COR_PF_CMD "=obtercorpf" +#define ADD_PF_CMD "=addpf" +#define OBTER_TAM_PF_CMD "=obtertamanhopf" +#define DESTRUIR_PF_CMD "=destruirpf" + +PF_tppFinalizadas PecFinal [DIM_VET_PF]; + +/***** Protótipos das funções encapuladas no módulo *****/ + + static void DestruirValor( void * pValor ) ; + +/***** Código das funções exportadas pelo módulo *****/ + + +/*********************************************************************** +* +* $FC Função: TPec Efetuar operações de teste específicas para o Modulo Peca +* +* $ED Descrição da função +* Efetua os diversos comandos de teste específicos para o módulo +* Peca sendo testado. +* +* $EP Parâmetros +* $P ComandoTeste - String contendo o comando +* +* $FV Valor retornado +* Ver TST_tpCondRet definido em TST_ESPC.H +* +***********************************************************************/ + + TST_tpCondRet TST_EfetuarComando( char * ComandoTeste ) + { + + int CondRetObtido = PF_CondRetOK ; + int CondRetEsperada = PF_CondRetFaltouMemoria ; + /* inicializa para qualquer coisa */ + + char ValorEsperado = '?' ; + char ValorObtido = '!' ; + char ValorDado = '\0' ; + char corEsperada = 'x'; + char corRecebida; + int NumLidos = -1 ; + int i = 0; + int inxpec, tamanhopf,tamanhopfresp; + + TST_tpCondRet Ret; + TST_tpCondRet CondRet; + + /* Testar Bar Criar Bar */ + if ( strcmp( ComandoTeste , CRIAR_PF_CMD ) == 0 ) + { + + NumLidos = LER_LerParametros( "ici" ,&inxpec, &corRecebida, &CondRetEsperada ) ; + if ( NumLidos != 3 ) + { + return TST_CondRetParm ; + } /* if */ + + if(inxpec > 5 || inxpec < 0) return TST_CondRetErro; + + CondRetObtido = PF_CriarPF(&PecFinal[inxpec],corRecebida,DestruirValor); + + return TST_CompararInt( CondRetEsperada , CondRetObtido , + "Retorno errado ao criar BAR." ); + + } /* fim ativa: Testar BAR Criar BAr */ + + /* Testar Bar Obter cor da Bar */ + else if ( strcmp( ComandoTeste , OBTER_COR_PF_CMD ) == 0 ) + { + + NumLidos = LER_LerParametros( "ici",&inxpec,&corEsperada, &CondRetEsperada ) ; + if ( NumLidos != 3 ) + { + return TST_CondRetParm ; + } /* if */ + CondRetObtido = PF_ObterCorPF(PecFinal[inxpec],&corRecebida) ; + + Ret = TST_CompararChar( corRecebida , corEsperada , + "Valor do elemento errado, diferente do esperado" ) ; + + if ( Ret != TST_CondRetOK ) + { + return Ret ; + } /* if */ + + return TST_CompararChar(CondRetObtido, CondRetEsperada, "Retorno errado ao obter o cor do BAR."); + + } /* fim ativa: Testar Bar Obter cor da Bar */ + + /* Testar Bar AddBar */ + else if ( strcmp( ComandoTeste , ADD_PF_CMD ) == 0 ) + { + + NumLidos = LER_LerParametros( "ii" , &inxpec, &CondRetEsperada ) ; + if ( NumLidos != 2 ) + { + return TST_CondRetParm ; + } /* if */ + + CondRetObtido = PF_AdicionarPecaPF(PecFinal[inxpec]) ; + + return TST_CompararInt( CondRetEsperada , CondRetObtido , + "Retorno errado ao obter cor da BAR." ); + + } + /*Fim da ativa: Testar Bar addbar*/ + + /* Testar obter tamanho BAR*/ + else if( strcmp ( ComandoTeste , OBTER_TAM_PF_CMD) == 0) + { + NumLidos = LER_LerParametros( "iii" , &inxpec,&tamanhopfresp, &CondRetEsperada); + if ( NumLidos != 3 ) + return TST_CondRetParm; + + CondRetObtido = PF_ObterTamanhoPF(PecFinal[inxpec],&tamanhopf); + + CondRet = TST_CompararInt(tamanhopfresp,tamanhopf,"Tamanho do elemento errado, diferente do esperado"); + + if ( CondRet != TST_CondRetOK ) + return CondRet; + + return TST_CompararInt( CondRetEsperada , CondRetObtido, "Retorno errado ao obter tamanho bar."); + } + /*Fim da ativa: Testar Bar tamanhoBAR*/ + + /*Testar Destruir Bar*/ + + else if( strcmp ( ComandoTeste , DESTRUIR_PF_CMD) == 0) + { + NumLidos = LER_LerParametros( "ii" , &inxpec, &CondRetEsperada); + if ( NumLidos != 2 ) + return TST_CondRetParm; + + CondRetObtido = PF_DestruirPF(PecFinal[inxpec]); + + return TST_CompararInt( CondRetEsperada , CondRetObtido, "Retorno errado ao destruir BAR."); + } + + /*Fim da ativa: Testar Destuir Bar*/ + return TST_CondRetNaoConhec ; + } /* Fim função: TPec Efetuar operações de teste específicas para Peca */ + +void DestruirValor( void * pValor ) + { + free( pValor ) ; + } \ No newline at end of file diff --git a/MODULO PF/TST_ESPC.H b/MODULO PF/TST_ESPC.H new file mode 100644 index 0000000..987ff8e --- /dev/null +++ b/MODULO PF/TST_ESPC.H @@ -0,0 +1,320 @@ +#if ! defined( Tst_Espc_ ) +#define Tst_Espc_ +/*************************************************************************** +* +* $MCD Módulo de definição: TSTE Interface de teste específico +* +* Arquivo gerado: Tst_Espc.h +* +* Nome da base de software: Arcabouço para a automação de testes de programas redigidos em C +* Arquivo da base de software: C:\AUTOTEST\PROJETOS\ARCABOUC.BSW +* +* Projeto: INF 1301 / 1628 Automatização dos testes de módulos C +* Gestor: LES/DI/PUC-Rio +* Autores: avs +* +* $HA Histórico de evolução: +* Versão Autor Data Observações +* 4 avs 01/fev/2006 criar linguagem script simbólica +* 3 avs 08/dez/2004 uniformização dos exemplos +* 2 avs 07/jul/2003 unificação de todos os módulos em um só projeto +* 1 avs 16/abr/2003 início desenvolvimento +* +* $ED Descrição do módulo +* Este módulo consta somente do módulo de definição de todos os módulos +* de teste específicos a serem desenvolvidos, e também da especificação +* do tipo de condições de retorno deste módulo. +* +* Ele estabelece a interface a ser utilizada pelo módulo de teste +* genérico com todos os módulos de teste específico a serem +* desenvolvidos. +* +* Os módulos de teste específico devem sempre incluir este módulo +* de definição e, idealmente, não devem adicionar mais itens +* à interface. +* +* O módulo de teste específico contém a função de teste de um +* determinado módulo ou conjunto de módulos. Mais especificamente, +* contém a função que interpreta os comandos de teste que exercitarão +* as funções do(s) módulo(s) em teste. +* +* Poderá conter também diversas funções auxiliares requeridas para +* realizar os testes, vide "contexto" a seguir. +* +* O contexto é formado por variáveis e estruturas auxiliares necessárias +* para que se possa efetuar todos os comandos de teste. +* Por exemplo pode-se desejar testar várias instâncias de uma +* mesma estrutura. Uma forma de resolver isto é criar um vetor +* global static +* de n elementos em que cada elemento aponta para a cabeça de +* uma determinada instância dessa estrutura. Para realizar um +* teste relativo a uma determinada instância, torna-se necessário +* selecioná-la através de um índice contido no comando de teste. +* Este parâmetro, embora seja um índice, é na realidade o identificador +* da instância da estrutura a ser manipulada (idEstrutura). +* +* Caso o módulo em teste requeira um contexto, este deverá ser +* estabelecido no presente módulo. Para tal devem ser declaradas +* variáveis e estruturas encapsuladas e devem ser incluídos comandos +* de teste capazes de manipular o contexto. +* +* Uma das formas para estabelecer o contexto seria a de incluir +* no mçodulo de teste específico comando semelhantes a: +* +* =iniciaXXX que inicializa o contexto do módulo sob teste para +* vazio. Este comando deve ser utilizado uma única vez +* logo ao inciar a execução do teste. +* =reset restaura o contexto para vazio. Este comando usualmente +* assumirá que o contexto a esvaziar esteja correto. +* O comando deverá liberar os espaços alocados aos +* elementos, anular as referências a ele, inicializar +* valores de vetores de referências, etc. +* O comando tem utilidade especial ao segmentar um teste +* em partes estanques e ao controlar vazamento de +* memória. +* =terminaXXX este comando destrói todo o contexto e não o +* reinicializa. O objetivo é poder verificar vazamento +* de memória. +* +* Evidentemente, outra forma seria a de alterar as funções de +* inicialização e término do módulo de teste genérico o que é pouco +* recomendável pois viola o princípio de um mesmo módulo genérico +* servir para testar todos os construtos. +* +* Para cada função do módulo a ser testado deve existir pelo menos +* um comando de teste. Em alguns casos pode ser interessante criar +* comandos que armazenem, alterem ou consultem variáveis de +* estado do próprio módulo de teste. Ver os comentários sobre +* contexto acima. Ou seja, podem existir comandos de teste que +* têm o propósito de agir sobre o contexto e, não, o de efetuar +* um determinado teste. Alguns desses comandos podem inclusive +* realizar verificações entre um resultado esperado e existente +* no contexto. +* +* Todos os controles de consistência dos parâmetros dos comandos +* de teste devem ser realizados no módulo de teste específico. +* Recomenda-se que seja sempre retornado TST_CondRetParm, +* sinalizando erro de sintaxe do comando de teste ou valores +* não permitidos. Deve ser sempre assumido que os parâmetros +* podem estar em erro. Ou seja, o controle da integridade dos +* comando é mandatória. +* +* Caso seja necessário emitir mensagens especiais, +* deve ser utilizada a função genérica "TST_ExibirPrefixo". +* Caso seja desejado acrescentar um texto a alguma mensagem já exibida, +* (prefixo, ou comparar), utilize a função +* fprintf( TST_ObterArqLog( ) , "..." , ... ) +* na qual não deve ocorrer avanço de linha ou nova linha ("\n" ou "\r") +* no parâmetro indicador de formato (2o. parâmetro). Essa comvenção +* assegura a consistência do aspecto das mensagens com o restante do +* programa de teste. +* +* Cada comando deve ser completamente interpretado pelo seu +* respectivo fragmento de interpretação. Ou seja, não deverá ser +* retornado para o módulo genérico qualquer dado adicional à +* condição de retorno da função de teste específico. Veja +* "TST_ExibirPrefixo" acima, caso seja desejado adicionar detalhes +* à mensagen já exibida. +* +* A função TST_NotificarFalha sempre registra uma falha, enquanto que +* a função TST_ExibirPrefixo pode ser usada para emitir mensagens +* de informação ou mesmo de advertência. Caso a função TST_ExibirPrefixo +* seja utilizada para sinalizar uma falha, é necessário chamar +* também a função TST_ContarFalha( ) para que seja notificada a falha. +* Isto não é necessário no caso da função TST_NotificarFalha, pois +* esta sempre conta falhas. +* +* As funções a testar que retornem um valor sempre devem ter +* este valor verificado, mesmo que seja uma condição de retorno. +* Utilize para isto uma das funções " Comparar" do arcabouço. +* Caso uma função retorne dois ou mais valores, incluindo +* a condição de retorno, utilize um código semelhante ao +* descrito a seguir. +* +* Seja +* FuncATestar( p1, p2, p3 ... ) => v1, v2, ... +* a função a ser testada e, v1, v2, ... os dados retornados de +* alguma forma (valor retornado, parâmetro por referência, variável +* global). Assumindo que v1 seja o valor retornado. +* +* v1Obtido = FuncATestar( ... +* CondRet = TST_CompararXXX( v1Obtido , v1Esperado , "mensagem 1" ) ; +* if ( CondRet != TST_CondRetOK ) +* { +* return CondRet ; +* } +* +* CondRet = TST_CompararXXX( v2Obtido , v2Esperado , "mensagem 2" ) ; +* if ( CondRet != TST_CondRetOK ) +* { +* return CondRet ; +* } +* ... +* +* TST_CompararXXX( vnObtido , vnEsperado , "mensagem n" ) ; +* +***************************************************************************/ + +#if defined( Tst_Espc_OWN ) + #define Tst_Espc_EXT +#else + #define Tst_Espc_EXT extern +#endif + +/***** Declarações exportadas pelo módulo *****/ + +#define SINALIZA_ERRO ">>>" +#define SINALIZA_RECUPERA "<<<" +#define SINALIZA_COMENTARIO "!!!" + + +/*********************************************************************** +* +* $TC Tipo de dados: TST Cond ret módulo de teste específico +* +* +* $ED Descrição do tipo +* Este tipo enumera todas as condições de retorno que podem ser +* geradas pela função de teste específica. +* +***********************************************************************/ + + typedef enum { + + TST_CondRetOK , + /* Comando de teste executou corretamente */ + + TST_CondRetErro , + /* Comando de teste encontrou uma ou mais falhas + * + *$ED Descrição + * Esta condição sinaliza que um ou mais resultados da execução + * da função sob teste resultou em um valor diferente do esperado. */ + + TST_CondRetParm , + /* Comando de teste está com a sintaxe em erro + * + *$ED Descrição + * A presente condição de retorno deve ser retornada caso a sintaxe + * ou os valores do comando de teste estiverem em erro. + * + * Todos os fragmentos de interpretação devem: + * - realizar a análise dos parâmetros do comando + * - verificar se todos os parâmetros foram lidos + * - verificar se os valores dos parâmetros estão corretos + * por exemplo: verificar se os índices de acesso a elementos + * estão dentro dos limites dos correspondentes vetores. + * - efetuar a função a testar + * - verificar se os resultados retornados por esta função estão + * corretos */ + + TST_CondRetNaoExecutou , + /* Comando de teste não se destina ao presente interpretador + * + *$ED Descrição + * Esta condição deve ser retornada por todas as funções de interpretação + * de comandos de teste relativas a módulos do próprio arcabouço, + * caso não tenha sido encontrado um comando válido. Isso permite + * estabelecer um "daisy chain" de interpretadores em que cada qual + * tenha finalidade específica no contexto do arcabouço. */ + + TST_CondRetNaoConhec , + /* Comando de teste não é conhecido + * + *$ED Descrição + * Esta condição deve ser retornada por todas as funções de interpretação + * de casos de teste específico visando determinado módulo em teste, + * sempre que esse interpretador não consiga identificar o comando. + * + * Cabe salientar a diferença entre TST_CondRetNaoExecutou e + * TST_CondRetNaoConhec. A primeira corresponde à não interpretação + * de um comando possivelmente válido em interpretadores subsequentes. + * A segunda corresponde a comandos não válidos considerando todos + * os interpretadores. */ + + TST_CondRetNaoImplementado , + /* Comando de teste não implementado + * + *$ED Descrição + * Esta condição deve ser retornada ao interpretar um comando de teste + * específico ainda não implementado. + * + * Recomenda-se que o desenvolvimento dos módulos sob teste e do + * correpondente módulo de teste específico se dê incrementalmente. + * Consequentemente diversos comandos não estarão implementados + * no início do desenvolvimento. Esta incompleteza poderá ser + * sinalizada com esta condição de retorno. */ + + TST_CondRetMemoria + /* Faltou memória para executar o comando + * + *$ED Descrição + * Esta condição deve ser retornada caso tenha ocorrido algum erro + * quando o módulo de teste específico tentar alocar memória ou + * outro recurso. */ + + } TST_tpCondRet ; + + +/*********************************************************************** +* +* $FC Função: TSTE &Efetuar comandos de teste específicos +* +* $ED Descrição da função +* Efetua os diversos comandos de teste específicos para o módulo +* sendo testado. +* +* Cada módulo de teste específico deve desenvolver esta função. +* Poderá conter diversas outras conforme necessário. No entanto +* estas devem todas ser funções encapsuladas no módulo (static) +* +* Freqüentemente é necessário desenvolver um contexto para o teste. +* Por exemplo, pode ser necessário tratar n elementos disponibilizados +* pelo módulo sob teste. Neste caso deveria ser criado um vetor +* global com referências para estas elemento. Ao iniciar os teste +* este vetor deverá ser inicializado. Ao terminar, os elementos do +* vetor referenciando algum elemento devem ser destruídos. +* +* Todos os controles de consistência devem ser realizados no +* módulo de teste específico. +* +* A função TST_EfetuarComando( ) deve retornar as condições de retorno +* identificadas no tipo TST_tpCondRet. +* +* As funções do módulo sob teste que retornam algum valor sempre +* devem sempre ter este valor verificado, mesmo sendo uma condição de +* retorno. Para fazer a vereficação da corretude, recomenda-se +* utilizar as funções TST_CompararXXX definidas no módulo genérico. +* Assegura-se assim a uniformidade da saída gerada durante o teste. +* +* Para realizar a análise de um comando de teste recomenda-se +* utilizar as funções definidas no módulo LerParm. Elas, além +* de realizarem a análise léxica, permitem o uso intercambiável +* de parâmetros simbólicos ou literais. Também realizam a +* verificação da corretude dos tipos dos parâmetros, contribuindo +* assim para a redução de erros de redação de scripts de teste +* que possam passar despercebidos. +* +* As funções a serem testadas que requeiram algum argumento, devem +* ser chamadas com valores (parâmetros) extraídos do comando de +* teste sendo executado. Use sempre as funções do módulo LerParm +* para realizar a análise sintática. +* +* $EP Parâmetros +* $P ComandoTeste - String contendo o comando +* +* $FV Valor retornado +* TST_CondRetXXX - veja a descriÓcão dos possíveis valores +* retornados na especificação do correspondente +* enum +* +***********************************************************************/ + + TST_tpCondRet TST_EfetuarComando( char * ComandoTeste ) ; + +#undef Tst_Espc_EXT + +/********** Fim do módulo de definição: TSTE Interface de teste específico **********/ + +#else +#endif diff --git a/MODULO PF/pf.script b/MODULO PF/pf.script new file mode 100644 index 0000000..dad50ef --- /dev/null +++ b/MODULO PF/pf.script @@ -0,0 +1,40 @@ +// Script: TesteLista.script +// Autor: Arndt von Staa, Tassio Miranda +// Data: 23/10/2015 +// + +==Criar Peças Finalizadas Branco +=criarpf 1 'b' 0 + +==Criar Peças Finalizadas Preto +=criarpf 2 'p' 0 + +==Obter Cor do Peças Finalizadas Branco +=obtercorpf 1 'b' 0 + +==Obter Cor do Peças Finalizadas Preto +=obtercorpf 2 'p' 0 + +==Aumentar o Peças Finalizadas Branco em 6 pecas +=addpf 1 0 +=addpf 1 0 +=addpf 1 0 +=addpf 1 0 +=addpf 1 0 +=addpf 1 0 + +==Obter Tamaho do Peças Finalizadas Branco com 6 pecas +=obtertamanhopf 1 6 0 + +==Aumetar o peças finalizadas Preto em duas pecas +=addpf 2 0 +=addpf 2 0 + +==Obter Tamaho do Peças Finalizadas Preto com 2 pecas +=obtertamanhopf 2 2 0 + +==Destruir Peças Finalizadas Branco +=destruirpf 1 0 + +==Destruir Peças Finalizadas Preto +=destruirpf 2 0 diff --git a/TESTBAR.c b/TESTBAR.c new file mode 100644 index 0000000..dbc2d47 --- /dev/null +++ b/TESTBAR.c @@ -0,0 +1,219 @@ +/*************************************************************************** +* $MCI Módulo de implementação: Módulo de teste específico + +* Módulo criado para operar com listas +* +* Arquivo gerado: TESTBAR.C +* Letras identificadoras: TBar +* +* Nome da base de software: Exemplo de teste automatizado +* +* Projeto: Disciplinas INF 1628 / 1301 +* Gestor: DI/PUC-Rio +* Autores: fvc - Felipe Vieira Cortes +* tbm - Tássio Borges de Miranda +* db - Daniela Brazão +* +* $HA Histórico de evolução: +* Versão Autor Data Observações +* 4.00 tbm 23/10/2015 Módulo criado para operar com listas +* +* $ED Descrição do módulo +* Este módulo contém as funções específicas para o teste do +* módulo Bar. +* +* $EIU Interface com o usuário pessoa +* Comandos de teste específicos para testar o módulo BAR: + +* =criarbar - Chama a função BAR_tpCondRet BAR_CriarBAR() +* =obtercorbar - Chama a função BAR_tpCondRet BAR_AdicionarPeca(BAR_tppCapturadas pBAR) +* =obtertamanhobar - Chama a função BAR_tpCondRet BAR_RemoverPeca(BAR_tppCapturadas pBAR) +* =removerbar - Chama a função BAR_tpCondRet BAR_ObterTamanhoBar(BAR_tppCapturadas pBAR, int *tam) +* =addbar - Chama a função BAR_tpCondRet BAR_ObterCorBar(BAR_tppCapturadas pBAR, char *cor) +* =destruirbar - Chama a função BAR_tpCondRet Bar_DestruirBar(BAR_tppCapturadas pBAR) +* +***************************************************************************/ + +#include +#include +#include + +#include "BAR.h" +#include "LISTA.H" +#include "GENERICO.H" +#include "LERPARM.H" +#include "PECA.h" +#include "TST_ESPC.H" + + +/* Tabela dos nomes dos comandos de teste específicos */ +#define MAX 5 +#define DIM_VET_BAR 2 +#define CRIAR_BAR_CMD "=criarbar" +#define REMOVER_BAR_CMD "=removerbar" +#define OBTER_COR_BAR_CMD "=obtercorbar" +#define ADD_BAR_CMD "=addbar" +#define OBTER_TAM_BAR_CMD "=obtertamanhobar" +#define DESTRUIR_BAR_CMD "=destruirbar" + +BAR_tppCapturadas BarCap [DIM_VET_BAR]; + +/***** Protótipos das funções encapuladas no módulo *****/ + + static void DestruirValor( void * pValor ) ; + +/***** Código das funções exportadas pelo módulo *****/ + + +/*********************************************************************** +* +* $FC Função: TPec Efetuar operações de teste específicas para o Modulo Peca +* +* $ED Descrição da função +* Efetua os diversos comandos de teste específicos para o módulo +* Peca sendo testado. +* +* $EP Parâmetros +* $P ComandoTeste - String contendo o comando +* +* $FV Valor retornado +* Ver TST_tpCondRet definido em TST_ESPC.H +* +***********************************************************************/ + + TST_tpCondRet TST_EfetuarComando( char * ComandoTeste ) + { + + int CondRetObtido = BAR_CondRetOK ; + int CondRetEsperada = BAR_CondRetFaltouMemoria ; + /* inicializa para qualquer coisa */ + + char ValorEsperado = '?' ; + char ValorObtido = '!' ; + char ValorDado = '\0' ; + char corEsperada = 'x'; + char corRecebida; + int NumLidos = -1 ; + int i = 0; + int inxpec, tamanhobar,tamanhobaresp; + + TST_tpCondRet Ret; + TST_tpCondRet CondRet; + + /* Testar Bar Criar Bar */ + if ( strcmp( ComandoTeste , CRIAR_BAR_CMD ) == 0 ) + { + + NumLidos = LER_LerParametros( "ici" , + &inxpec, &corRecebida, &CondRetEsperada ) ; + if ( NumLidos != 3 ) + { + return TST_CondRetParm ; + } /* if */ + + if(inxpec > 5 || inxpec < 0) return TST_CondRetErro; + + CondRetObtido = BAR_CriarBAR(&BarCap[inxpec],corRecebida,DestruirValor); + + return TST_CompararInt( CondRetEsperada , CondRetObtido , + "Retorno errado ao criar BAR." ); + + } /* fim ativa: Testar BAR Criar BAr */ + + /* Testar Bar Remover Bar */ + else if ( strcmp( ComandoTeste , REMOVER_BAR_CMD ) == 0 ) + { + + NumLidos = LER_LerParametros( "ii" , &inxpec, &CondRetEsperada ) ; + if ( NumLidos != 2 ) + { + return TST_CondRetParm ; + } /* if */ + + CondRetObtido = BAR_RemoverPeca(BarCap[inxpec]) ; + + return TST_CompararInt( CondRetEsperada , CondRetObtido , + "Retorno errado ao Removar Bar." ); + + } /* fim ativa: Testar Bar Remover Bar */ + + /* Testar Bar Obter cor da Bar */ + else if ( strcmp( ComandoTeste , OBTER_COR_BAR_CMD ) == 0 ) + { + + NumLidos = LER_LerParametros( "ici",&inxpec,&corEsperada, &CondRetEsperada ) ; + if ( NumLidos != 3 ) + { + return TST_CondRetParm ; + } /* if */ + CondRetObtido = BAR_ObterCorBar(BarCap[inxpec],&corRecebida) ; + + Ret = TST_CompararChar( corRecebida , corEsperada , + "Valor do elemento errado, diferente do esperado" ) ; + + if ( Ret != TST_CondRetOK ) + { + return Ret ; + } /* if */ + + return TST_CompararChar(CondRetObtido, CondRetEsperada, "Retorno errado ao obter o cor do BAR."); + + } /* fim ativa: Testar Bar Obter cor da Bar */ + + /* Testar Bar AddBar */ + else if ( strcmp( ComandoTeste , ADD_BAR_CMD ) == 0 ) + { + + NumLidos = LER_LerParametros( "ii" , &inxpec, &CondRetEsperada ) ; + if ( NumLidos != 2 ) + { + return TST_CondRetParm ; + } /* if */ + + CondRetObtido = BAR_AdicionarPeca(BarCap[inxpec]) ; + + return TST_CompararInt( CondRetEsperada , CondRetObtido , + "Retorno errado ao obter cor da BAR." ); + + } + /*Fim da ativa: Testar Bar addbar*/ + + /* Testar obter tamanho BAR*/ + else if( strcmp ( ComandoTeste , OBTER_TAM_BAR_CMD) == 0) + { + NumLidos = LER_LerParametros( "iii" , &inxpec,&tamanhobaresp, &CondRetEsperada); + if ( NumLidos != 3 ) + return TST_CondRetParm; + + CondRetObtido = BAR_ObterTamanhoBar(BarCap[inxpec],&tamanhobar); + + CondRet = TST_CompararInt(tamanhobaresp,tamanhobar,"Tamanho do elemento errado, diferente do esperado"); + + if ( CondRet != TST_CondRetOK ) + return CondRet; + + return TST_CompararInt( CondRetEsperada , CondRetObtido, "Retorno errado ao obter tamanho bar."); + } + /*Fim da ativa: Testar Bar tamanhoBAR*/ + + /*Testar Destruir Bar*/ + + else if( strcmp ( ComandoTeste , DESTRUIR_BAR_CMD) == 0) + { + NumLidos = LER_LerParametros( "ii" , &inxpec, &CondRetEsperada); + if ( NumLidos != 2 ) + return TST_CondRetParm; + + CondRetObtido = Bar_DestruirBar(BarCap[inxpec]); + + return TST_CompararInt( CondRetEsperada , CondRetObtido, "Retorno errado ao destruir BAR."); + } + + /*Fim da ativa: Testar Destuir Bar*/ + return TST_CondRetNaoConhec ; + } /* Fim função: TPec Efetuar operações de teste específicas para Peca */ + +void DestruirValor( void * pValor ) + { + free( pValor ) ; + } \ No newline at end of file diff --git a/TESTLIS.C b/TESTLIS.C new file mode 100644 index 0000000..a55bece --- /dev/null +++ b/TESTLIS.C @@ -0,0 +1,449 @@ +/*************************************************************************** +* $MCI Módulo de implementação: TLIS Teste lista de símbolos +* +* Arquivo gerado: TestLIS.c +* Letras identificadoras: TLIS +* +* Nome da base de software: Arcabouço para a automação de testes de programas redigidos em C +* Arquivo da base de software: D:\AUTOTEST\PROJETOS\LISTA.BSW +* +* Projeto: INF 1301 / 1628 Automatização dos testes de módulos C +* Gestor: LES/DI/PUC-Rio +* Autores: avs +* +* $HA Histórico de evolução: +* Versão Autor Data Observações +* 4 avs 01/fev/2006 criar linguagem script simbólica +* 3 avs 08/dez/2004 uniformização dos exemplos +* 2 avs 07/jul/2003 unificação de todos os módulos em um só projeto +* 1 avs 16/abr/2003 início desenvolvimento +* +***************************************************************************/ + +#include +#include +#include + +#include "TST_Espc.h" + +#include "Generico.h" +#include "LerParm.h" + +#include "Lista.h" + + +static const char RESET_LISTA_CMD [ ] = "=resetteste" ; +static const char CRIAR_LISTA_CMD [ ] = "=criarlista" ; +static const char DESTRUIR_LISTA_CMD [ ] = "=destruirlista" ; +static const char ESVAZIAR_LISTA_CMD [ ] = "=esvaziarlista" ; +static const char INS_ELEM_ANTES_CMD [ ] = "=inselemantes" ; +static const char INS_ELEM_APOS_CMD [ ] = "=inselemapos" ; +static const char OBTER_VALOR_CMD [ ] = "=obtervalorelem" ; +static const char EXC_ELEM_CMD [ ] = "=excluirelem" ; +static const char IR_INICIO_CMD [ ] = "=irinicio" ; +static const char IR_FIM_CMD [ ] = "=irfinal" ; +static const char AVANCAR_ELEM_CMD [ ] = "=avancarelem" ; +static const char PROCURA_VALOR_CMD [ ] = "=procurarvalor" ; +static const char OBTER_TAMANHO_CMD [ ] = "=obtertamanho" ; + +#define TRUE 1 +#define FALSE 0 + +#define VAZIO 0 +#define NAO_VAZIO 1 + +#define DIM_VT_LISTA 10 +#define DIM_VALOR 100 + +LIS_tppLista vtListas[ DIM_VT_LISTA ] ; + +/***** Protótipos das funções encapuladas no módulo *****/ + + static void DestruirValor( void * pValor ) ; + + static int ValidarInxLista( int inxLista , int Modo ) ; + +/***** Código das funções exportadas pelo módulo *****/ + + +/*********************************************************************** +* +* $FC Função: TLIS &Testar lista +* +* $ED Descrição da função +* Podem ser criadas até 10 listas, identificadas pelos índices 0 a 10 +* +* Comandos disponíveis: +* +* =resetteste +* - anula o vetor de listas. Provoca vazamento de memória +* =criarlista inxLista +* =destruirlista inxLista +* =esvaziarlista inxLista +* =inselemantes inxLista string CondRetEsp +* =inselemapos inxLista string CondRetEsp +* =obtervalorelem inxLista string CondretPonteiro +* =excluirelem inxLista CondRetEsp +* =irinicio inxLista +* =irfinal inxLista +* =avancarelem inxLista numElem CondRetEsp +* =procurarvalor inxLista string CondretPonteiro +* +***********************************************************************/ + + TST_tpCondRet TST_EfetuarComando( char * ComandoTeste ) + { + + int inxLista = -1 , + numLidos = -1 , + CondRetEsp = -1 ; + + TST_tpCondRet CondRet ; + + int CondRetObtido = LIS_CondRetOK; + + char StringDado[ DIM_VALOR ] ; + char * pDado ; + + int ValEsp = -1 ; + + int i,num ; + + int numElem = -1 ; + + StringDado[ 0 ] = 0 ; + + /* Efetuar reset de teste de lista */ + + if ( strcmp( ComandoTeste , RESET_LISTA_CMD ) == 0 ) + { + + for( i = 0 ; i < DIM_VT_LISTA ; i++ ) + { + vtListas[ i ] = NULL ; + } /* for */ + + return TST_CondRetOK ; + + } /* fim ativa: Efetuar reset de teste de lista */ + + /* Testar CriarLista */ + + else if ( strcmp( ComandoTeste , CRIAR_LISTA_CMD ) == 0 ) + { + + numLidos = LER_LerParametros( "i" , + &inxLista ) ; + + if ( ( numLidos != 1 ) + || ( ! ValidarInxLista( inxLista , VAZIO ))) + { + return TST_CondRetParm ; + } /* if */ + + vtListas[ inxLista ] = + LIS_CriarLista( DestruirValor ) ; + + return TST_CompararPonteiroNulo( 1 , vtListas[ inxLista ] , + "Erro em ponteiro de nova lista." ) ; + + } /* fim ativa: Testar CriarLista */ + + /* Testar Esvaziar lista lista */ + + else if ( strcmp( ComandoTeste , ESVAZIAR_LISTA_CMD ) == 0 ) + { + + numLidos = LER_LerParametros( "i" , + &inxLista ) ; + + if ( ( numLidos != 1 ) + || ( ! ValidarInxLista( inxLista , NAO_VAZIO ))) + { + return TST_CondRetParm ; + } /* if */ + + LIS_EsvaziarLista( vtListas[ inxLista ] ) ; + + return TST_CondRetOK ; + + } /* fim ativa: Testar Esvaziar lista lista */ + + /* Testar Destruir lista */ + + else if ( strcmp( ComandoTeste , DESTRUIR_LISTA_CMD ) == 0 ) + { + + numLidos = LER_LerParametros( "i" , + &inxLista ) ; + + if ( ( numLidos != 1 ) + || ( ! ValidarInxLista( inxLista , NAO_VAZIO ))) + { + return TST_CondRetParm ; + } /* if */ + + LIS_DestruirLista( vtListas[ inxLista ] ) ; + vtListas[ inxLista ] = NULL ; + + return TST_CondRetOK ; + + } /* fim ativa: Testar Destruir lista */ + + /* Testar inserir elemento antes */ + + else if ( strcmp( ComandoTeste , INS_ELEM_ANTES_CMD ) == 0 ) + { + + numLidos = LER_LerParametros( "isi" , + &inxLista , StringDado , &CondRetEsp ) ; + + if ( ( numLidos != 3 ) + || ( ! ValidarInxLista( inxLista , NAO_VAZIO )) ) + { + return TST_CondRetParm ; + } /* if */ + + pDado = ( char * ) malloc( strlen( StringDado ) + 1 ) ; + if ( pDado == NULL ) + { + return TST_CondRetMemoria ; + } /* if */ + + strcpy( pDado , StringDado ) ; + + + CondRet = LIS_InserirElementoAntes( vtListas[ inxLista ] , pDado ) ; + + if ( CondRet != LIS_CondRetOK ) + { + free( pDado ) ; + } /* if */ + + return TST_CompararInt( CondRetEsp , CondRet , + "Condicao de retorno errada ao inserir antes." ) ; + + } /* fim ativa: Testar inserir elemento antes */ + + /* Testar inserir elemento apos */ + + else if ( strcmp( ComandoTeste , INS_ELEM_APOS_CMD ) == 0 ) + { + + numLidos = LER_LerParametros( "isi" , + &inxLista , StringDado , &CondRetEsp ) ; + + if ( ( numLidos != 3 ) + || ( ! ValidarInxLista( inxLista , NAO_VAZIO )) ) + { + return TST_CondRetParm ; + } /* if */ + + pDado = ( char * ) malloc( strlen( StringDado ) + 1 ) ; + if ( pDado == NULL ) + { + return TST_CondRetMemoria ; + } /* if */ + + strcpy( pDado , StringDado ) ; + + + CondRet = LIS_InserirElementoApos( vtListas[ inxLista ] , pDado ) ; + + if ( CondRet != LIS_CondRetOK ) + { + free( pDado ) ; + } /* if */ + + return TST_CompararInt( CondRetEsp , CondRet , + "Condicao de retorno errada ao inserir apos." ) ; + + } /* fim ativa: Testar inserir elemento apos */ + + /* Testar excluir simbolo */ + + else if ( strcmp( ComandoTeste , EXC_ELEM_CMD ) == 0 ) + { + + numLidos = LER_LerParametros( "ii" , + &inxLista , &CondRetEsp ) ; + + if ( ( numLidos != 2 ) + || ( ! ValidarInxLista( inxLista , NAO_VAZIO )) ) + { + return TST_CondRetParm ; + } /* if */ + + return TST_CompararInt( CondRetEsp , + LIS_ExcluirElemento( vtListas[ inxLista ] ) , + "Condição de retorno errada ao excluir." ) ; + + } /* fim ativa: Testar excluir simbolo */ + + /* Testar obter valor do elemento corrente */ + + else if ( strcmp( ComandoTeste , OBTER_VALOR_CMD ) == 0 ) + { + + numLidos = LER_LerParametros( "isi" , + &inxLista , StringDado , &ValEsp ) ; + + if ( ( numLidos != 3 ) + || ( ! ValidarInxLista( inxLista , NAO_VAZIO )) ) + { + return TST_CondRetParm ; + } /* if */ + + pDado = ( char * ) LIS_ObterValor( vtListas[ inxLista ] ) ; + + if ( ValEsp == 0 ) + { + return TST_CompararPonteiroNulo( 0 , pDado , + "Valor não deveria existir." ) ; + } /* if */ + + if ( pDado == NULL ) + { + return TST_CompararPonteiroNulo( 1 , pDado , + "Dado tipo um deveria existir." ) ; + } /* if */ + + return TST_CompararString( StringDado , pDado , + "Valor do elemento errado." ) ; + + } /* fim ativa: Testar obter valor do elemento corrente */ + + /* Testar ir para o elemento inicial */ + + else if ( strcmp( ComandoTeste , IR_INICIO_CMD ) == 0 ) + { + + numLidos = LER_LerParametros( "i" , &inxLista ) ; + + if ( ( numLidos != 1 ) + || ( ! ValidarInxLista( inxLista , NAO_VAZIO )) ) + { + return TST_CondRetParm ; + } /* if */ + + IrInicioLista( vtListas[ inxLista ] ) ; + + return TST_CondRetOK ; + + } /* fim ativa: Testar ir para o elemento inicial */ + + /* LIS &Ir para o elemento final */ + + else if ( strcmp( ComandoTeste , IR_FIM_CMD ) == 0 ) + { + + numLidos = LER_LerParametros( "i" , &inxLista ) ; + + if ( ( numLidos != 1 ) + || ( ! ValidarInxLista( inxLista , NAO_VAZIO )) ) + { + return TST_CondRetParm ; + } /* if */ + + IrFinalLista( vtListas[ inxLista ] ) ; + + return TST_CondRetOK ; + + } /* fim ativa: LIS &Ir para o elemento final */ + + /* LIS &Avançar elemento */ + + else if ( strcmp( ComandoTeste , AVANCAR_ELEM_CMD ) == 0 ) + { + + numLidos = LER_LerParametros( "iii" , &inxLista , &numElem , + &CondRetEsp ) ; + + if ( ( numLidos != 3 ) + || ( ! ValidarInxLista( inxLista , NAO_VAZIO )) ) + { + return TST_CondRetParm ; + } /* if */ + + return TST_CompararInt( CondRetEsp , LIS_AvancarElementoCorrente( vtListas[ inxLista ] , numElem ) , + "Condicao de retorno errada ao avancar" ) ; + + } /* fim ativa: LIS &Avançar elemento */ + + else if (strcmp ( ComandoTeste , OBTER_TAMANHO_CMD ) == 0 ) + { + numLidos = LER_LerParametros( "iii" ,&inxLista,&ValEsp, &CondRetEsp ) ; + + if ( ( numLidos != 3 )||( ! ValidarInxLista( inxLista , NAO_VAZIO )) ) + { + return TST_CondRetParm ; + } /* if */ + + CondRetObtido = LIS_ObterTamanho( vtListas[ inxLista ], &num ); + + CondRet = TST_CompararInt( ValEsp , num ,"Valor do elemento errado, diferente do esperado" ) ; + + if ( CondRet != TST_CondRetOK ) + return CondRet ; + + + return TST_CondRetOK(CondRetObtido, CondRetEsp, "Retorno errado ao obter o tamanho da lista."); + } + + return TST_CondRetNaoConhec ; + + } /* Fim função: TLIS &Testar lista */ + + +/***** Código das funções encapsuladas no módulo *****/ + + +/*********************************************************************** +* +* $FC Função: TLIS -Destruir valor +* +***********************************************************************/ + + void DestruirValor( void * pValor ) + { + + free( pValor ) ; + + } /* Fim função: TLIS -Destruir valor */ + + +/*********************************************************************** +* +* $FC Função: TLIS -Validar indice de lista +* +***********************************************************************/ + + int ValidarInxLista( int inxLista , int Modo ) + { + + if ( ( inxLista < 0 ) + || ( inxLista >= DIM_VT_LISTA )) + { + return FALSE ; + } /* if */ + + if ( Modo == VAZIO ) + { + if ( vtListas[ inxLista ] != 0 ) + { + return FALSE ; + } /* if */ + } else + { + if ( vtListas[ inxLista ] == 0 ) + { + return FALSE ; + } /* if */ + } /* if */ + + return TRUE ; + + } /* Fim função: TLIS -Validar indice de lista */ + +/********** Fim do módulo de implementação: TLIS Teste lista de símbolos **********/ + diff --git a/Teste.script b/Teste.script new file mode 100644 index 0000000..b0afe22 --- /dev/null +++ b/Teste.script @@ -0,0 +1,36 @@ +// Script: TesteLista.script +// Autor: Arndt von Staa, Tassio Miranda +// Data: 23/10/2015 +// + +==Criar BAR Branco +=criarbar 1 'b' 0 + +==Criar BAR Preto +=criarbar 2 'p' 0 + +==Obter Cor do BAR Branco +=obtercorbar 1 'b' 0 + +==Obter Cor do BAR Preto +=obtercorbar 2 'p' 0 + +==Aumentar o BAR Branco em 2 peças +=addbar 1 0 +=addbar 1 0 + +==Obter Tamaho do BAR Branco com 2 pecas +=obtertamanhobar 1 2 0 + +==Remover 2 peças do BAR Branco +=removerbar 1 0 +=removerbar 1 0 + +==Obter Tamaho do BAR Branco com 0 pecas +=obtertamanhobar 1 0 0 + +==Destruir BAR Branco +=destruirbar 1 0 + +==Destruir BAR Preto +=destruirbar 2 0 diff --git a/main.c b/main.c index f10c500..905a00d 100644 --- a/main.c +++ b/main.c @@ -17,6 +17,10 @@ void displayJogo(LIS_tppLista estrutura); LIS_tppLista carregaJogo(FILE** fp); void salvarJogo(LIS_tppLista estrutura); + void finalizarPeca(TAB_tppTabuleiro *pTab, PF_tppFinalizadas *pPF, int num); + /* Conta a quantidade de peças a partir da 'qtd'ultimas casas */ + int contaUltimasCasas(TAB_tppTabuleiro *pTab, char cor, int qtd); + int jogadordaVez; int main (void) { @@ -26,11 +30,13 @@ int main (void) PF_tppFinalizadas pfbranca, pfpreta; // pecas finalizadas BAR_tppCapturadas barbranca, barpreta; // pecas capturadas LIS_tppLista casas, casa; // lista de casas auxiliar usada no jogo - int dado1, dado2, dado3, dado4; // dados da partida + int dado1, dado2; // dados da partida tppDadoPontos dp; + int flag = 0; char preto = 'p', branco = 'b'; - int tampfb = 0, tampfp = 0, temp, tamanho, tambarb, tambarp; // tamanho da estrutura de pecas finalizadas, elas que determinam o termino do jogo - int casaEscolhida, opt[3] = {0,0,0}, contOpt = 0, i, j, k, opcao, opcaorestante; + int tampfb = 0, tampfp = 0,tamanho, tambarb, tambarp, ultCasas; // tamanho da estrutura de pecas finalizadas, elas que determinam o termino do jogo + int casaEscolhida, opt[3] = {0,0,0}, contOpt = 0, i, k = 0; + int opcao, opcaorestante; void* aux; char jogadordaVez, corObtida; int resp; @@ -116,11 +122,12 @@ int main (void) if(dado1 == dado2) goto JOGARDADO; // Dado1 corresponde ao jogador branco e dado2 corresponde ao jogador preto jogadordaVez = (dado1 > dado2)? 'b':'p'; - while(tampfp < 15 || tampfb < 15) + while(tampfp < 15 || tampfb < 15) { LABEL1: - printf("Jogador da vez eh o %s \n", (jogadordaVez == 'b')? "Branco" : "Preto"); + printf("Jogador da vez eh o %s \n", QUESTION "Branco" : "Preto"); printf("1: Jogar dados \n0: Salvar e Sair \n"); + flag = 0; scanf("%d", &resp); if(resp == 0) { @@ -136,10 +143,14 @@ int main (void) } displayJogo(Principal); printf("Jogador da vez eh o %s \n", QUESTION "Branco" : "Preto"); - printf("Dados : %d %d \n", dado1, dado2); + if(dado1 == dado2) + printf("Dados : %d %d %d %d \n", dado1, dado2, dado1, dado2); + else + printf("Dados : %d %d \n", dado1, dado2); // checa se a bar está com alguma peça, se sim, calcula as opções q ele tem com os dados jogados BAR_ObterTamanhoBar(barbranca, &tambarb); BAR_ObterTamanhoBar(barpreta,&tambarp); +DOBRADOBAR: if(((jogadordaVez == 'b') && (tambarb > 0)) || ((jogadordaVez == 'p') && (tambarp > 0))) // o jogador da vez tem peça no bar? { // calcula as opções do jogador @@ -246,6 +257,7 @@ int main (void) LIS_AvancarElementoCorrente(casas,QUESTION opt[opcao-1] -1: -opt[opcao-1] +1 ); casa = (LIS_tppLista)LIS_ObterValor(casas); aux = LIS_ObterValor(casa); + tamanho = LIS_ObterTamanho(casa); Pec_CriarPeca(&pecaAux, QUESTION branco : preto); if(tamanho == 1) { @@ -277,10 +289,10 @@ int main (void) // obtem o novo tamanho do BAR BAR_ObterTamanhoBar(barbranca, &tambarb); BAR_ObterTamanhoBar(barpreta,&tambarp); + opt[opcao - 1] = 0; if(((jogadordaVez == 'b') && (tambarb > 0)) || ((jogadordaVez == 'p') && (tambarp > 0))) { displayJogo(Principal); - opcaorestante = (opt[opcao - 1] == dado1)? dado2 : dado1; for( i = 0; i < 2; i++) { if(opt[i] == 0) continue; else break; @@ -307,8 +319,9 @@ int main (void) } goto LABEL1; } - printf("Dado Restante : %d \n", opcaorestante); - opt[opcao-1] = 0; + opcaorestante = (opt[opcao - 1] == dado1)? dado2 : dado1; + if((dado1 == dado2) && !flag) printf("Dados Restantes : %d %d %d \n", dado1, dado2, dado2); + else printf("Dado Restante : %d \n", opcaorestante); // mover a peça do bar para o tabuleiro printf("1: Mover a peca do BAR para a casa %d \n", QUESTION opcaorestante : 25 - opcaorestante); ESCOLHAOPCAO4: @@ -326,10 +339,11 @@ int main (void) return 0; } QUESTION IrInicioLista(casas) : IrFinalLista(casas); - LIS_AvancarElementoCorrente(casas,QUESTION opcaorestante -1: opcaorestante +1 ); + LIS_AvancarElementoCorrente(casas,QUESTION opcaorestante -1: -opcaorestante +1 ); casa = (LIS_tppLista)LIS_ObterValor(casas); aux = LIS_ObterValor(casa); Pec_CriarPeca(&pecaAux, QUESTION branco : preto); + tamanho = LIS_ObterTamanho(casa); if(tamanho == 1) { Pec_ObterCor((tppPeca)aux, &corObtida); @@ -360,6 +374,15 @@ int main (void) // acabou a vez do jogador de tirar as peças do bar (trocar de jogador) BAR_ObterTamanhoBar(barbranca, &tambarb); BAR_ObterTamanhoBar(barpreta,&tambarp); + if((dado1 == dado2) && !flag) + { + displayJogo(Principal); + printf("Jogador da vez eh o %s \n", (jogadordaVez == 'b')? "Branco" : "Preto"); + printf("Dados : %d %d \n", dado1, dado2); + flag = 1; + for(i = 0; i < 2; i++) opt[i] = 0; + goto DOBRADOBAR; + } jogadordaVez = QUESTION 'p' : 'b'; contOpt = 0; for(i = 0; i < 3; i++) @@ -377,11 +400,77 @@ int main (void) printf("Erro ao jogar o dado (main) \n"); return 0; } + displayJogo(Principal); goto LABEL1; } goto OPCAORESTANTE; } - printf("Escolha de qual casa deseja andar \n"); +DOBRADO: + ultCasas = contaUltimasCasas(&tabuleiro, jogadordaVez, 6); + if((ultCasas + QUESTION tampfb : tampfp) == 15) + { + // ve se pode finalizar + IrInicioLista(casas); + LIS_AvancarElementoCorrente(casas, QUESTION dado1 -1 : -dado1 + 1); + casa = (LIS_tppLista)LIS_ObterValor(casas); + aux = LIS_ObterValor(casa); + contOpt = 2; + if(aux != NULL) + { + Pec_ObterCor((tppPeca)aux, &corObtida); + if(corObtida == jogadordaVez) + { + opt[contOpt] = dado1; + contOpt++; + } + } + if((aux == NULL) || corObtida != jogadordaVez) + { + ultCasas = contaUltimasCasas(&tabuleiro, jogadordaVez, dado1); + if((ultCasas + QUESTION tampfb : tampfp) == 15) + { + while((aux == NULL) || corObtida != jogadordaVez) + { + LIS_AvancarElementoCorrente(casas, QUESTION 1 : -1); + casa = (LIS_tppLista)LIS_ObterValor(casas); + aux = LIS_ObterValor(casa); + k++; + } + opt[contOpt] = k; + contOpt++; + } + } + IrInicioLista(casas); + LIS_AvancarElementoCorrente(casas, QUESTION dado2 -1 : -dado2 + 1); + casa = (LIS_tppLista)LIS_ObterValor(casas); + aux = LIS_ObterValor(casa); + if(aux != NULL) + { + Pec_ObterCor((tppPeca)aux, &corObtida); + if(corObtida == jogadordaVez) + { + opt[contOpt] = dado2; + contOpt++; + } + } + if((aux == NULL) || corObtida != jogadordaVez) + { + ultCasas = contaUltimasCasas(&tabuleiro, jogadordaVez, dado2); + if((ultCasas + QUESTION tampfb : tampfp) == 15) + { + while((aux == NULL) || corObtida != jogadordaVez) + { + LIS_AvancarElementoCorrente(casas, QUESTION 1 : -1); + casa = (LIS_tppLista)LIS_ObterValor(casas); + aux = LIS_ObterValor(casa); + k++; + } + opt[contOpt] = k; + contOpt++; + } + } + } + printf("Escolha de qual casa deseja andar \n"); ESCOLHADECASA: scanf("%d", &casaEscolhida); IrInicioLista(casas); @@ -425,7 +514,6 @@ int main (void) } // a casa é valida // agora é saber as opçoes que o jogador tem - // ordena os dados, dado1 < dado2 LIS_AvancarElementoCorrente(casas, QUESTION dado1 : -dado1); // avanca para a posicao dado1 casa = (LIS_tppLista)LIS_ObterValor(casas); aux = LIS_ObterValor(casa); @@ -482,16 +570,22 @@ int main (void) } } } + // o bizu está aqui,... para finalziar as peças for(i = 0; i < 3; i++) { if(((jogadordaVez == 'b') && (opt[i] + casaEscolhida > 24)) || ((casaEscolhida - opt[i] < 1) && (jogadordaVez == 'p'))) opt[i] = 0; } - if(opt[0] == 0) + if((opt[0] == 0) && (opt[1] == 0)) { printf("Nao ha opcoes, escolha outra casa \n"); goto ESCOLHADECASA; } + if((opt[0] == 0) && (opt[1] != 0)) + { + opt[0] = opt[1]; + opt[1] = 0; + } for(i = 0; opt[i] != 0; i++) { if(opt[i] == 0) continue; @@ -552,7 +646,8 @@ int main (void) OPCAORESTANTE: displayJogo(Principal); opcaorestante = (opt[opcao - 1] == dado1)? dado2 : dado1; - printf("Dado Restante : %d \n", opcaorestante); + if((dado1 == dado2) && !flag) printf("Dados Restantes : %d %d %d\n", dado1, dado2, dado1); + else printf("Dado Restante : %d \n", opcaorestante); opt[opcao-1] = 0; // jogador escolhe outra casa e repete-se o procedimento ESCOLHADECASA1: @@ -690,7 +785,13 @@ int main (void) } } displayJogo(Principal); -JOGARDADO1: + if((dado1 == dado2) && !flag) + { + printf("Dados : %d %d \n", dado1, dado2); + flag = 1; + for(i = 0; i < 2; i++) opt[i] = 0; + goto DOBRADO; + } if(DAD_NumPular(&dado1) != DAD_CondRetOK) { printf("Erro ao jogar o dado (main) \n"); @@ -702,8 +803,6 @@ int main (void) printf("Erro ao jogar o dado (main) \n"); return 0; } - // se os dois valores forem iguais - if(dado1 == dado2) goto JOGARDADO1; jogadordaVez = QUESTION 'p' : 'b'; contOpt = 0; for(i = 0; i < 3; i++) @@ -1098,6 +1197,34 @@ LIS_tppLista carregaJogo(FILE** fp) return estrutura; fclose(*fp); } +void finalizarPeca(TAB_tppTabuleiro *pTab, PF_tppFinalizadas *pPF, int num) +{ + LIS_tppLista casas, casa; + char corpf; + TAB_ObterCasas(*pTab, &casas); + PF_ObterCorPF(*pPF, &corpf); + (corpf == 'b')? IrInicioLista(casas) : IrFinalLista(casas); + LIS_AvancarElementoCorrente(casas,(corpf == 'b')? num - 1 : -num + 1); + casa = (LIS_tppLista)LIS_ObterValor(casas); + LIS_ExcluirElemento(casa); + PF_AdicionarPeca(*pPF); +} +int contaUltimasCasas(TAB_tppTabuleiro *pTab, char cor, int qtd) +{ + int cont = 0, i; + LIS_tppLista casa, casas; + TAB_ObterCasas(*pTab, &casas); + (cor == 'b')? IrInicioLista(casas) : IrFinalLista(casas); + for(i = 0; i < qtd; i++) + { + casa = (LIS_tppLista)LIS_ObterValor(casas); + cont += LIS_ObterTamanho(casa); + LIS_AvancarElementoCorrente(casas, (cor == 'b')? 1:-1); + } + return cont; +} + + diff --git a/testlista.script b/testlista.script new file mode 100644 index 0000000..49a66d9 --- /dev/null +++ b/testlista.script @@ -0,0 +1,137 @@ +// Script: TesteLista.script +// Autor: Arndt von Staa, Felipe Vieira +// Data: 30/ago/2015 +// + +== Inicializar valores +=declararparm lista0 int 0 +=declararparm lista1 int 1 +=declararparm lista2 int 2 +=declararparm lista3 int 3 +=declararparm lista4 int 4 +=declararparm lista5 int 5 + +=declararparm str0 string "abcdefg" +=declararparm str1 string "qwerty" +=declararparm str2 string "xxx" +=declararparm str3 string "xpto" +=declararparm str4 string "1234" +=declararparm str5 string "oi!" + + +=declararparm OK int 0 +=declararparm ListaVazia int 1 +=declararparm FimLista int 2 +=declararparm NaoAchou int 3 +=declararparm FaltouMemoria int 4 + +=declararparm pNULL int 0 +=declararparm pNaoNULL int 1 + +== Criar a lista 0 +=criarlista lista0 + +== Verificar ObterValor relativo a lista vazia +=obtervalorelem lista0 "???" pNULL + +== Inserir elemento em lista vazia +=inselemantes lista0 str0 OK +=obtervalorelem lista0 str0 pNaoNULL + +== Inserir elemento após primeiro +=inselemapos lista0 str1 OK +=obtervalorelem lista0 str1 pNaoNULL + +== Inserir elemento antes do último +=inselemantes lista0 str2 OK +=obtervalorelem lista0 str2 pNaoNULL + +== Excluir elemento do meio +=obtervalorelem lista0 str2 pNaoNULL +=excluirelem lista0 OK + +== Excluir elemento do início +=obtervalorelem lista0 str0 pNaoNULL +=excluirelem lista0 OK + +== Excluir elemento final, único +=obtervalorelem lista0 str1 pNaoNULL +=excluirelem lista0 OK + +== Ver se a lista ficou vazia +=obtervalorelem lista0 "???" pNULL + +== Destruir a lista +=destruirlista lista0 + +== Criar uma lista com dois elementos +=criarlista lista1 +=inselemapos lista1 str0 OK +=inselemapos lista1 str1 OK + +== Esvaziar a lista e ver se ficou vazia +=esvaziarlista lista1 +=obtervalorelem lista1 "???" pNULL + +== Destruir a lista +=destruirlista lista1 + +== Criar uma lista com quatro elementos +=criarlista lista2 +=inselemapos lista2 str0 OK +=inselemapos lista2 str1 OK +=inselemapos lista2 str2 OK +=inselemapos lista2 str3 OK + +== Obter Tamanho da Lista Nao Vazia +=obtertamanho lista2 4 OK + +== Verificar a lista de trás para diante +=obtervalorelem lista2 str3 pNaoNULL +=avancarelem lista2 -1 OK +=obtervalorelem lista2 str2 pNaoNULL +=avancarelem lista2 -1 OK +=obtervalorelem lista2 str1 pNaoNULL +=avancarelem lista2 -1 OK +=obtervalorelem lista2 str0 pNaoNULL +=avancarelem lista2 -1 FimLista + +== Verificar a lista de frente para trás +=obtervalorelem lista2 str0 pNaoNULL +=avancarelem lista2 1 OK +=obtervalorelem lista2 str1 pNaoNULL +=avancarelem lista2 1 OK +=obtervalorelem lista2 str2 pNaoNULL +=avancarelem lista2 1 OK +=obtervalorelem lista2 str3 pNaoNULL +=avancarelem lista2 1 FimLista + +== Verificar a lista andando demais de trás para diante +=avancarelem lista2 -10 FimLista +=obtervalorelem lista2 str0 pNaoNULL + +== Verificar a lista andando demais de frente para trás +=avancarelem lista2 10 FimLista +=obtervalorelem lista2 str3 pNaoNULL + +== Destruir a lista +=destruirlista lista2 + +== Criar lista com 3 elementos +=criarlista lista3 +=inselemapos lista3 str0 OK +=inselemapos lista3 str1 OK +=inselemapos lista3 str2 OK + +== Ir Inicio da lista e obter string 0 +=irinicio lista3 +=obtervalorelem lista3 str0 pNaoNULL + +== Ir Final da lista e obter a strig 2 +=irfinal lista3 +=obtervalorelem lista3 str2 pNaoNULL + +== Destruir a lista +=destruirlista lista3 + +// fim