diff --git a/DadoPonto/DADOPONTOS.c b/DadoPontos/Source/DADOPONTOS.c similarity index 97% rename from DadoPonto/DADOPONTOS.c rename to DadoPontos/Source/DADOPONTOS.c index a19cd12..32d4a55 100644 --- a/DadoPonto/DADOPONTOS.c +++ b/DadoPontos/Source/DADOPONTOS.c @@ -24,6 +24,7 @@ #include #include #include +#include "GENERICO.H" #define DADO_OWN #include "DADOPONTOS.h" @@ -123,6 +124,8 @@ DADPnt_tpCondRet DADPtn_ObterDono(tppDadoPontos DadoPonto, char * CorDonoAtual) DADPnt_tpCondRet DADPtn_DestruirDado(tppDadoPontos Dado) { + if(Dado == NULL) + return DADPnt_CondRetDadoPontosNaoExiste; free(Dado); return DADPnt_CondRetOK; } diff --git a/DadoPonto/DADOPONTOS.h b/DadoPontos/Source/DADOPONTOS.h similarity index 98% rename from DadoPonto/DADOPONTOS.h rename to DadoPontos/Source/DADOPONTOS.h index b73dd7a..31e9c32 100644 --- a/DadoPonto/DADOPONTOS.h +++ b/DadoPontos/Source/DADOPONTOS.h @@ -31,6 +31,8 @@ #define DADOPONTOS_EXT extern #endif +#include "Generico.h" + typedef struct tgDadoPontos * tppDadoPontos; typedef struct tgPlayers * tppPlayers; /*********************************************************************** @@ -48,7 +50,7 @@ typedef struct tgPlayers * tppPlayers; DADPnt_CondRetErro = 1 , /* Estrutura do DadoPontos está errada */ - DADPnt_CondRetMatrizNaoExiste = 2 , + DADPnt_CondRetDadoPontosNaoExiste = 2 , /* DadoPontos não existe */ DADPnt_CondRetFaltouMemoria = 3 diff --git a/DadoPontos/Source/GENERICO.H b/DadoPontos/Source/GENERICO.H new file mode 100644 index 0000000..dcf7430 --- /dev/null +++ b/DadoPontos/Source/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/DadoPontos/Source/LERPARM.H b/DadoPontos/Source/LERPARM.H new file mode 100644 index 0000000..f12cf3d --- /dev/null +++ b/DadoPontos/Source/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/DadoPonto/TESTDADOPONTOS.c b/DadoPontos/Source/TESTDADOPONTOS.c similarity index 91% rename from DadoPonto/TESTDADOPONTOS.c rename to DadoPontos/Source/TESTDADOPONTOS.c index e7b289b..ef3273c 100644 --- a/DadoPonto/TESTDADOPONTOS.c +++ b/DadoPontos/Source/TESTDADOPONTOS.c @@ -110,7 +110,7 @@ tppDadoPontos P[MAX]; return TST_CompararInt( CondRetEsperada , CondRetObtido , - "Retorno errado ao criar a peca." ); + "Retorno errado ao criar ao criar dadopontos." ); } /* fim ativa: Testar Criar Dado Pontos */ @@ -154,10 +154,10 @@ tppDadoPontos P[MAX]; return Ret ; } /* if */ - return TST_CompararChar(CondRetObtido, CondRetEsperada, "Retorno errado ao obter o valor da peca"); + return TST_CompararChar(CondRetObtido, CondRetEsperada, "Retorno errado ao obter o dono do dado"); } - /* fim ativa: Testar DadoPontos Dobrar Dado*/ + /* fim ativa: Testar Obter Dono do DadoPonto*/ /* Testar Dadoponto DobrarDado */ else if ( strcmp( ComandoTeste , DOBRAR_DADO_CMD ) == 0 ) @@ -174,11 +174,11 @@ tppDadoPontos P[MAX]; CondRetObtido = DADPtn_DobrarDado(P[inxpec],corEsperada); return TST_CompararInt( CondRetEsperada , CondRetObtido , - "Retorno errado ao criar a peca." ); + "Retorno errado ao dobrar o valor do dadopontos." ); } /* fim ativa: Fim Dobrar Dado */ - /* Testar Dadoponto Valor Partida */ + /* Testar Dadoponto Obter Valor */ else if ( strcmp( ComandoTeste , OBTER_VALORPARTIDA_CMD ) == 0 ) { @@ -192,14 +192,17 @@ tppDadoPontos P[MAX]; CondRetObtido = DADPtn_ValorPartida(P[inxpec],&ValorPontos); - Ret = TST_CompararChar( valoresperado , ValorPontos , " Valor da Partida Errado" ) ; + Ret = TST_CompararInt( valoresperado , ValorPontos , " Valor da Partida Errado" ) ; - return TST_CompararInt( CondRetEsperada , CondRetObtido , - "Retorno errado ao criar a peca." ); - - } /* fim ativa: Fim Dobrar Dado */ + if ( Ret != TST_CondRetOK ) + { + return Ret ; + } + return TST_CompararInt( CondRetObtido, CondRetEsperada , + "Retorno errado ao obter valor do dado pontos." ); + } /* fim ativa: Fim Dobrar Dado */ return TST_CondRetNaoConhec ; diff --git a/DadoPontos/Source/TST_ESPC.H b/DadoPontos/Source/TST_ESPC.H new file mode 100644 index 0000000..987ff8e --- /dev/null +++ b/DadoPontos/Source/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/DadoPontos/TRAB2-2.exe b/DadoPontos/TRAB2-2.exe new file mode 100644 index 0000000..13e9635 Binary files /dev/null and b/DadoPontos/TRAB2-2.exe differ diff --git a/DadoPontos/TesteDadoPontos.bat b/DadoPontos/TesteDadoPontos.bat new file mode 100644 index 0000000..9a42476 --- /dev/null +++ b/DadoPontos/TesteDadoPontos.bat @@ -0,0 +1 @@ +TRAB2-2 /sTesteDadoPontos > logTesteDadoPontos.txt \ No newline at end of file diff --git a/DadoPonto/testescript.script b/DadoPontos/TesteDadoPontos.script similarity index 95% rename from DadoPonto/testescript.script rename to DadoPontos/TesteDadoPontos.script index b1b1fbc..76f8783 100644 --- a/DadoPonto/testescript.script +++ b/DadoPontos/TesteDadoPontos.script @@ -36,12 +36,11 @@ =obterdono 0 'b' 0 == Obter Valor Errado -=obtervalorpartida 0 63 0 +=obtervalorpartida 0 63 1 =recuperar == Obter Valor =obtervalorpartida 0 64 0 - == Destruir DadoPontos =destruirdadoponto 0 0 \ No newline at end of file diff --git a/DadoPontos/logTesteDadoPontos.txt b/DadoPontos/logTesteDadoPontos.txt new file mode 100644 index 0000000..a9a799e --- /dev/null +++ b/DadoPontos/logTesteDadoPontos.txt @@ -0,0 +1,39 @@ + + +LES - Laboratório de Engenharia de Software DI/PUC-Rio + Arcabouço de teste de módulos C (c) 2006 + +--------------------------------------------- + Construto sob teste: TRAB2-2 + + Arquivo de teste: TesteDadoPontos + + +!!! 0 Linha: 1 // SCRIPT DE TESTE PARA O MODULO DADOSPnt + 2 == Criar DadoPontos + 5 == Obter Dono + 8 == Obter Valor + 11 == Dobrar Dado + 14 == Obter Dono + 17 == Obter Valor + 20 == Dobrar Dado + 23 == Dobrar Dado + 26 == Dobrar Dado + 29 == Obter Valor + 32 == Dobrar Dado + 35 == Obter Dono + 38 == Obter Valor Errado +>>> 1 Linha: 39 Valor da Partida Errado Deveria ser: 63 É: 64 +<<< 0 Linha: 40 Falha esperada foi recuperada. + 42 == Obter Valor + 45 == Destruir DadoPontos + +!!! Número de linhas lidas: 46 +!!! Número de casos de teste: 15 +!!! Número comandos corretos: 14 +!!! Número de falhas encontradas: 0 + +!!! Não foram encontrados problemas + + +!!! Numero de espacos ainda alocados: 0 \ No newline at end of file diff --git a/README.txt b/README.txt deleted file mode 100644 index e69de29..0000000 diff --git a/TESTDADOPONTOS.c b/TESTDADOPONTOS.c new file mode 100644 index 0000000..ef3273c --- /dev/null +++ b/TESTDADOPONTOS.c @@ -0,0 +1,210 @@ +/*************************************************************************** +* $MCI Módulo de implementação: Módulo de teste específico + +* Módulo modificado para operar matrizes que armazenam listas! +* +* Arquivo gerado: TESTDADOPONTOS.C +* Letras identificadoras: TPec +* +* Nome da base de software: Exemplo de teste automatizado +* +* Projeto: Disciplinas INF 1628 / 1301 +* Gestor: DI/PUC-Rio +* Autores: avs - Arndt von Staa + 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/08/2015 Módulo modificado para operar dadospontos +* 3.00 avs 28/02/2003 Uniformização da interface das funções e +* de todas as condições de retorno. +* 2.00 avs 03/08/2002 Eliminação de código duplicado, reestruturação +* 1.00 avs 15/08/2001 Início do desenvolvimento +* +* $ED Descrição do módulo +* Este módulo contém as funções específicas para o teste do +* módulo Matriz. Ilustra como redigir um interpretador de comandos +* de teste específicos utilizando o arcabouço de teste para C. +* +* $EIU Interface com o usuário pessoa +* Comandos de teste específicos para testar o módulo Matriz: +* +* =criardadoponto - Chama a função Pec_tpCondRet Pec_CriarPeca(tppPeca * PecCriado); +* =destruirdadoponto - Chama a função Pec_tpCondRet Pec_DestruirPeca(tppPeca Peca); +* =obtervalorjogo - Chama a função Pec_tpCondRet Pec_ObterCor(tppPeca Peca, char *cor); +***************************************************************************/ + +#include +#include +#include + +#include "TST_ESPC.H" + +#include "GENERICO.H" +#include "lerparm.h" +#include "DADOPONTOS.h" + +/* Tabela dos nomes dos comandos de teste específicos */ +#define MAX 5 +#define CRIAR_DADOPONTOS_CMD "=criardadopontos" +#define DESTRUIR_DADOPONTOS_CMD "=destruirdadoponto" +#define OBTER_VALORPARTIDA_CMD "=obtervalorpartida" +#define DOBRAR_DADO_CMD "=dobrardado" +#define OBTER_DONO_CMD "=obterdono" + + +tppDadoPontos P[MAX]; +/***** 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 = DADPnt_CondRetOK ; + int CondRetEsperada = DADPnt_CondRetFaltouMemoria ; + /* inicializa para qualquer coisa */ + + char ValorEsperado = '?' ; + char ValorObtido = '!' ; + char ValorDado = '\0' ; + char corEsperada = 'x'; + + int NumLidos = -1 ; + int i = 0; + int ValorPontos,valoresperado; + char corRecebida; + int inxpec; + + TST_tpCondRet Ret; + + /* Testar Pec Criar Dado Pontos */ + if ( strcmp( ComandoTeste , CRIAR_DADOPONTOS_CMD ) == 0 ) + { + + NumLidos = LER_LerParametros( "ici" , + &inxpec,&corEsperada, &CondRetEsperada ) ; + if ( NumLidos != 3 ) + { + return TST_CondRetParm ; + } /* if */ + if(inxpec > 5 || inxpec < 0) return TST_CondRetErro; + + CondRetObtido = DADPtn_CriarDado(&P[inxpec]); + + + return TST_CompararInt( CondRetEsperada , CondRetObtido , + "Retorno errado ao criar ao criar dadopontos." ); + + } + /* fim ativa: Testar Criar Dado Pontos */ + + /* Testar Pec Destruir DadoPontos */ + else if ( strcmp( ComandoTeste , DESTRUIR_DADOPONTOS_CMD ) == 0 ) + { + + NumLidos = LER_LerParametros( "ii" , + &inxpec, &CondRetEsperada ) ; + if ( NumLidos != 2 ) + { + return TST_CondRetParm ; + } /* if */ + + CondRetObtido = DADPtn_DestruirDado(P[inxpec]) ; + + return TST_CompararInt( CondRetEsperada , CondRetObtido , + "Retorno errado ao destruir o dadopontos." ); + + } + /* fim ativa: Testar DadoPontos Destruir*/ + + /* Testar Obter Dono do DadoPonto */ + else if ( strcmp( ComandoTeste , OBTER_DONO_CMD ) == 0 ) + { + + NumLidos = LER_LerParametros( "ici" , + &inxpec, &corEsperada ,&CondRetEsperada ) ; + if ( NumLidos != 3 ) + { + return TST_CondRetParm ; + } /* if */ + CondRetObtido = DADPtn_ObterDono(P[inxpec],&corRecebida) ; + + Ret = TST_CompararChar( corRecebida , corEsperada , + "Cor do jogador errado, diferente do esperado" ) ; + + if ( Ret != TST_CondRetOK ) + { + return Ret ; + } /* if */ + + return TST_CompararChar(CondRetObtido, CondRetEsperada, "Retorno errado ao obter o dono do dado"); + + } + /* fim ativa: Testar Obter Dono do DadoPonto*/ + + /* Testar Dadoponto DobrarDado */ + else if ( strcmp( ComandoTeste , DOBRAR_DADO_CMD ) == 0 ) + { + + NumLidos = LER_LerParametros( "ici" , + &inxpec,&corEsperada, &CondRetEsperada ) ; + if ( NumLidos != 3 ) + { + return TST_CondRetParm ; + } /* if */ + if(inxpec > 5 || inxpec < 0) return TST_CondRetErro; + + CondRetObtido = DADPtn_DobrarDado(P[inxpec],corEsperada); + + return TST_CompararInt( CondRetEsperada , CondRetObtido , + "Retorno errado ao dobrar o valor do dadopontos." ); + + } /* fim ativa: Fim Dobrar Dado */ + + /* Testar Dadoponto Obter Valor */ + else if ( strcmp( ComandoTeste , OBTER_VALORPARTIDA_CMD ) == 0 ) + { + + NumLidos = LER_LerParametros( "iii" , + &inxpec,&valoresperado, &CondRetEsperada ) ; + if ( NumLidos != 3 ) + { + return TST_CondRetParm ; + } /* if */ + if(inxpec > 5 || inxpec < 0) return TST_CondRetErro; + + CondRetObtido = DADPtn_ValorPartida(P[inxpec],&ValorPontos); + + Ret = TST_CompararInt( valoresperado , ValorPontos , " Valor da Partida Errado" ) ; + + if ( Ret != TST_CondRetOK ) + { + return Ret ; + } + + return TST_CompararInt( CondRetObtido, CondRetEsperada , + "Retorno errado ao obter valor do dado pontos." ); + + } /* fim ativa: Fim Dobrar Dado */ + + + return TST_CondRetNaoConhec ; + + } /* Fim função: TPec Efetuar operações de teste específicas para DadoPonto */ \ No newline at end of file diff --git a/tabuleiro/ArcaboucoTeste.lib b/tabuleiro/ArcaboucoTeste.lib new file mode 100644 index 0000000..41ba199 Binary files /dev/null and b/tabuleiro/ArcaboucoTeste.lib differ diff --git a/tabuleiro/DADO.H b/tabuleiro/DADO.H new file mode 100644 index 0000000..5a2f0df --- /dev/null +++ b/tabuleiro/DADO.H @@ -0,0 +1,72 @@ +/*************************************************************************** +* +* $MCD Módulo de definição: Módulo Dado +* +* Arquivo gerado: Dado.H +* Letras identificadoras: DAD +* +* Nome da base de software: Exemplo de teste automatizado +* +* Projeto: Disciplinas INF 1628 / 1301 +* Gestor: DI/PUC-Rio +* Autores: avs - Arndt von Staa +* 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 avs 15/08/2001 Início do desenvolvimento +* +* $ED Descrição do módulo +* Este módulo implementa um conjunto simples de funções para gerar o resultado +* do dado "lançado". +* +***************************************************************************/ + +#if defined( DADO_OWN ) + #define DADO_EXT +#else + #define DADO_EXT extern +#endif + +/*********************************************************************** +* +* $TC Tipo de dados: MAT Condicoes de retorno +* +* +***********************************************************************/ + + typedef enum { + + DAD_CondRetOK = 0 , + /* Executou correto */ + + DAD_CondRetErro = 1 , + /* Estrutura do DadoPontos está errada */ + + DAD_CondRetMatrizNaoExiste = 2 , + /* DadoPontos não existe */ + + DAD_CondRetFaltouMemoria = 3 + /* Faltou memória ao alocar dados */ + + } DAD_tpCondRet ; + +/*********************************************************************** +* +* $FC Função: DAD &Gerar o numero de casas a serem paladas +* +* $ED Descrição da função +* Retorno o numero da casas a serem andadas +* $FV Valor retonado +* DAD_CondRetOK +* DAD_CondRetFaltouMemoria +***********************************************************************/ + +DAD_tpCondRet DAD_NumPular(int *NumeroCasas) ; + +#undef DADO_EXT + +/*************** Fim do módulo de definição: Módulo Dado ****************/ diff --git a/tabuleiro/DADO.c b/tabuleiro/DADO.c new file mode 100644 index 0000000..18832fc --- /dev/null +++ b/tabuleiro/DADO.c @@ -0,0 +1,86 @@ +/*************************************************************************** +* $MCI Módulo de implementação: Gerador de numeroes aleatorios restrito ao +* numero de faces +* +* Arquivo gerado: DADO.c +* Letras identificadoras: DAD +* +* Nome da base de software: Exemplo de teste automatizado +* +* Projeto: Disciplinas INF 1628 / 1301 +* Gestor: DI/PUC-Rio +* Autores: avs - Arndt von Staa +* 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 02/set/2015 Início do desenvolvimento +* +***************************************************************************/ + +#include +#include +#include + +#define DADO_OWN +#include "DADO.h" +#include +#undef DADO_OWN +#define RAN_MAX 0x7fff + +/*************************************************************************** +* +* Função: DAD & gerar o numero de casas que devem ser puladas com 1 dado +* ****/ + + +/* Funcao do Modulo */ +int dadorand(void); + + +/* fim funcao do modulo */ + +DAD_tpCondRet DAD_NumPular(int *NumeroCasas) +{ + *NumeroCasas = randint(6); + + return DAD_CondRetOK; +}/*Fim da função DAD_NumPular */ + +/* Função usada pelo módulo */ + + +/* Returns an integer in the range [1, n]. + * + * Uses rand(), and so is affected-by/affects the same seed. + */ +int randint(int n) { + int r; + if ((n - 1) == RAND_MAX) { + return rand(); + } else { + // Chop off all of the values that would cause skew... + long end = RAND_MAX / n; // truncate skew + assert (end > 0L); + end *= n; + + // ... and ignore results from rand() that fall above that limit. + // (Worst case the loop condition should succeed 50% of the time, + // so we can expect to bail out of this loop pretty quickly. + while ((r = rand()) >= end); + + r = (r|time(NULL)); + + return (r % n) +1; + } +} +/*********** Fim do módulo de implementação: Módulo Dado **************/ + + + + + + + diff --git a/tabuleiro/GENERICO.H b/tabuleiro/GENERICO.H new file mode 100644 index 0000000..c9d2692 --- /dev/null +++ b/tabuleiro/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/tabuleiro/LERPARM.H b/tabuleiro/LERPARM.H new file mode 100644 index 0000000..f12cf3d --- /dev/null +++ b/tabuleiro/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/tabuleiro/LISTA.C b/tabuleiro/LISTA.C new file mode 100644 index 0000000..2889ad9 --- /dev/null +++ b/tabuleiro/LISTA.C @@ -0,0 +1,560 @@ +/*************************************************************************** +* $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 */ + + +/***** 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/tabuleiro/LISTA.H b/tabuleiro/LISTA.H new file mode 100644 index 0000000..a9f9b84 --- /dev/null +++ b/tabuleiro/LISTA.H @@ -0,0 +1,346 @@ +#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_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 ) ; + +#undef LISTA_EXT + +/********** Fim do módulo de definição: LIS Lista duplamente encadeada **********/ + +#else +#endif diff --git a/tabuleiro/PECA.C b/tabuleiro/PECA.C new file mode 100644 index 0000000..696d6a6 --- /dev/null +++ b/tabuleiro/PECA.C @@ -0,0 +1,92 @@ +/*************************************************************************** +* $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: avs - Arndt von Staa +* 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{ + int *posicao; + /*Pontei para a posicao da peca, ainda deve ser alterado pelo tipo correto.*/ + char cor; + /*Devemos usar um inteiro para facilitar a manipulacao da peça pela cor? Porem a cor tambem determia qual jogador + tem a posse da peca*/ + //struct tpp * jogador; +} tpPeca; + + +/***** Dados encapsulados no módulo *****/ + + +/***** 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) +{ + 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/tabuleiro/PECA.h b/tabuleiro/PECA.h new file mode 100644 index 0000000..a63d488 --- /dev/null +++ b/tabuleiro/PECA.h @@ -0,0 +1,98 @@ +/*************************************************************************** +* +* $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: avs - Arndt von Staa +* 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: DADPnt 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: DADPnt 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: DADPnt 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/tabuleiro/TABULEIRO.C b/tabuleiro/TABULEIRO.C new file mode 100644 index 0000000..e0ae02a --- /dev/null +++ b/tabuleiro/TABULEIRO.C @@ -0,0 +1,143 @@ +/*************************************************************************** +* $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 TABULEIRO_OWN +#include "LISTA.H" +#include "GENERICO.H" +#include "PECA.h" +#include "TABULEIRO.H" + +#undef TABULEIRO_OWN + +/*********************************************************************** +* +* $TC Tipo de dados: TAB Tabuleiro +* +* +***********************************************************************/ + +typedef struct TAB_tagTabuleiro { + + LIS_tppLista Casas; + +} TAB_tpTabuleiro; + + +/***** Código das funções exportadas pelo módulo *****/ + +/*************************************************************************** +* +* Função: LIS &Criar Tabuleiro +* ****/ + +TAB_tpCondRet TAB_CriarTabuleiro(TAB_tppTabuleiro * pTab, + void ( * ExcluirValor ) ( void * pDado ) ) +{ + LIS_tppLista vtCasa[24]; // vetor de casas auxiliar + tppPeca vtPecaB[15]; // vetor de peças brancas + tppPeca vtPecaP[15]; //vetor de peças pretas + int i, jb = 0,jp = 0; + + *pTab = (TAB_tppTabuleiro)malloc(sizeof(TAB_tpTabuleiro)); + (*pTab)->Casas = LIS_CriarLista(ExcluirValor); + + /* Cria 15 peças brancas */ + for(i = 0; i < 15; i++) + if(Pec_CriarPeca(&vtPecaB[i], 'b')!=Pec_CondRetOK) + return TAB_CondRetErro; + /* Cria 15 peças pretas */ + for(i = 0; i < 15; i++) + if(Pec_CriarPeca(&vtPecaP[i], 'p')!=Pec_CondRetOK) + return TAB_CondRetErro; + /* Cria 24 listas que representam cada casa do tabuleiro*/ + for(i = 0; i < 24; i++) + vtCasa[i] = LIS_CriarLista(ExcluirValor); + + // Pretas + LIS_InserirElementoApos(vtCasa[23], vtPecaP[jp]); jp++; + LIS_InserirElementoApos(vtCasa[23], vtPecaP[jp]); jp++; + // Brancas + LIS_InserirElementoApos(vtCasa[0], vtPecaB[jb]); jb++; + LIS_InserirElementoApos(vtCasa[0], vtPecaB[jb]); jb++; + for(i = 0; i < 5; i++) + { + // Pretas + LIS_InserirElementoApos(vtCasa[5], vtPecaP[jp]); jp++; + LIS_InserirElementoApos(vtCasa[12], vtPecaP[jp]); jp++; + // Brancas + LIS_InserirElementoApos(vtCasa[11], vtPecaB[jb]); jb++; + LIS_InserirElementoApos(vtCasa[18], vtPecaB[jb]); jb++; + } + for(i = 0; i < 3; i++) + { + // Pretas + LIS_InserirElementoApos(vtCasa[7], vtPecaP[jp]); jp++; + // Brancas + LIS_InserirElementoApos(vtCasa[16], vtPecaB[jb]); jb++; + } + // Alocar as 24 casas na lista do tabuleiro + for(i = 0; i < 24; i++) + LIS_InserirElementoApos((*pTab)->Casas, vtCasa[i]); + + free(vtCasa); + free(vtPecaB); + free(vtPecaP); + + return TAB_CondRetOK; +} + +/* Destuir Tabuleiro */ + +TAB_tpCondRet TAB_DestruirTabuleiro (TAB_tppTabuleiro pTab) +{ + LIS_tppLista temp; + int i; + // Destroi as 24 casas + for(i = 0; i < 24; i++) + { + temp = (LIS_tppLista)LIS_ObterValor(pTab->Casas); + LIS_DestruirLista(temp); + LIS_AvancarElementoCorrente(pTab->Casas, -1); + } + // Destroi a lista principal + LIS_DestruirLista(pTab->Casas); + // Libera o ponteiro para o tabuleiro + free(pTab); + + return TAB_CondRetOK; +} + + + + + + + + + + diff --git a/tabuleiro/TABULEIRO.H b/tabuleiro/TABULEIRO.H new file mode 100644 index 0000000..7b024aa --- /dev/null +++ b/tabuleiro/TABULEIRO.H @@ -0,0 +1,162 @@ +#if ! defined( TABULEIRO_ ) +#define TABULEIRO_ +/*************************************************************************** +* +* $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 TAB_tagTabuleiro * TAB_tppTabuleiro; + + +/*********************************************************************** +* +* $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 { + + TAB_CondRetOK , + /* Concluiu corretamente */ + TAB_CondRetErro, + + } TAB_tpCondRet ; + + + + +/*********************************************************************** +* +* $FC Função: TAB &Criar Tabuleiro +* +* $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. +* +***********************************************************************/ + + TAB_tpCondRet TAB_CriarTabuleiro(TAB_tppTabuleiro * pTab, + void ( * ExcluirValor ) ( void * pDado ) ) ; + + +/*********************************************************************** +* +* $FC Função: TAB &Destruir Tabuleiro +* +* $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_DestruirTabuleiro( TAB_tppTabuleiro pTab ) ; + + +/*********************************************************************** +* +* $FC Função: TAB &Mover Peça do Tabuleiro +* +* $ED Descrição da função + +* +* $FV Valor retornado +* LIS_CondRetOK - Moveu sem problemas +* TAB_CondRetOK - Nao moveu a peça +* +***********************************************************************/ + + void TAB_MoverPeca( TAB_tppTabuleiro pTab, int casaOrigem, int casaDestino ) ; + + +/***********************************************************************/ + + + +#undef TABULEIRO_EXT + +/********** Fim do módulo de definição: LIS Lista duplamente encadeada **********/ + +#else +#endif \ No newline at end of file diff --git a/tabuleiro/TST_ESPC.H b/tabuleiro/TST_ESPC.H new file mode 100644 index 0000000..987ff8e --- /dev/null +++ b/tabuleiro/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