From ff9ef3c4f01bdd4ebc4afac79015bfa44e45a64d Mon Sep 17 00:00:00 2001 From: Tassio Date: Sat, 5 Sep 2015 11:52:44 -0300 Subject: [PATCH 1/6] =?UTF-8?q?Atualiza=C3=A7=C3=A3o=20do=20trabalho=202.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit O módulo dado completo. O módulo dado pontos com apenas uma função criada, criadadoponto. PDF do modelo do programa, dá pra modificar no projeto do processon --- Arquitetura do Programa.pdf | Bin 0 -> 18523 bytes DADO.H | 35 +++++++++-- DADO.c | 11 ++-- DADOPONTOS.c | 91 +++++++++++++++++++++++++++ DADOPONTOS.h | 119 ++++++++++++++++++++++++++++++++++++ 5 files changed, 248 insertions(+), 8 deletions(-) create mode 100644 Arquitetura do Programa.pdf create mode 100644 DADOPONTOS.c create mode 100644 DADOPONTOS.h diff --git a/Arquitetura do Programa.pdf b/Arquitetura do Programa.pdf new file mode 100644 index 0000000000000000000000000000000000000000..8c237d88736c59fbdff1ae7a8f7077f0f1dfb92d GIT binary patch literal 18523 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 literal 0 HcmV?d00001 diff --git a/DADO.H b/DADO.H index 77fe259..0e5dbee 100644 --- a/DADO.H +++ b/DADO.H @@ -32,15 +32,42 @@ #endif #include "GERAALT.H" +/*********************************************************************** +* +* $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 -* -* $EP Parâmetros -* +* Retorno o numero da casas a serem andadas +* $FV Valor retonado +* DAD_CondRetOK +* DAD_CondRetFaltouMemoria ***********************************************************************/ -int DAD_NumPular( void*) ; \ No newline at end of file +DAD_tpCondRet DAD_NumPular( void*, int*NumeroCasas) ; + +#undef DADO_EXT + +/*************** Fim do módulo de definição: Módulo Dado ****************/ diff --git a/DADO.c b/DADO.c index 3802913..72b1223 100644 --- a/DADO.c +++ b/DADO.c @@ -34,7 +34,7 @@ * Função: DAD & gerar o numero de casas que devem ser puladas com 1 dado * ****/ -int DAD_NumPular(void*) +DAD_tpCondRet DAD_NumPular(void*, int *NumeroCasas) { unsigned int i = 1; int DadoInicio = 1; @@ -42,12 +42,15 @@ int DAD_NumPular(void*) int *NumeroCasasPular; ALT_Inicializar( i ); - *NumeroCasasPular = ALT_GerarDistUniforme( DadoInicio, DadoFim ); + NumeroCasasPular = (int*)ALT_GerarDistUniforme( DadoInicio, DadoFim ); + NumeroCasas = NumeroCasasPular; - return 1; -} + return DAD_CondRetOK; +}/*Fim da função DAD_NumPular */ +/*********** Fim do módulo de implementação: Módulo Dado **************/ + diff --git a/DADOPONTOS.c b/DADOPONTOS.c new file mode 100644 index 0000000..b27186f --- /dev/null +++ b/DADOPONTOS.c @@ -0,0 +1,91 @@ +/*************************************************************************** +* $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 "DADO.H" +#include "GERAALT.H" + +#define DADO_OWN +#include "DADOPONTOS.h" +#undef DADO_OWN + +/*********************************************************************** +* +* $TC Tipo de dados: DADPnt Descritor do dados de ponto. +* +* $ED Descrição do tipo +* Descreve a estrutura do dados ponto +***********************************************************************/ + + typedef struct tgDadoPontos { + int valor; + /*Valor atual do dado de pontos*/ + struct Jogador * Jogador; + /*Ponteiro para o jogador que pode usar o dado + *$EED Assertivas Estruturais + * É NULL se o jogo esta no começo e ninguem fez nenhuma dobra */ + + + } tpDadoPontos ; + +/***** Dados encapsulados no módulo *****/ + + +/***** Código das funções exportadas pelo módulo *****/ + +/*************************************************************************** +* +* Função: DADPnt Criar Dado de Pontos +* ****/ + +DADPnt_tpCondRet DADPtn_CriarDado(tppDadoPontos * Dado) +{ + tpDadoPontos * DadoNovo = (tpDadoPontos*)malloc(sizeof(tpDadoPontos)); + DadoNovo->valor = 2; + /*Valor Inicial do Dado de Pontos*/ + DadoNovo->Jogador = NULL; + /*Quando o dado é criado, todos os jogadores podem usa-lo o inicio*/ + return DADPnt_CondRetOK; +} +/*************************************************************************** +* +* Função: DADPnt Dobrar Dado de Pontos +* ****/ + +DADPnt_tpCondRet DADPtn_DobrarDado(tppDadoPontos Dado); + +/*************************************************************************** +* +* Função: DADPnt Mudar "Dono" do Dado de Pontos +* ****/ + +DADPnt_tpCondRet DADPtn_MudDono(tppDadoPontos Dado); + +/*************************************************************************** +* +* Função: DADPnt Destruir Dado de Pontos +* ****/ + +DADPnt_tpCondRet DADPtn_DestruirDado(tppDadoPontos Dado); + +/*********** Fim do módulo de implementação: Módulo DadoPontos **************/ diff --git a/DADOPONTOS.h b/DADOPONTOS.h new file mode 100644 index 0000000..b59cc19 --- /dev/null +++ b/DADOPONTOS.h @@ -0,0 +1,119 @@ +/*************************************************************************** +* +* $MCD Módulo de definição: Módulo Dado +* +* Arquivo gerado: DadoPontos.H +* Letras identificadoras: DADPnt +* +* 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 05/09/2015 Início do desenvolvimento +* +* $ED Descrição do módulo +* Este módulo implementa um conjunto simples de funções para verificar o +* valor atual da partida e qual jogador pode utilizar o dado. +* +***************************************************************************/ + +#if defined( DADOPONTOS_OWN ) + #define DADOPONTOS_EXT +#else + #define DADOPONTOS_EXT extern +#endif + +#include "LISTA.H" + +typedef struct tgDadoPontos * tppDadoPontos; +/*********************************************************************** +* +* $TC Tipo de dados: MAT Condicoes de retorno +* +* +***********************************************************************/ + + typedef enum { + + DADPnt_CondRetOK = 0 , + /* Executou correto */ + + DADPnt_CondRetErro = 1 , + /* Estrutura do DadoPontos está errada */ + + DADPnt_CondRetMatrizNaoExiste = 2 , + /* DadoPontos não existe */ + + DADPnt_CondRetFaltouMemoria = 3 + /* Faltou memória ao alocar dados */ + + } DADPnt_tpCondRet ; + + +/*********************************************************************** +* +* $FC Função: DADPnt Criar Dado de Pontos +* +* $ED Descrição da função +* Cria um novo dado de pontos +* $FV Valor retonado +* DADPnt_CondRetOK +* DADPnt_CondRetFaltouMemoria +* +***********************************************************************/ + +DADPnt_tpCondRet DADPtn_CriarDado(tppDadoPontos * Dado) + +/*************************************************************************** +* +* $FC Função: DADPnt Dobrar Dado de Pontos +* +* $ED Descrição da função +* Dobra o valor da partida +* $FV Valor retonado +* DADPnt_CondRetOK +* DADPnt_CondRetFaltouMemoria +* +***********************************************************************/ + +DADPnt_tpCondRet DADPtn_DobrarDado(tppDadoPontos Dado); + +/*************************************************************************** +* +* $FC Função: DADPnt Mudar "Dono" do Dado de Pontos +* +* $ED Descrição da função +* Muda o jogador que possa usar o Dado de Pontos +* $FV Valor retonado +* DADPnt_CondRetOK +* DADPnt_CondRetFaltouMemoria +* +***********************************************************************/ + +DADPnt_tpCondRet DADPtn_MudDono(tppDadoPontos Dado); + +/*************************************************************************** +* +* $FC Função: DADPnt Destroi o Dado de Pontos +* +* $ED Descrição da função +* Destroi o Dado de Pontos +* $FV Valor retonado +* DADPnt_CondRetOK +* DADPnt_CondRetFaltouMemoria +* +***********************************************************************/ + +DADPnt_tpCondRet DADPtn_DestruirDado(tppDadoPontos Dado); + +#undef DADOPONTOS_EXT + +/*************** Fim do módulo de definição: Módulo DadoPontos ****************/ From 3f53cd5cfa8755bb96bcabae38bfed8686149f98 Mon Sep 17 00:00:00 2001 From: Tassio Date: Wed, 23 Sep 2015 17:05:46 -0300 Subject: [PATCH 2/6] modulo dadopontos pronto --- DadoPontos/Source/DADOPONTOS.c | 132 ++++++ DadoPontos/Source/DADOPONTOS.h | 132 ++++++ DadoPontos/Source/GENERICO.H | 713 ++++++++++++++++++++++++++++++ DadoPontos/Source/LERPARM.H | 463 +++++++++++++++++++ DadoPontos/Source/TST_ESPC.H | 320 ++++++++++++++ DadoPontos/TRAB2-2.exe | Bin 0 -> 76800 bytes DadoPontos/TesteDadoPontos.bat | 1 + DadoPontos/TesteDadoPontos.script | 46 ++ DadoPontos/logTesteDadoPontos.txt | 39 ++ 9 files changed, 1846 insertions(+) create mode 100644 DadoPontos/Source/DADOPONTOS.c create mode 100644 DadoPontos/Source/DADOPONTOS.h create mode 100644 DadoPontos/Source/GENERICO.H create mode 100644 DadoPontos/Source/LERPARM.H create mode 100644 DadoPontos/Source/TST_ESPC.H create mode 100644 DadoPontos/TRAB2-2.exe create mode 100644 DadoPontos/TesteDadoPontos.bat create mode 100644 DadoPontos/TesteDadoPontos.script create mode 100644 DadoPontos/logTesteDadoPontos.txt diff --git a/DadoPontos/Source/DADOPONTOS.c b/DadoPontos/Source/DADOPONTOS.c new file mode 100644 index 0000000..32d4a55 --- /dev/null +++ b/DadoPontos/Source/DADOPONTOS.c @@ -0,0 +1,132 @@ +/*************************************************************************** +* $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 +#include +#include "GENERICO.H" + +#define DADO_OWN +#include "DADOPONTOS.h" +#undef DADO_OWN + +/*********************************************************************** +* +* $TC Tipo de dados: DADPnt Descritor do dados de ponto. +* +* $ED Descrição do tipo +* Descreve a estrutura do dados ponto +***********************************************************************/ + + typedef struct tgDadoPontos { + int valor; + /*Valor atual do dado de pontos*/ + char CorDoJogador; + /*Ponteiro para o jogador que pode usar o dado + *$EED Assertivas Estruturais + * É NULL se o jogo esta no começo e ninguem fez nenhuma dobra */ + + } tpDadoPontos ; + +/***** Dados encapsulados no módulo *****/ + + +/***** Código das funções exportadas pelo módulo *****/ + +/*************************************************************************** +* +* Função: DADPnt Criar Dado de Pontos +* ****/ + +DADPnt_tpCondRet DADPtn_CriarDado(tppDadoPontos * DadoPontoCriado) +{ + + *DadoPontoCriado = (tpDadoPontos*)malloc(sizeof(tpDadoPontos)); + + if(DadoPontoCriado == NULL) + return DADPnt_CondRetFaltouMemoria; + + (*DadoPontoCriado)->valor = 2; + /*Valor Inicial do Dado de Pontos*/ + (*DadoPontoCriado)->CorDoJogador = 's'; + /*Quando o dado é criado, todos os jogadores podem usa-lo o inicio + s determinado que qualquer jogador pode usar*/ + return DADPnt_CondRetOK; +} +/*************************************************************************** +* +* Função: DADPnt Dobrar Dado de Pontos e Mudar "Dono" do Dado de Pontos +* ****/ + +DADPnt_tpCondRet DADPtn_DobrarDado(tppDadoPontos DadoDobrar, char CorNovoDono) +{ + DadoDobrar->valor = DadoDobrar->valor * 2; + DadoDobrar->CorDoJogador = CorNovoDono; + /*Pega o valor atual do dado e multiplica por 2*/ + return DADPnt_CondRetOK; +} + +/*************************************************************************** +* +* Função: DADPnt Gerar Valor da Partida +* ****/ + +DADPnt_tpCondRet DADPtn_ValorPartida(tppDadoPontos DadoAtual, int * valorjogo) +{ + if(DadoAtual->CorDoJogador == 's' ) + *valorjogo = 2; + else + *valorjogo = DadoAtual->valor; + return DADPnt_CondRetOK; +} + +/*************************************************************************** +* +* $FC Função: DADPnt Obter "Dono" do dado de pontos atual +* +* $ED Descrição da função +* Retorno o dono do Dado +* $FV Valor retonado +* DADPnt_CondRetOK +* +***********************************************************************/ + +DADPnt_tpCondRet DADPtn_ObterDono(tppDadoPontos DadoPonto, char * CorDonoAtual) +{ + *CorDonoAtual = DadoPonto->CorDoJogador; + return DADPnt_CondRetOK; +} + +/*************************************************************************** +* +* Função: DADPnt Destruir Dado de Pontos +* ****/ + +DADPnt_tpCondRet DADPtn_DestruirDado(tppDadoPontos Dado) +{ + if(Dado == NULL) + return DADPnt_CondRetDadoPontosNaoExiste; + free(Dado); + return DADPnt_CondRetOK; +} +/*********** Fim do módulo de implementação: Módulo DadoPontos **************/ diff --git a/DadoPontos/Source/DADOPONTOS.h b/DadoPontos/Source/DADOPONTOS.h new file mode 100644 index 0000000..31e9c32 --- /dev/null +++ b/DadoPontos/Source/DADOPONTOS.h @@ -0,0 +1,132 @@ +/*************************************************************************** +* +* $MCD Módulo de definição: Módulo Dado +* +* Arquivo gerado: DadoPontos.H +* Letras identificadoras: DADPnt +* +* 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 05/09/2015 Início do desenvolvimento +* +* $ED Descrição do módulo +* Este módulo implementa um conjunto simples de funções para verificar o +* valor atual da partida e qual jogador pode utilizar o dado. +* +***************************************************************************/ + +#if defined( DADOPONTOS_OWN ) + #define DADOPONTOS_EXT +#else + #define DADOPONTOS_EXT extern +#endif + +#include "Generico.h" + +typedef struct tgDadoPontos * tppDadoPontos; +typedef struct tgPlayers * tppPlayers; +/*********************************************************************** +* +* $TC Tipo de dados: MAT Condicoes de retorno +* +* +***********************************************************************/ + + typedef enum { + + DADPnt_CondRetOK = 0 , + /* Executou correto */ + + DADPnt_CondRetErro = 1 , + /* Estrutura do DadoPontos está errada */ + + DADPnt_CondRetDadoPontosNaoExiste = 2 , + /* DadoPontos não existe */ + + DADPnt_CondRetFaltouMemoria = 3 + /* Faltou memória ao alocar dados */ + + } DADPnt_tpCondRet ; + + +/*********************************************************************** +* +* $FC Função: DADPnt Criar Dado de Pontos +* +* $ED Descrição da função +* Cria um novo dado de pontos +* $FV Valor retonado +* DADPnt_CondRetOK +* DADPnt_CondRetFaltouMemoria +* +***********************************************************************/ + +DADPnt_tpCondRet DADPtn_CriarDado(tppDadoPontos * DadoCriado); + +/*************************************************************************** +* +* $FC Função: DADPnt Dobrar Dado de Pontos e Mudar "Dono" do Dado de Pontos +* +* $ED Descrição da função +* Dobra o valor da partida e Muda o jogador que possa usar o Dado de Pontos +* $FV Valor retonado +* DADPnt_CondRetOK +* DADPnt_CondRetFaltouMemoria +* +***********************************************************************/ + +DADPnt_tpCondRet DADPtn_DobrarDado(tppDadoPontos DadoDobrar, char CorNovoDono); + +/*************************************************************************** +* +* $FC Função: DADPnt Valor da partida +* +* $ED Descrição da função +* Gera o valor atual da partida +* $FV Valor retonado +* DADPnt_CondRetOK +* +***********************************************************************/ + +DADPnt_tpCondRet DADPtn_ValorPartida(tppDadoPontos Dado, int * valorjogo); + +/*************************************************************************** +* +* $FC Função: DADPnt Obter "Dono" do dado de pontos atual +* +* $ED Descrição da função +* Retorno o dono do Dado +* $FV Valor retonado +* DADPnt_CondRetOK +* +***********************************************************************/ + +DADPnt_tpCondRet DADPtn_ObterDono(tppDadoPontos Dado, char * corRecebida); + +/*************************************************************************** +* +* $FC Função: DADPnt Destroi o Dado de Pontos +* +* $ED Descrição da função +* Destroi o Dado de Pontos +* $FV Valor retonado +* DADPnt_CondRetOK +* DADPnt_CondRetFaltouMemoria +* +***********************************************************************/ + +DADPnt_tpCondRet DADPtn_DestruirDado(tppDadoPontos Dado); + +#undef DADOPONTOS_EXT + +/*************** Fim do módulo de definição: Módulo DadoPontos ****************/ 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/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 0000000000000000000000000000000000000000..13e96351d106f7e2aa73c23e6b8beb5fa3451f62 GIT binary patch literal 76800 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 SK|0K` logTesteDadoPontos.txt \ No newline at end of file diff --git a/DadoPontos/TesteDadoPontos.script b/DadoPontos/TesteDadoPontos.script new file mode 100644 index 0000000..76f8783 --- /dev/null +++ b/DadoPontos/TesteDadoPontos.script @@ -0,0 +1,46 @@ +// SCRIPT DE TESTE PARA O MODULO DADOSPnt +== Criar DadoPontos +=criardadopontos 0 's' 0 + +== Obter Dono +=obterdono 0 's' 0 + +== Obter Valor +=obtervalorpartida 0 2 0 + +== Dobrar Dado +=dobrardado 0 'b' 0 + +== Obter Dono +=obterdono 0 'b' 0 + +== Obter Valor +=obtervalorpartida 0 4 0 + +== Dobrar Dado +=dobrardado 0 'p' 0 + +== Dobrar Dado +=dobrardado 0 'b' 0 + +== Dobrar Dado +=dobrardado 0 'p' 0 + +== Obter Valor +=obtervalorpartida 0 32 0 + +== Dobrar Dado +=dobrardado 0 'b' 0 + +== Obter Dono +=obterdono 0 'b' 0 + +== Obter Valor Errado +=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 From ec66057d46170099ef1ba7617a20fc8b083907a3 Mon Sep 17 00:00:00 2001 From: Tassio Date: Wed, 23 Sep 2015 17:27:15 -0300 Subject: [PATCH 3/6] agora ta certo --- DadoPonto/DADOPONTOS.c | 129 ----------------- DadoPonto/DADOPONTOS.h | 130 ------------------ DadoPonto/testescript.script | 47 ------- .../Source}/TESTDADOPONTOS.c | 23 ++-- 4 files changed, 13 insertions(+), 316 deletions(-) delete mode 100644 DadoPonto/DADOPONTOS.c delete mode 100644 DadoPonto/DADOPONTOS.h delete mode 100644 DadoPonto/testescript.script rename {DadoPonto => DadoPontos/Source}/TESTDADOPONTOS.c (91%) diff --git a/DadoPonto/DADOPONTOS.c b/DadoPonto/DADOPONTOS.c deleted file mode 100644 index a19cd12..0000000 --- a/DadoPonto/DADOPONTOS.c +++ /dev/null @@ -1,129 +0,0 @@ -/*************************************************************************** -* $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 -#include - -#define DADO_OWN -#include "DADOPONTOS.h" -#undef DADO_OWN - -/*********************************************************************** -* -* $TC Tipo de dados: DADPnt Descritor do dados de ponto. -* -* $ED Descrição do tipo -* Descreve a estrutura do dados ponto -***********************************************************************/ - - typedef struct tgDadoPontos { - int valor; - /*Valor atual do dado de pontos*/ - char CorDoJogador; - /*Ponteiro para o jogador que pode usar o dado - *$EED Assertivas Estruturais - * É NULL se o jogo esta no começo e ninguem fez nenhuma dobra */ - - } tpDadoPontos ; - -/***** Dados encapsulados no módulo *****/ - - -/***** Código das funções exportadas pelo módulo *****/ - -/*************************************************************************** -* -* Função: DADPnt Criar Dado de Pontos -* ****/ - -DADPnt_tpCondRet DADPtn_CriarDado(tppDadoPontos * DadoPontoCriado) -{ - - *DadoPontoCriado = (tpDadoPontos*)malloc(sizeof(tpDadoPontos)); - - if(DadoPontoCriado == NULL) - return DADPnt_CondRetFaltouMemoria; - - (*DadoPontoCriado)->valor = 2; - /*Valor Inicial do Dado de Pontos*/ - (*DadoPontoCriado)->CorDoJogador = 's'; - /*Quando o dado é criado, todos os jogadores podem usa-lo o inicio - s determinado que qualquer jogador pode usar*/ - return DADPnt_CondRetOK; -} -/*************************************************************************** -* -* Função: DADPnt Dobrar Dado de Pontos e Mudar "Dono" do Dado de Pontos -* ****/ - -DADPnt_tpCondRet DADPtn_DobrarDado(tppDadoPontos DadoDobrar, char CorNovoDono) -{ - DadoDobrar->valor = DadoDobrar->valor * 2; - DadoDobrar->CorDoJogador = CorNovoDono; - /*Pega o valor atual do dado e multiplica por 2*/ - return DADPnt_CondRetOK; -} - -/*************************************************************************** -* -* Função: DADPnt Gerar Valor da Partida -* ****/ - -DADPnt_tpCondRet DADPtn_ValorPartida(tppDadoPontos DadoAtual, int * valorjogo) -{ - if(DadoAtual->CorDoJogador == 's' ) - *valorjogo = 2; - else - *valorjogo = DadoAtual->valor; - return DADPnt_CondRetOK; -} - -/*************************************************************************** -* -* $FC Função: DADPnt Obter "Dono" do dado de pontos atual -* -* $ED Descrição da função -* Retorno o dono do Dado -* $FV Valor retonado -* DADPnt_CondRetOK -* -***********************************************************************/ - -DADPnt_tpCondRet DADPtn_ObterDono(tppDadoPontos DadoPonto, char * CorDonoAtual) -{ - *CorDonoAtual = DadoPonto->CorDoJogador; - return DADPnt_CondRetOK; -} - -/*************************************************************************** -* -* Função: DADPnt Destruir Dado de Pontos -* ****/ - -DADPnt_tpCondRet DADPtn_DestruirDado(tppDadoPontos Dado) -{ - free(Dado); - return DADPnt_CondRetOK; -} -/*********** Fim do módulo de implementação: Módulo DadoPontos **************/ diff --git a/DadoPonto/DADOPONTOS.h b/DadoPonto/DADOPONTOS.h deleted file mode 100644 index b73dd7a..0000000 --- a/DadoPonto/DADOPONTOS.h +++ /dev/null @@ -1,130 +0,0 @@ -/*************************************************************************** -* -* $MCD Módulo de definição: Módulo Dado -* -* Arquivo gerado: DadoPontos.H -* Letras identificadoras: DADPnt -* -* 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 05/09/2015 Início do desenvolvimento -* -* $ED Descrição do módulo -* Este módulo implementa um conjunto simples de funções para verificar o -* valor atual da partida e qual jogador pode utilizar o dado. -* -***************************************************************************/ - -#if defined( DADOPONTOS_OWN ) - #define DADOPONTOS_EXT -#else - #define DADOPONTOS_EXT extern -#endif - -typedef struct tgDadoPontos * tppDadoPontos; -typedef struct tgPlayers * tppPlayers; -/*********************************************************************** -* -* $TC Tipo de dados: MAT Condicoes de retorno -* -* -***********************************************************************/ - - typedef enum { - - DADPnt_CondRetOK = 0 , - /* Executou correto */ - - DADPnt_CondRetErro = 1 , - /* Estrutura do DadoPontos está errada */ - - DADPnt_CondRetMatrizNaoExiste = 2 , - /* DadoPontos não existe */ - - DADPnt_CondRetFaltouMemoria = 3 - /* Faltou memória ao alocar dados */ - - } DADPnt_tpCondRet ; - - -/*********************************************************************** -* -* $FC Função: DADPnt Criar Dado de Pontos -* -* $ED Descrição da função -* Cria um novo dado de pontos -* $FV Valor retonado -* DADPnt_CondRetOK -* DADPnt_CondRetFaltouMemoria -* -***********************************************************************/ - -DADPnt_tpCondRet DADPtn_CriarDado(tppDadoPontos * DadoCriado); - -/*************************************************************************** -* -* $FC Função: DADPnt Dobrar Dado de Pontos e Mudar "Dono" do Dado de Pontos -* -* $ED Descrição da função -* Dobra o valor da partida e Muda o jogador que possa usar o Dado de Pontos -* $FV Valor retonado -* DADPnt_CondRetOK -* DADPnt_CondRetFaltouMemoria -* -***********************************************************************/ - -DADPnt_tpCondRet DADPtn_DobrarDado(tppDadoPontos DadoDobrar, char CorNovoDono); - -/*************************************************************************** -* -* $FC Função: DADPnt Valor da partida -* -* $ED Descrição da função -* Gera o valor atual da partida -* $FV Valor retonado -* DADPnt_CondRetOK -* -***********************************************************************/ - -DADPnt_tpCondRet DADPtn_ValorPartida(tppDadoPontos Dado, int * valorjogo); - -/*************************************************************************** -* -* $FC Função: DADPnt Obter "Dono" do dado de pontos atual -* -* $ED Descrição da função -* Retorno o dono do Dado -* $FV Valor retonado -* DADPnt_CondRetOK -* -***********************************************************************/ - -DADPnt_tpCondRet DADPtn_ObterDono(tppDadoPontos Dado, char * corRecebida); - -/*************************************************************************** -* -* $FC Função: DADPnt Destroi o Dado de Pontos -* -* $ED Descrição da função -* Destroi o Dado de Pontos -* $FV Valor retonado -* DADPnt_CondRetOK -* DADPnt_CondRetFaltouMemoria -* -***********************************************************************/ - -DADPnt_tpCondRet DADPtn_DestruirDado(tppDadoPontos Dado); - -#undef DADOPONTOS_EXT - -/*************** Fim do módulo de definição: Módulo DadoPontos ****************/ diff --git a/DadoPonto/testescript.script b/DadoPonto/testescript.script deleted file mode 100644 index b1b1fbc..0000000 --- a/DadoPonto/testescript.script +++ /dev/null @@ -1,47 +0,0 @@ -// SCRIPT DE TESTE PARA O MODULO DADOSPnt -== Criar DadoPontos -=criardadopontos 0 's' 0 - -== Obter Dono -=obterdono 0 's' 0 - -== Obter Valor -=obtervalorpartida 0 2 0 - -== Dobrar Dado -=dobrardado 0 'b' 0 - -== Obter Dono -=obterdono 0 'b' 0 - -== Obter Valor -=obtervalorpartida 0 4 0 - -== Dobrar Dado -=dobrardado 0 'p' 0 - -== Dobrar Dado -=dobrardado 0 'b' 0 - -== Dobrar Dado -=dobrardado 0 'p' 0 - -== Obter Valor -=obtervalorpartida 0 32 0 - -== Dobrar Dado -=dobrardado 0 'b' 0 - -== Obter Dono -=obterdono 0 'b' 0 - -== Obter Valor Errado -=obtervalorpartida 0 63 0 -=recuperar - -== Obter Valor -=obtervalorpartida 0 64 0 - - -== Destruir DadoPontos -=destruirdadoponto 0 0 \ No newline at end of file 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 ; From f62876fea4696d9baf4b50bc976700074b60302a Mon Sep 17 00:00:00 2001 From: Tassio Date: Wed, 23 Sep 2015 17:47:03 -0300 Subject: [PATCH 4/6] Atualizacao --- README.txt | 0 1 file changed, 0 insertions(+), 0 deletions(-) delete mode 100644 README.txt diff --git a/README.txt b/README.txt deleted file mode 100644 index e69de29..0000000 From a9f64bc647073293b02e58447550b153311945ea Mon Sep 17 00:00:00 2001 From: Tassio Date: Wed, 23 Sep 2015 18:00:37 -0300 Subject: [PATCH 5/6] testdadopontos --- TESTDADOPONTOS.c | 210 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 210 insertions(+) create mode 100644 TESTDADOPONTOS.c 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 From b28b4c52796df7303d083d4685da86f57afaf00e Mon Sep 17 00:00:00 2001 From: Tassio Date: Wed, 23 Sep 2015 18:19:29 -0300 Subject: [PATCH 6/6] Tabuleiro Modulo --- tabuleiro/ArcaboucoTeste.lib | Bin 0 -> 89288 bytes tabuleiro/DADO.H | 72 +++++ tabuleiro/DADO.c | 86 +++++ tabuleiro/GENERICO.H | 588 +++++++++++++++++++++++++++++++++++ tabuleiro/LERPARM.H | 463 +++++++++++++++++++++++++++ tabuleiro/LISTA.C | 560 +++++++++++++++++++++++++++++++++ tabuleiro/LISTA.H | 346 +++++++++++++++++++++ tabuleiro/PECA.C | 92 ++++++ tabuleiro/PECA.h | 98 ++++++ tabuleiro/TABULEIRO.C | 143 +++++++++ tabuleiro/TABULEIRO.H | 162 ++++++++++ tabuleiro/TST_ESPC.H | 320 +++++++++++++++++++ 12 files changed, 2930 insertions(+) create mode 100644 tabuleiro/ArcaboucoTeste.lib create mode 100644 tabuleiro/DADO.H create mode 100644 tabuleiro/DADO.c create mode 100644 tabuleiro/GENERICO.H create mode 100644 tabuleiro/LERPARM.H create mode 100644 tabuleiro/LISTA.C create mode 100644 tabuleiro/LISTA.H create mode 100644 tabuleiro/PECA.C create mode 100644 tabuleiro/PECA.h create mode 100644 tabuleiro/TABULEIRO.C create mode 100644 tabuleiro/TABULEIRO.H create mode 100644 tabuleiro/TST_ESPC.H diff --git a/tabuleiro/ArcaboucoTeste.lib b/tabuleiro/ArcaboucoTeste.lib new file mode 100644 index 0000000000000000000000000000000000000000..41ba1990924bce9779c6bdfa6b21565e71e10993 GIT binary patch literal 89288 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

(+lxk=fk>%<99^g>Amgv#<{Lp z5O6HIcgLFp-usv6Ui8p2x?V|o?_oq?e-Gw2xTEp>%-c}E#ISJPTh#s7LaNxm@j-y- z`pnJvv)i4iVCA{h^r^T71fBR)?yvWzX4<}4!|Q?~(aVDAgh-NgMi}oGiS%{R2M47h zGfAU}c4ykYJVGX`=O8n~Q=pKHb!yYZJ=E9ZjyK0zx63dlk$!Jq0dq%+Hn=m-kp6Fw zdZ%j6fkgVxWcsD(@bz!R*U18%A9hoIOd;c+Ih;iGFJ(jO0IHHlTZqah<~{B5>_arG z{yd2*a*y4MzYAGforpVzQtUn+sn}4GIe{stRTG?rT*v$zXqIwn?<`kCJ!~Plx~Thb z(ci1*ec*F)s?3XsrbMgV^P=S`^P|*Dm+G1Txa=xBvOX zGEQX!vWApkK1h87oXkj)Q8;l;UZV0@=sjM*OBdom5QJ%EGR-ZWYO$ z1<5H!nbVD86*Eezw=Tstg~u%S)My^+Y#$Q08HuZp?m^n(l9ebuMx{X3Q^ZK=Cu+u# zq=Yq1>X)A2l0r=y=X7FjsjSgLcZ|&^vG+_FDypRkjLWe9|MhdiyZge!k@+Vp8{8=W z9e<;oEPqNqQAP4n&5dudO!E%vP;}4YsC%G;K$C z82U#A~AGnzkeIu4dOy6?%qQC!nOr4gLyW-|6C5WiALe zG#QeiJhD-8$IKkJrP+MsrEJG^S6F7%v2|}{Kql7!ejlQFB{d7`qVITL;^=j>&_~b3 zq?R>B58-**)0#Pa+TqCTt|v1y!H>lfS}C@;Pn&%Ls>>;WS(KB3i_u4}tQGXR~3o z^t#b8?K+l}*8Ld5JJ)1hFe6;M1yG?rc+|9hdE3k6IA$iLN+K#VJvqYq`$Xmrmkckgc2xJZm!|e{xdSm$}M^IKHWsZ zUb=%M3lGobneqi?t&!`_h(Kq?xz^zOURzID>)}9@?*zGny>Ca~>wYObv$rb6utu+^ zbIQr8t5c$X;_m0p?zbaDdM@qZ{_){~J^4MiDGZ^Ej6TIScwfRz(fbxA2RAHW0tyGM z(@5kX$}hEk2`08Oecdj)kNZ#ZJaA|~K?J!Urv5x`{9uLaN0b>Xj~n{P_h1-3 zF0CSpeR!f7PW1e&^ByhW_wG;pzSLXxe&WYpC)Y0(PO}nCHR*``i2-vr!(5{8{^0qG z`ta*AkjwCyhYm) zAkjus_EK2N-+)A05;8`#WdMm}nzkp}CTiL&AR}!+M%sXkv;i4u12WPEB-(BRGSUWQ zqzy>4eG90Tt)jJ9g!YuCy#yo^;SXxsAA!m_hsax7VqAdEgxEI`h+2eXl?$|x`O1LA z(rO^FbODf9S`Tyy$7lo+O9Mb+>Fq$G;~pTXIbQ;r$&z;f$%J{DEH3qBKahvz9RLz3 zzXKY@v_ELt8$hF(MytFC-}^w9G3~FK=ECDtCaGTpl*yr^fFuS@FCW9S$(lA5=yIk} zS6TQ z&=AmgrriW2I&K3J9rpuC+vX zvJvA#Ac>I=Bso+8BssJINOGtFNOGtNNOGtZNbVV0nMNev1SGc5dNd;WOF&X1z5^uk zegq`)eg-7+{sU+tTlzGR$fIxhBJT*0$Qy()WU=&oAhGlcAd#E{B$D%iMDk~V#L^NV zkvtnnB-aCpc!x}vSBo^!j5(^Fhi3KkKi3JCN#DYUWV!_)$V!?Yr zV!e@>D5p5knqU|mq(e@=E zsgqkY?Fk?wZ9qoafQ+;O8EFGD(guY8(DpX|7-<7C(l*%Cb}rCR<{PJJGc{TWBzl{H zL~jU4^xg_2dOLwc?*<^z+Y2OmKMy2&9|4k7eh*0W?$NY2fJEC-Akj8ph^g%?Akmf% zB-(}piMES@MB8ORqAeFlv=su0wn~kz*P%B7iQYSbMDOQ-B$ZzV61|&&W+SgM)T2P6 z_uD|C_xnJicNdW8eHKXWvfl!U1%K3`9{`EoWGEHA=ira%y$DG3dVprL-f=*p_bMRK z>je_MWk8~LF_36$*0j5TMB9Tv_>a2rb^N)8C4UP@v~2|vZQFrF+fRW+TR)I!djUwa z{Sin~IRuTa(8dCZwmcv(K-)Dy*RZw)K%(t>AknrANVF{n5^XDiMB92Gk$f-E*(~ot zAZZVNszZMXBs!i45*;rCiH_HSCUM-uK%(OvAkmQmv7%!PP=GDX0cznG#Tu0ZE$7e$ zK<9Gk^*S`H(JeqZ9C|xYGsn1Fhd!jy*MUUacYs9R4}mH;#!rE=S;|fzv3W0$*!%|2 z91i^m$jfNZP*X}Okn~@&fFxh00!hAn21xRy9Ec_*CaXC>qN4^#bhH5Z5t^ZH1EQCW zWYq;E`4ZK%do}Iffby8{``kk8c0(429WfX-v+AW(D#AF(&Ip4sTJ>aoi_>q~7laI*a2T01{hX0uoye0*Nh$fX-*Ww}Ixdl=pzdmce-BisVayq_oBW zrE-k%Kqws8mkoq!36u{cHqQXUf6$8YNAju?C z2)8h#tOdG(Lq7{7X?qAr-f_MSB$oadNGx~?NK*bZkfi+AK$7y`0S#x#uK-EP-vE-7 ze+(q@hQM^uaS_mk9K)k&V}Q!pstKBw4YY!3vw%d(av&+0n}NjoZXmJmZXmJmJ|MC0 zA)pl2wgpJ+`zDas_au-=-UlT1J*&}gfEKU?uK-E@y#W+v8nWM@4FM8c&Ib~C`9NZ6 znGUT15=)l=iKWYc#L^W&VrdXaER6t(rBNV}ycK99r)V3Hf5*5sBoK9w^58s+ z5#<_{E!>xJrl<8Ft_gD)Eya00qjsEY7=2n9(yh zFJW{L=Xyp*aBg5km0~F)8dvf$@&GMklm*nts1T@$Q8kdC(NZ9)kAqY@5ZO3LbpmxT zx(6u2sPG@Q>gOiNcOG`{0~8y47A6`DU)Xwozr~9eeLjc>J`1)zLntK4l?&_RkBdP{ zM+oz9@OYeQ2vR5w?Xs;RjTTxw^c18!!J<%G;Bio>H0a}&#nT3gwX!2F)NT0D_Y;eU z(x0U%_Sy9V5t8KUBUT*mUOV&&L0Ee-H+xDBUoejnNLOVS7!+1zsbs@U?`3)1_k#fwF$C+Q5g{j;g{sv3>h?1ZXKq7 zRys%`C*D7cxao=K!OzmQ6IWRd%5%7S#zA=vS8|X&bbKI}I1?qYGy7mzX&w?wp29>k z<>Z5>5I?d9auTkC>?&jN1J|C=oeCF&BeCaTvL}89eF8U{hCPYY;wC za)|a|yPq06K1^NP5bGWYu_W&V#mVzqP-sPMi|0?ogTk^Xw5-fl2W2EES?Cg3Jh{Z< zpv(oOda#{`-2V?cDC|^8hGE92EMl(1}i?#nT6h2d@Mcc-2!xbHiWzx~8XG>Xg@?mE5r{_ew%}@c_NP0G4Y_uug2k6O4&#L^aCJ;O;%xOA?Ah&{fI&B;}RZ1b%*_KsOh zmx@d8ww+*$Zc3(g2RPQ@joUtwc+HK(?O8~Sv0H=_uhW!9e@A;$piO(OYQNQN@=di4 zb5FtS$+_7DOqP{%8?mS01L!(GPB%D?M1HHEYLx|Bf1c!zqf^Y$NqYsx>?!ENQ=p%o zA-1D1fj{a|4CU;?)8NN6#DOD#IGzN11yT?3*JIJMzf$RWGko@>o|iCZnpSY`zaz4}_=8ruHihnjQ zS)Cq=gO+|AZIO3{r_Be4I6OW))~dVYAXi*kQ(aO~HBo!FHF-R9g5<=@Zg04`coEx> zkq8*l=wIfKz+M;;K>FHf3wyRDkqz=(IB8^^R!UDI8ULhxy88Nmd;W=&Xd@~VIc(GB zm3+TQZPgy76BSxy9z0Bx9&6cSikx^E=acYY>sj&~4SH^jkf%5{$u@6R)K2P!Cem3d zX5t3N!qT|C`R*bQR@$bN+}m+@Dw=Q~;ht*eR06l_bPR#Zw8s-8Wr8O_F(x-5t}T+s z)8b$4n+h-7tQ;Cf^FT29wi~RtE*oHs67+i^q3C?Tfxm9{By5KOvhr=$b9+|r1OSkc-a44;uXSBGgc-VP)=L8?y9AE&*}+hlD=J%TOL{nu>IVPeuEa~4umSb+X;eeU+^t2tf zUCg5SbcljwJ~pPlH+cK37-PiCdCkeW4W(-*w;W26Z+Y0rnx*nA-nA!>UDtb4rOp2% zGCamI*aVkJ7$rnrn#r8oULq*o=0q$4W8NDQ+xI7p0dp7Q!w4`TGDmQ zv&P-qI_{O;x^dB`#y=M~t$$A$MnIsXES)?}dfHRBlTMm)XP%?|i=_J0qfGYmvRSks zcOBP*>UmOPl)O|VZ|K4m%FLD2=NJHrnA058N_+j@9ndB)rkEP|1Ubew+~S{ighv~vAx1i!^pP$K@>ATB>ehQ zgwvpN;`l~>-b@VMqld_LsZ!9SA)kbnJ}pOuiUeGykb>I$vW2Cso{ za6)$2qucYJO3IlZ9KWk?wk?Lu{v(>7%S##&G*~w7{kDnmLXPsClN_x|?I}-}Vm5l;fa>0=@)e&k+#KrQKt7uSn%S7 zcBe~mS)nD?Hq5KRohR$y;Wo^`ME>H8YH?SR8?U!`w#=`u!|HV7jQAtH$Bpt$+g3Y0 zbv_q}@XtcNb{%)Gc|BT8#%Dwejg6iq7@>!U+St*qMT@Di$cUC3dwZXRaU^m)-5LAv z#yrq7?MQeU-w|o+hazJN+S9|;wg`tO*)ALgN_*b578)*1$YVUUphIrI%!2mR z6R?73PZ@m_!fFkk-tww~s+5QutIrHiC>Y#QS*F&NM}|mEDXR#dkU3iAG5Bk;m_2s zM0X^)YxPJKdA+B6q;#+xH-t^zns|BPbW_-%J%z)OG+nPvA-4EmI8}VAj^=%lAbzUu zFIeeG-u_iQ+{`3JlDE^d4qcX!rW~98u?gb4;XiK14!;*I^qBDy=>N3wFW0xGWxumL z3WxXG?46l_KUs=M?h>vX*FYF`BxX@++hd`4F( z_$Bk4R!sT?qWKUsKTy^V#wQWb@WF$J6_eRR37@|~^Wsb|eaSp~nR=wjyfMvCMx{98 zlL}}URpRg3$vijmCZ^HM-BtKy@SHWV;8tAY!!crP#91t$CW&U;C9^-T(7umr>WC$) zpW!UDJwPIbo@BSAe^*+uQF!~G5G(Qr0TzDm88g;n0!ev10VL^t1LzWtaTKT%C_|B#=A}%VhK5VZ zcOj6ZatV+~Y1W~40MQIi_>KaJlr2D#;{_5ai0Ye`+fr?dHRaxdmSi``QFid zM}Z{AU1(QCUNTTV^HJwXNj-6y~E%fP{~{G$rrXX}&vw3YhO+&G!J1 z)RHZl?-3vxCr(!1)qGC?iM&3bAsqTFkXY~=plM8d1xPG-UGx1-qhV;2B*ytb(>cZ{ zAc=7~kVr1ld}Tn?Jwdyn`4($F^2n4Jn}NhW^1hT5eFsSL{%1g)kdmQ(2{eo49R&Iu z(>?%_Hf9iJ9nIm;vw`m8(DQ++nC8(m^1htQv>BRK2UN|p#hTU(M03HD6?tEZyxW21 zGp$?G?gpx1+WngLFi2plg}-A<%V< zj_c5~@DRA3X~TfT(h)$5nC8*6%Yha%&8yK2pe0Nz)_ik->X}xfY0H6VJ}mqkHEk`> zQl@=YqX&U}O#7AZaIuq4G)S`9OXS zy;##m12r>kERe*V03>mXf#eRI10?n8Iv|l(544=)HUddp^6Qki?LbmHJAoudH&6@5 z*a##s?go+=_W?mOnU_Aaz^BVDw2N)B$E4p#&YOWK$4;ZKwCh|P_F=q zjyHhDG2gpDqT?74iXG)K1~>F(jzPYt5@Q;WSXBWeF~}=btRk;ev8n+`thxb6tXc&m zR^19DR&4+htF{1%jz@s5U<|MEb(-%Bn(w=sZyQi9^X<@l&uPAQG~ZFp=RyZb>^l$0un)+v59l*u zpXRI8d_K+B3{=Q`H)_5On(t8{xfi|-RK$GW1Co2;381y0Whn9|oynp7KvD`n2P$UT zGeAt(l#Km zv;#;iT@56b-VP*|-UTF~Di@N(AAkjfyq@_$FFH+G#UZkR950J$8 z1rRC};{F;);=TY>#=-F{qRzW_efb*;f~>Wk&4``CU^J+~ipciWFl`voxN zrTu8JUjY9J38Az=e-Z@^rxOk{eFsbc&jX?d@S}S&2{o6FSbL&OrIYZ-rjL4PbeLj) zCYPk2NmQ5U;KIS*Y`(JiW3LNN5gyBLmcOZggAw1}{ z&b^F|;QU!el!72P2g&rDp= z-DOeey=tU`(u^yQgF^L>?rDi-pD9dsCAnN=8jgh*y=+ud6?& zWc9q0lIK;wi=pJIgHFnn0^T~-rX35*z2@X8n4)OR%g$3^+nkiV5wo)LREwPllmfNJ zNy*Mq564iv>d_d=6!o~1;w@kgCapa;YjT$QwUcLZfjZ=*C#3*BdJalLH;}wLn%rQbqpn6t&gEhQ4cvOxGx@$p=7JAF%+-b8$-!ghhiuN z>WGtq?WF%4L&;Go$&TD8$WtB%#hZopIfjz2Cd5z*RJoIad$1*jlCSQGp`etVl$>1k zyBJEo@(i+D=*1S#A31rj#dDLB2hW1_F_c_IYn!1m;FhL#)tft6JsLwnjf$a6QO|3N z-Io^Gh^HQTz68(~PMh#3bx4ilF5~Y&W%>ht!wk}t9~czehWt!b>feFHI+OCOBbMC* z7s-eAYP4TtG>-{h2B7DlrTtAaNNfMtL1~EhYJ|^8yno^_q_iD6Ey)*yve`kI0m?HD z3hktqj$~S~ZUKebLyK}RDEBxhkATwWpzH?apo8+Cpiq`sa^3;OL81HI;-PhrI}HkaSK)5scjPl&>;n(ol@yD35^cb3 zZGmmppTmfC5cN=EksPP*DpAfx-cSe8;<*HrgM&>A6Z=Pxr&z`TB{;6u6jS?kpi~br z*gcb2k$v*+*po8aEpln8`){^sIpd4{fTqvt7 zjGG4TOE{Hpd4{f=93(ZTv&4ape%JzZlPG3(u=DG^24wk3*pXS`OX50 zzXkbCvPZ03b`;6x-|)(0CrrMS9jJxDqLMt>qucP!GB4raX$XUZCH9cEOkm$e_#(hj z0ZM6SOYc#jNb;_DgzyEWxEuH z4uA!x*ipQsR8%A?KN4dr0@DZ9k(Q!WKKNFc4z&^_nZTA;8~$$+U~|Kz^zw#%i9$>t z);NvY&(2gN#aQfH=7+0x3+h~)_p@-!@wau*hI+!lRZ06?YY$~pD5ZP8cm-k$*oF>& zVH)TwC8c7kX$B?5PAP|Llbz3A zJB41td+~+HPstQQV(0j%G7Cj~j#!(W3>PF@2%8!!MTp|U#9msWb52L#7SsHeI2{S| zRug&K_#v(SP`fX*@)P(SEz+b=hW5wu=(nLfHuI6nvZ zo&^5M?VxYH0%7BY?*jZulnxr|pnY}i$N$!D@wPhfY5kbnum%Gq32SZy+Lq%Zaf^?> z6siFBux$!PmbD^uMw7p>)fe({#Y5N(|LVZ9K**pr`htqeZemAcD9|2Op=J1l#}&?F zxZ#nzGB(T&`==6lOveyKdxTz&IJ7^gh=I#;(1VKohn0SK=+OWcEw1448NojC6%HF7 zZyYS)D_${N>exWI$FXA<&B%b~UWdX$5n)J1$M(HYz&DX;ESD@2|3vb)!``A372UyP zsWt)^9gV@Z7JnlY;iv(ac|ihkWFm;bWTc;nawM8bx`B{>nr(rnOnqrIzU+b1zlww;W)X$Pip2;eU#1 zK{;#Gi`HPho_3K5xM901RKd2*x?_XGkG!$Fyl=rD4JPZQd;I) z)`-f3Nh@#|g)6aL2D$Fy)(PM>E|DaB7<;cNz>nqo5z9Su#o9eXGE8ESCoHlPV5Au?DT3fGHTYweqdNGDTzf4%R z&AR1%ZGTK*u?}=CL_9<%ndF*7W4S7deJOb7+q#AHR;|YGoa@-iHu^4YW@~It%OdP@ zQoccPFa>qw0teaJg@b$wcjF}v2TzSP_qTOS5Uw$&(7L@Z!BwjJ`{0(1QPR4<2`sZ> z=e7I=nDy8;dg6)e;RSJ6%dOQZ$x8{B63E= z9-WaZIAxA(Ot3*_Dx4HggRyQ!7AJ0F*#vkUOz#N0r?*8$Mpt>FyX_8_g>`1mr$8>1 z3EPMK7-0sut+F)A(Mk;XF$LLeCrtN*2TdOwris}y*V-&-<1br9k;DOtFOhyN0(htJbVv+M@f*W ztA1nuqJBw?VgI#h>vw`-`s%dx)PAIG>+99Ce0U6MfF>UNTL?? z1D|cfgKhXM8y;lCsW$u>8y;)JqiuMxi4!G;Gh$;WnT3i}4}-if3BUJf^my8~9tw%e z=mJODi#k#$y@#?6r%m?(bqwq}lz%v>>(Ig-ueyuMlAafVT^|ov^KX*5YcEJ-3mL!} zOZk8L#}FJYIwd#;B%oo%r!@D!PDnwAD%r)B#t8)m3p30!`$$r7@a7O;JpiPnv~rGum_^i z#EMZ1xLM5DkjCN)*{GknAYMETZkt8>jiqgq`@zz}+>ybZ{5WffjFPIb!F{!eDPuX) z-oJggh*|T~-R`SZLyxz92{#Li#DArQ(!nP~a?0+KNyo9~T7A#>C1j|PpIvW_W4Z8d zgD3k64;|c#lCUI-cDV+#>oSQcl=Twt<9Ve&OQ;ZvxzmuV=06f6JpwDPTXnLm$Yr2lxL=7ly^9DMI)Qj#a=Xn zpvk?#)xWXYLk<3hbZLfJgOt|T@F?QJaP!bSJAXvBjSY`Dv0$UeK+?^^MPAHvX26IO-!BQ$fBA}lE&VA-TS|}Xy8b9< zKuV8fz;#mUBDk)1D;e7P;Z<}$j*lcu>WmtH1+`xrh{3E~l*{L`iFU>{FIculK}{Q;>DU2mnJ3Hf9>GGRrtEk{yc_!Cs6 zzI-9>|NfT?Jt)7_mq)NtqS&$?ewolU5(_|Z@~OQVg7zwGYp>+a`z$4`g-&J`83|{# z9Ka{Og!VY3ADhxg7s-ZKQ=!4RCWQ18Q? zfz>9RN=<#w!$}KiJoXPfZCh$qjgCJzUq6Th;*|_w=1=3V zfV*XQ^jFcnD%VgijeU(c<>P)pEg#fE745Kx@43Xq&m62!5{ODjt0N;mwiVU8a`TZSoaaD zv8oR((Jn2DW<9((fp(f;CEB?u@>C1^;j0W@yG)vTB{HQzY1d>^`fwD*mBpo<(^Ojb zn0L4j70diB4{mjI)1Rhm{Ai_|C?- z0eP{g)4jW|WGiSe=W~d~#u;|G>+$5WcY^;e`I1MRpDEP;PPaGh=h5^66|09EJJSf- zf8A*YF2~U}>Pd)daEwO)0Fo44s`+w(@F57lVoj?6x`b&}K-Y5IWjb^@ zki=*M600IWVhgqGVnMg&BcEfj`Ky{nb2EkSF(8S%184;6{Uy*+*84l4aZGy!2%n;$ z`*olO4*hSSE15>kVm;IT0z_Vf8EPP^2Yt9oW{(2;Je91{K$Ez`fv7o3=3Qwd?q#4! z-0?t*S;~Bkd_a=k8-SK^C^b1kTMHzmwF3y_(xCqw=o;2RGk`=d?F`$$*XgKB=5v{bQ@x1DB6*>nb8k`rm_^;n^y9G z_NJ9QcosCjA#Cg@P|gvNhJAx~(L zR}0k4QmzA{=TEYtoomI?Mj)}2=62rBp0ZCl)f9~WM zPXkGN@FLJsro9d%Qpgi}7HG+eJfTI(`#>UP0FqtKq2~Zej0=D&m^KnfVvGWk7!!eJ zbEp?cTHpd8X@M(%IuV+od_YhGy~}};8HIrGA6Iwk&|XdZJdl+17NE5(rC;;y(|peZ ziKQ4%YBe9D1$rVJt&Ju%m$IasuT?W*}F{S}YdJBQ*+i$We1(Nj629osN2qf}o zpIni*9!OI3pbq_-ru_?$q>}c;l~lg0`CbJQDdev#Qph*iuo*~b=L1b)t40Ee%~t}6 z&69u%I5ZdN8b$>`VzUoO0*Q{RfI3;;bwH8_ejt&&0%#1!4FZYeFpx;T1?aOJ z_p?AEJ@R64?{zKmP@TZ&k z`hkS+w?M*2-ohws@LiQI{+1bP7SP=s<2s-yqb49Jts8)PnRXM-LCmw0Fv7Dd!QSb@2IAI1eDBDhU10sON=fB`XZxjpoxs81APG~L(K$| zTw4q@i9?s`(3L=vS9bwrap>oC=z~C#L*D_)=FlJO&^zO?&n4u`(3LyrP&1T90I zcaB;5BY?cjM|;jn>1P5->E{AH$e~k!?q@U|=mAEBK=&~!0s1_na-h#KY67~QQ5XoB zgj{+IXcJI|dIIQDracMt5Yv7R)X9kUjfJs@LHof3T1I|dqn{f^>+KMyPj6tdo=T=6~;Cu_CgE&)d8N|Cl z(z6tIFf3fhC>`hyMjjx#pTy^y?hf&}rdkU75PC18r9fY1gcBcy|AYR{q|j~r2ur0v zMQ5r-84dVXy2OF~2Se86Ulb#}pUOByslHj?IbuNkq4tRm=3zunTYA!4lxke1J19$W zMYY@F3F2y`gR%}+bjMgc)B;j3S}1luZc1O0E73e=@i6}g;mm`-Nxc7c56B2?yEF5CX&hPExVwAuOt>xa^T-bPa-?T%lTuY zVBgX#Cr{3lm>p4b;B!~&IEIqPt*lM*1#|ux`CMP8~U#)gh z;9I@PNkJ+$$51A#A2=yf;HBuKz%TfigOUpmaT@Wn?8$|PIPLXlqvYhNtQbnZqVF3v z9&bMTXxk_#(^e->UbgCtp?KB9F_bAWJH6)Sd(}ZFPeHzN<5seCO@`-kdJH93jdW77 zy{bHhQlOSPDM-bAP6~Xq`(h}Q)u9+lUd#@ylTlu&xRq=cVprJ-PD(ykmC=sb#a|Tm*_o zQyT2PQOQKfA9H|LJq4vo<1U{iDW?38nWhuH2R(ZWj6dpGso`$%+U!ff{?F01C!(qyK53#Jh zaqT@B?w7deY#pWMSF^;14wfAD6=c?QjmNH%L`2Kw5%)^R=j#V{L%Yuy$*h3nYOb_&<1Dovr((7q{h zkj!K(NojFq z(fp$M4K)>WX3njg+fY2G1bgCMTQRdDhSmRM})MA{spE8yE_S5+c@ehm$@xo2Tk z%mK~Kt>H+AzsV6vT&09mV)zHz3pc^$yp~N;1;{bpwx2Hr!!-D}!XZy*n88#PlwI(| z4_U#}t^XY&q!|k+8W_^l9%=?}6UyT;yA|(N(m*4_;S4 z50B=#a%tP#Q=?D!=5C$YTjZj-a~Bq^e+l7xr#%~bHM-k-;Dc~xdi|p4PGiO~&0bAe z;C;Jb{HhYnRXZLnc1Lp`#SR{mWbP5Re2T86`DiCLG5P`W>9?iR#)o!d`ctu6^2nTX zm$F39RZc=5*i{vR4ucFuiBWob)?lr<`^o zN$M$bgVfODzLzEg@1KVfPw91MR?~E2bAA-^FERjAzSVX8^LRoaX-4`m>rN_=>5n$3 zp|@;6JvhrK%duq`w78>XsA{xjSV~WI%Hgx4v!E~qHl_5W-V>d5^6Eo#eXr{$!)fGD z_I(gU{S$N*LF>|}N2ANp0!S#0NC+y`=o*cJKs5T9p=hQLwG|n>)|%*;i?&2)A&qtd ziM+iUAsUZE(%&RwMbc4pVLPq?h6?@vIEI zJ`>;n;CQ9I{YK{y@7~mcla)2QA1KBjetYYG5=`#EAzxHx#8$5Ir4#3CLl;e!T6c&H2u0mWwGp(oW+O`&$S zA-=~GSO&-MkhK^Gam4m^szX7n{()YY+3_N#3UQQo&=NA1uI8mcOvdH@HaOTf2F-_j zb}q)V@^W(uj3+ssiF{;ZvBbPQk0*PIHy?j+$VwN>u+qgBa}|G4pj0M$#@8Ze9LEWs z@m(=|g$Y)=xE6v=XQc}oHHbYr6RdP`0Pn6e3(tNeTIr$;cjgQ<4PBQA=R2@9QQu-S z=x?Ke>gD${`NEhe9aI zyL2q3Raf|gmzc)IbC<2aq6{62?RDT&c0wlMJLL>~otlB&<|FM?mw}g|%X>q65bp14 zMkC%3uzUl^YDQ6`KM?l8?Z3tMe~LR7IIF69kMCio;o;Z}aa1hQtqz7fhdJ{Eq`_eb zR1_ISR1}Ug1B?y~%{fD)s8a(9ju>X93uM7h5k(IZPm6)X2t(bt)YgbJ( z?)U%y@4e1Gdq%_Vy|q6x=lu3>{nvjz_S$Q&z4lqZot{P(8NoNF(%$hVNzm4MQL2Nr z^r@!yv^Qkx)Ty*Nc`fzg_Ez3uPr=YO@>6ot13tjrRB&B_#@kvj77IYDqCK5&8|Pz zZ$DpN$*y~S^E-89dWt#}VE*KyCwd|y%PO0-mU}1pl9q6`Jt1F8ifx}d7`ei-NN?IF zOkRI2nonw>;!nBt=fZf!I-7}RwXRJ0i$y?**Nr21v3w~dr5b`m9UkM+2e5@@%k}MN zlgUCc)iTTX0k|Ih&-#`Z$d9a`JURnFX{dIzRD4NS>d)0X`y-R{J?cI#TVXaM%aZen zCHctenYa_W3ECUa-ExYnkDPN-hmk-1aU}^$;yM2kZ^)3NjylRW#W0b@2+l=6#rx({ z`YL!DT$;SoDm8shC5iV5iOWB+Jt?QnUGM_&v?c{eQf3ZlR=^_6{^=qCVxona^f-tX)1^mn?7BPBOGf>yHHN0))FItu#Zq z1R>FqTIOnP6J|r#d=v2#P*g_lD|B;-PdTz+c zaf)-GeVl0fkO8_p-9}cnX3v4Fsk9}IU+#GzrtX{zY=h&Qrp{G>DR8WAxZdrz%NWq121aHlwJl>#yT8MJzhc{Uw*a?*}DVCSO~-|I*PMyTpbOqlz~dC2hIj zX^}%UgT?2QUtj%F_uoq{@gI^%V}8x-kJgu(g$-fQNu7VRwxYC~q0lrcWGQq0t}6?Y zQ~ZuWQ!YbNg&D9-<1GRj9VQ@Sk%AxynT7 z?(KEm_JghH`*_1yo1$%f?TcuaI(5fn*1Yc3rGr?(cMBCmJ(e8!IiPu;cY&>@3oCJy z9yC^PGna(-lVq09Tw2vw8SF%ilq7o2UEs~rEQbdmbg7d_!CW7+Wmodf-bu{RWg6dG zws|Lcsc+dR-n=b1wQXt<4GhixIol!<8$pU%UotgDW1?8Jxc6F9XKJZjMTIkIy5{_; zr*_f*JkMg3=OpM({m|@3Ff^l;-5iR@H8^*+88N?DIv%6i-GHww~w*Rs<1$F%D! zhfX@Q^H>BZiZ6dec2CQjG%v67knT4I6kmRi5Yq-snlYewjZ_c~)_;!;Hm9}v+Fi`q zXf4bNX02=989k5fCWSs-&%DMUpl|Q918thI^j`PUl>|*Qn8W@5ZjX9B(&LX9*kGoy z2WvwGy#C%AKbJ~6f)8oq%V}wDF4>B0r$>0w7lo%sc*1{bZ)tv1S;1$o`{7b~jxMis zFXOv-?U{L8tb;vShC3+d(3I$&9)fr6hV1YY9Zibi2heR{74a-{q+Z}Z(uIdTjJ=?E z!%SZ*Wb)SHHS&Ybu;~|Q?znoZ!#l*)zdOGdSe{rxFIDbTDCB5FhBtvy4Wdb!^RPUF zoN|~QWIG?MPUR}eMS1n_tggTD0#`Qds*i#@6CbZhl$VsFq zHXazowR%MUuHwxJlOD0_jAbdfH2+pc1IGlT0qZ~XxT)W;4Kg6;?UOgjmkc^8rT=Bn z(RW0kL&oCGkM}bO`B`^cX-P@ zmr8UyBFedg6DFWX(hl=^=X7sRL{6~N9xEuNx$J*HeDv(tc!1aA&Wt>9(}XRN?Sn*! zX`o6H@HDNU)UrN#YiF%m#nfsn^j*5M@ebAl;-H(u#d+U0Xwq9np9t}+-9)pYS z5Aq0Blb)CLYwc^r>*O6Zjdp()47rQ1o(!i=IO}8wU4yrn{9byuxp+XF$$iMy%o%yv zj>g>EEvDvUZq|pD$ErWehHb0V4wE#9-UsQ4yH=N`z05&;b=+ONRv4GR8`)v3T+;Q{ zgw7!~3rdF;uaSlI+KxEkO2YfU0~_BJuQ@3i`2bsC@f!IRSl3&}hdJn>+oE${+sHSP zDkb#q!2{)&yZ>HTe1$A?*+61*kJH@CSkBXNUwM4omub;4-v?>y zE6)zbdj~V#TRGdtdYOhUyJad~b1{y!g7t{!DXsgO+B+S9L~p%hF?%etQMf|%9veD+ zNRE7-_N7^i$VEj-Ymc1on&gK1!Li~^>{GmBwRne5-nMc?v~?w;>hbCv4dIyh;X3yaQxgxp6 zE_VxyzqAD*8jaY!y=@zFC-1g}Llzla{PP1ArVmDhmxdC4;*qeU9Ask9c^m2r(2LEK zCTfnz9MiKydCZ1K%$7b-zdw@^jd0 z_)q9U8)@E!-l2ScK#`nXlNBAq=SKb$y13lzc=Q#-Jpp9gOpwJr6(kmgy7b1poXx&@ zk!L9u<5M7>4Pz(ykhBYRkZ7T=uy6j}1j(I5!W+uDHdO77cIX6$#ruz$09z7u4rZ30flD3HaFUh+~6 z6(ueUt#P5pgD%rh>1r)h79v_)`PodDhOTm<*MP2pOL*6VKBb|eiuGwlw}Z^fS3y>% z_kg-J^ghrUMKUxpyGKA)$b-ALSIy?DUi5-t$fv(Wd7eVV3{odLA+1b4g zTCbrZq;sXB0bC+2-Ge|q%E=-cSp-O{bD@(!mRcRi$~(hxCxfhp8bKp8?tGB7u=7Bc zMw7F<5F{NwjZGl)vf0@^0yPEN|2>- z3Fv5zD>6Hl#yU_?8_w=?pkvhTi!SsJAWLH($kKS#aeoC_8nXJRRO7x6WN91(vNRGP zvl|N zOL#XqyW2ox)b6X!Zj-ay?Cc%_ja9p?&h9TDE76-ED-pjz3%Ej%<@8|CIF0)Okd^YTT|jf5t=+d&p%6X;vY-S0xTfMkVAq4%h>dlF>nJ`J*Tf8j!(2i0hd z-+(OLKY%RVeISeRCdjzLSF#YY3T1<=s<4BEZu`acC{Y{vUJN`Xf?>L_VPnF3!UXcPXXE0{&W|5u?rQM zoi0uHN*5}UI@6SsTSCjhRu}qn&`=G14rJ}+CC~}V?FCs3k>0Uu{2L%U3V#RL_#pov z&-*Sh65e2tEM-o3Q$TWqhJ*%anEIRT&|J_LH1s@By@oDxp;v>ZD|fBqZUEh^F@6AQ z(9lOgGRcNCAIMtvGa$>=PLSpKk05J9BFAI7e;YJIy$mP{^EVJ=X^aPbOhZM4$Bx1z zkfkBgJ610$!?##rI(M673~rnVYnsjUH-zpI?xb)Z>l zccZhr)rEcqWcm9h$l{7@kLC1XkR9orAh}s8^xn_cClw6?{Q#8k#(=DbDnJ)$=p@J0 zgRCZJIqp=Dr6IyR7i$a==9#Q01+o$?1Fcpr1G*iQ@Gb*AqG$u?`-()E=V3*6gC0_} z9ds|K(EAn0%Jy53rMnk&vWAKXkEJHkJF}G&>77#)4Fp-}!61t(B0Q&R=y1>+MMpTh zV?aNKOL)hDEXH`yX=;}Q%~ezjGS4$WPic(VpdTqZAM~W!r9q8~R)L;Sv>x=h+T94U zy1x~4x`uukWHtVE7kV$q^71{<8EW@1$ZGtDAj`|+&hEz`OYLW%c^czcXZIVBikricsU{foL+IZ-X8LCA>#Lk16*fkey{e2U*Eq0MR)R<3B-`?$IS78V@>OLu)}+ z-l?D_l5AoJ1)YF4|mKpWL=3CO&(ffi}#$3ZDYD?#S38`PrQ)gX&; zEoiZFH#j>H7_xNl09m?sftIM zS*~P>=LO1*2U)I?pbM3&aduNdmaBS@r7;uKrgpNJ)N*wWXqj@0LFVs5&~oKgfGpjW zAoF)I$ozGI+STrIkomh7v_iRCK<4ib(8ra#3uON80hz!1K<4jzpboYBKFIt%3F2ph zw2hyG%-?gMjB+o4%-`=o=5G(EQ$t??nV0<_i(7!vN(~(hl3zX2uYt^qEY{@@?r^>= zS4V(WDOUp_<8XF&Yn<@0={LOozu60%-`K0Yjq;VWO28G&eRw?K<4==5P$gl z8DD1iENH%RyFljow;=P}3*wI$f8xt>`YPxw<^BpXy8&Fxt+#kT$UF}NouhWcL6(Cf zK<2O1*^LG*P`e2r%Rwc`JU2MI(?IuOm+%&Vc4&-6php!ogSIPL3i_dJLqXe{{cE2 zROtNz^i$>j1iDGl8=wzr=-V!I0B%2|oCq{ojA0-Q@G=3k1;lI_XtN?d^gd6%2gnDT zjNWC-voE=I%h?KZ_QZ4U7T=e#y=-}2p1PEpiEa->cfjF(xNz#~Sh(a|ws2vV^!>7h z`*M!SmhTm6k>pI1EiA`++jZe3K|u?=BI?D?QTYzzuah0NaQ`~&r8Vd4QRI5bzPMmv zmsGU20r`ei&tKt_+kG~9zT$Z=@vi~Fr!1zGqsAgB4d01>iE1~(HuT+P_&58FDP2U=NA=q@hR=cWVLQlbSs}S<{YT^uCiycTDK{Zws^au z7x}zH(aU_^rAUf!w<4*AXC)?R~)_&EHd=>;yZ4^tdAZ(WTFnfb?m@({0Q_I>^vghY8 zC$Kj*hmj0VcT8XTto{~9*;s%`L7odM;4 zF_so;OkWu;S%f9q1B>QL@z_j0%XZ|9Ky*R{wQ6(@B+At4s4T)vMEZ#s5eA7ZIc`y= zTw7a|Not#pFv)Vg+C`b9_O}rRVXnQoo)KS>HXpI6tn!MepD0rum(QxI@}}h4@QTyA zTn5pt1-T5OTZ>{$MNAs2yrwcHja6P#6_ds)udVdt9E#+y7BR6LCW-9TH*y(dLN>)1 z>L-^$ylZcasffvECCe*yp=37oB=T7^X)RHvIwp;kEU)!MGCyL2B#Asrh%ysnVp&O! z>Ekh*8t>^`MviGNQ(fu39Aj!dc`gu1i(?@tX_Tq(5;3OI^J7enC%@Cm#;Pcr=uL?+ z<=*rdQxOy9swk`U?j7YS_m~u~q{Ue?^ySK!cY89Y}+SGU=^B-ZVYdn$rk1|Nlu^VA( z%DoXWCh670mSKNcoe(UNj)8Wm$|ysAkGeVPv+Ojx%{q(mNLj>FQ;JeWC8JhGjh4;(QSZ$&b0wjm$ zTk$IQQMub5cIo@Mw-L{>G2jg5EkZ_~_;!=e?71S40gYz}w9yqLrM8D{S{;tDFSRvT$yXf>Bb(MN78ZU(>Mn9$}i zm=&5<$n1i7nkhWVA(hJ}ze2Drv>8Z%e^As$er=GoS-3dOn$)nlhq0=1Y{XiA8u)Zk z)X$KkUAK5b#c+_^!lh{jrj$tct>LtZS9qf^7+D8SH;j2WwJ zGpTx6WO_R5lTk=h!q&-#p|+4Z-5_h9WnFY2A!gEVPDD=R#^PdkB1aZe8dHffO~jh~*mKjL!?A5?%_{R*K124DPEqm`A106RUKQ~qrqzh0 zZE}N=mKZcBlc8fteM)6Mvg&><9m`smr#ixR*D&2RAJ$n1&3IZ{dy};|anna3@Ezst z8Wy)?I-Ta7w{TWH?jzQkXjo^n>Nyi5F`C=8eJ*KPW^#OycwsY)O7}VOy}8K!iIPdA z;Gx8&<~}QiX}NKABFS~MBZ(qsq?q=n_h>CWS8vi7SZf zSA-Hk{y)+Hswk_e@pTgoARa!T0rVu7r(o`;Uk#uFh6*{`J7@r9^^wh5wR6r-r=xM- zbQj1h+trV@&s}t?+hXa~iCs)L@KO9-$dy8V+#y>X|9(HZfn0^WO_XyB|FVf|$sbkm zFV_u>9JBwWWDhzYCpR?uthRS@WuOhZ=)Ng+fuFwMv{L%_0Eo9Rx{e!cIHYC6tG4!??ljyGi7d)ZtX zoDcn}gbWFFe(1tg1c-zK5snLfqkm&jqH zvPEicMeYJkoUH6apwHsZZb!(2Om>RC2r4EW?Mu+ANNK&vc|U*td}*NRDHPgH_^JNI z6WU~#tJ>5{*h$Hb3;-nLqyB1t!czYd{QG`1l2031PFEwTggK*}NYX;|RX*`4wr)<# zM!O9C$ktUm7uhA&=uk0Q)r6)8%1a2rIK7or=c;{eB99VeM>1`m-eY#&Js&HYTHBYW z+Q$2hEvhJj$i;F!g5(NSHcHY@{B|Tkf(yUYinaXZDL`AwAC=BDw|8calS&BkZgniV z@0<6ak)U9aEVVV-PzqqKYghx7P zA>(}+jA;!~FSs7tUp&13#zzT91yCppjf&<>tI};8y@?&(K*_}&V%nUZpnAOu5(&na zL%dJzm5a!2Ql0wlcIkf`dv0QtAy3wVb*;N4bg6vAP)~kjkzMjNU9ZA|p5#6jgp|}i z%yLB*Q(k=ppFIT+vDh&YmEyRPWsFlMWQI){mnmi`S@5d%-ls^Wc=PnqL%O$Y?S7-8 z_=GFTGB_*6!;Z@qL_n$t@eNJh|Y|b?bx`eUDdq$kKsnLU&enze{lVN4V~aPx!vX7mKe2;n+B56NTL3a(BjHNuS1l(n@@>f zsMAMs*(=l^G7M7mb3VDlhI@`ri(5!3W$;tzeE?)XNH`2+p|VUxF5HD)l|!;%Wtegw zb9OReB@ZhZ5jyU2(4orpIPP}PVak2gaq@6!xN`S8ZZqg`Nt6i%LujG>9}8m4PH=qTk5 za-2MvKU%p%9QQ%cG0Gk3I9X6rs+>%0nLk-ZWA!YLzwCI-2HA0wrI>OpNqFs`az(2_ zqt#0nXpEvYps|Y9fyODi3N%U)AD)bNr|~_&J5mmpE;Qi5d(*%0p?PFPFLN&WdHs#) z?SZl6P;CTgo0E<|%gB+UC;=0FxGddRexBR~$Tt1Kw{&_*A1)`WbQ&pqB+bKRm`eRw zxWIy<71WVR-DgCB{_fL*b}RjZVo%7~aTHM=7FAQXkz$nM!?78)d3J zSJ@TU z%cQz7{Z9kVz$V-EEg+V}Fh4(* +#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