diff --git a/Arquitetura do Programa.pdf b/Arquitetura do Programa.pdf deleted file mode 100644 index 8c237d8..0000000 Binary files a/Arquitetura do Programa.pdf and /dev/null differ diff --git a/DADO.H b/DADO.H deleted file mode 100644 index 5a2f0df..0000000 --- a/DADO.H +++ /dev/null @@ -1,72 +0,0 @@ -/*************************************************************************** -* -* $MCD Módulo de definição: Módulo Dado -* -* Arquivo gerado: Dado.H -* Letras identificadoras: DAD -* -* Nome da base de software: Exemplo de teste automatizado -* -* Projeto: Disciplinas INF 1628 / 1301 -* Gestor: DI/PUC-Rio -* Autores: avs - Arndt von Staa -* fvc - Felipe Vieira Côrtes -* tbm - Tássio Borges de Miranda -* db - Daniela Brazão - -* -* $HA Histórico de evolução: -* Versão Autor Data Observações -* 1.00 avs 15/08/2001 Início do desenvolvimento -* -* $ED Descrição do módulo -* Este módulo implementa um conjunto simples de funções para gerar o resultado -* do dado "lançado". -* -***************************************************************************/ - -#if defined( DADO_OWN ) - #define DADO_EXT -#else - #define DADO_EXT extern -#endif - -/*********************************************************************** -* -* $TC Tipo de dados: MAT Condicoes de retorno -* -* -***********************************************************************/ - - typedef enum { - - DAD_CondRetOK = 0 , - /* Executou correto */ - - DAD_CondRetErro = 1 , - /* Estrutura do DadoPontos está errada */ - - DAD_CondRetMatrizNaoExiste = 2 , - /* DadoPontos não existe */ - - DAD_CondRetFaltouMemoria = 3 - /* Faltou memória ao alocar dados */ - - } DAD_tpCondRet ; - -/*********************************************************************** -* -* $FC Função: DAD &Gerar o numero de casas a serem paladas -* -* $ED Descrição da função -* Retorno o numero da casas a serem andadas -* $FV Valor retonado -* DAD_CondRetOK -* DAD_CondRetFaltouMemoria -***********************************************************************/ - -DAD_tpCondRet DAD_NumPular(int *NumeroCasas) ; - -#undef DADO_EXT - -/*************** Fim do módulo de definição: Módulo Dado ****************/ diff --git a/DADO.c b/DADO.c deleted file mode 100644 index 18832fc..0000000 --- a/DADO.c +++ /dev/null @@ -1,86 +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 - -#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/DADOPONTOS.c b/DADOPONTOS.c deleted file mode 100644 index 14006e1..0000000 --- a/DADOPONTOS.c +++ /dev/null @@ -1,127 +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 "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*/ - 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 ; -/* - typedef struct tgPlayers { - int id; - } tpPlayers; - /*Struct Temporaria*/ - -/***** 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 * DadoCriado) -{ - struct tgDadoPontos * DadoNovo; - DadoNovo = (tpDadoPontos*)malloc(sizeof(tpDadoPontos)); - if(DadoNovo = NULL) - return DADPnt_CondRetFaltouMemoria; - DadoNovo->valor = 2; - /*Valor Inicial do Dado de Pontos*/ - DadoNovo->CorDoJogador = NULL; - /*Quando o dado é criado, todos os jogadores podem usa-lo o inicio*/ - (*DadoCriado) = DadoNovo; - return DADPnt_CondRetOK; -} -/*************************************************************************** -* -* Função: DADPnt Dobrar Dado de Pontos -* ****/ - -DADPnt_tpCondRet DADPtn_DobrarDado(tppDadoPontos DadoDobrar) -{ - DadoDobrar->valor = DadoDobrar->valor * 2; - /*Pega o valor atual do dado e multiplica por 2*/ - return DADPnt_CondRetOK; -} -/*************************************************************************** -* -* Função: DADPnt Mudar "Dono" do Dado de Pontos -* ****/ - -DADPnt_tpCondRet DADPtn_MudDono(tppDadoPontos DadoDono, char * cor) -{ - DadoDono->CorDoJogador = cor; - /*Troca o jogador que pode realizar a dobra*/ - return DADPnt_CondRetOK; -} - -/*************************************************************************** -* -* Função: DADPnt Gerar Valor da Partida -* ****/ - -DADPnt_tpCondRet DADPtn_ValorPartida(tppDadoPontos Dado, int * valorjogo) -{ - if(Dado->CorDoJogador == NULL) - *valorjogo = 1; - else - *valorjogo = Dado->valor; - return DADPnt_CondRetOK; -} - -/*************************************************************************** -* -* Função: DADPnt Destruir Dado de Pontos -* ****/ - -DADPnt_tpCondRet DADPtn_DestruirDado(tppDadoPontos Dado) -{ - Dado->CorDoJogador = NULL; - Dado->valor = 0; - free(Dado); - return DADPnt_CondRetOK; -} -/*********** Fim do módulo de implementação: Módulo DadoPontos **************/ diff --git a/DADOPONTOS.h b/DADOPONTOS.h deleted file mode 100644 index 3bdd603..0000000 --- a/DADOPONTOS.h +++ /dev/null @@ -1,131 +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 -* -* $ED Descrição da função -* Dobra o valor da partida -* $FV Valor retonado -* DADPnt_CondRetOK -* DADPnt_CondRetFaltouMemoria -* -***********************************************************************/ - -DADPnt_tpCondRet DADPtn_DobrarDado(tppDadoPontos DadoDobrar); - -/*************************************************************************** -* -* $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 DadoDono, char * cor); - -/*************************************************************************** -* -* $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 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/Dado/Source Dado/DADO.H b/Dado/Source Dado/DADO.H index 5a2f0df..019e64d 100644 --- a/Dado/Source Dado/DADO.H +++ b/Dado/Source Dado/DADO.H @@ -9,15 +9,13 @@ * * Projeto: Disciplinas INF 1628 / 1301 * Gestor: DI/PUC-Rio -* Autores: avs - Arndt von Staa -* fvc - Felipe Vieira Côrtes +* Autores: fvc - Felipe Vieira Côrtes * tbm - Tássio Borges de Miranda * db - Daniela Brazão - * * $HA Histórico de evolução: * Versão Autor Data Observações -* 1.00 avs 15/08/2001 Início do desenvolvimento +* 1.00 fvc 15/08/2001 Início e término do desenvolvimento * * $ED Descrição do módulo * Este módulo implementa um conjunto simples de funções para gerar o resultado @@ -33,7 +31,7 @@ /*********************************************************************** * -* $TC Tipo de dados: MAT Condicoes de retorno +* $TC Tipo de dados: DAD Condicoes de retorno * * ***********************************************************************/ @@ -56,7 +54,7 @@ /*********************************************************************** * -* $FC Função: DAD &Gerar o numero de casas a serem paladas +* $FC Função: DAD &Gerar o numero de casas a serem puladas * * $ED Descrição da função * Retorno o numero da casas a serem andadas diff --git a/Dado/Source Dado/DADO.c b/Dado/Source Dado/DADO.c index 18832fc..5b7a67e 100644 --- a/Dado/Source Dado/DADO.c +++ b/Dado/Source Dado/DADO.c @@ -9,14 +9,14 @@ * * Projeto: Disciplinas INF 1628 / 1301 * Gestor: DI/PUC-Rio -* Autores: avs - Arndt von Staa -* fvc - Felipe Vieira Côrtes +* Autores: fvc - Felipe Vieira Côrtes * tbm - Tássio Borges de Miranda * db - Daniela Brazão * * $HA Histórico de evolução: -* Versão Autor Data Observações -* 1.0 tbm 02/set/2015 Início do desenvolvimento +* Versão Autor Data Observações +* 1.0 tbm, fvc 02/set/2015 Início do desenvolvimento + * ***************************************************************************/ @@ -36,39 +36,37 @@ * ****/ -/* Funcao do Modulo */ -int dadorand(void); +/***** Código das funções encapsuladas no módulo *****/ + +int randint(int n); + +/***** Código das funções exportadas pelo módulo *****/ -/* fim funcao do modulo */ +/*************************************************************************** +* +* Função: DAD &Gera numero aleatório +* ****/ DAD_tpCondRet DAD_NumPular(int *NumeroCasas) { *NumeroCasas = randint(6); return DAD_CondRetOK; -}/*Fim da função DAD_NumPular */ -/* Função usada pelo módulo */ +}/*Fim da função DAD_NumPular */ -/* Returns an integer in the range [1, n]. - * - * Uses rand(), and so is affected-by/affects the same seed. - */ +/* Função usada pelo módulo */ +/* Returns an integer in the range [1, n]*/ 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)); diff --git a/Dado/Source Dado/TESTDADO.c b/Dado/Source Dado/TESTDADO.c index f74a38b..316f85d 100644 --- a/Dado/Source Dado/TESTDADO.c +++ b/Dado/Source Dado/TESTDADO.c @@ -1,53 +1,29 @@ /*************************************************************************** * $MCI Módulo de implementação: Módulo de teste específico - -* Módulo modificado para operar matrizes que armazenam listas! * -* Arquivo gerado: TESTMAT.C -* Letras identificadoras: TMAT +* Arquivo gerado: TESTDADO.C +* Letras identificadoras: TDADO * * 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 +* Autores: fvc - Felipe Vieira Cortes * tbm - Tássio Borges de Miranda * db - Daniela Brazão * * $HA Histórico de evolução: * Versão Autor Data Observações - 4.00 fvc 23/08/2015 Módulo modificado para operar matrizes -* 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 + 1.00 fvc 14/09/2015 Início e término do deselvolvimento * * $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. +* módulo Dados, que gera um número aleatório de 1 a 6 * * $EIU Interface com o usuário pessoa * Comandos de teste específicos para testar o módulo Matriz: * -* =criarmatriz - Chama a função MAT_CriarMatriz( linha, coluna, vtMatriz[inxmat]) -* =criarlista - Chama a função MAT_CriarLista( lista ) -* =avancar - Chama a função MAT_Avancar(vtMatriz[inxmat], direcao ) -* e avança a célula corrente da matriz de acordo com a direção dada. - as direções são: norte, nordeste, leste, sudeste, sul, sudoeste, oeste e noroeste -* =inscharantes" - Chama a função MAT_InserirCharAntes( lista ) e insere o char na posição posterior ao corrente -* =inschardepois" - Chama a função MAT_InserirCharDepois( lista ) e insere o char na posição anterior ao corrente -* "=inslista" - chama a função MAT_InserirLista(vtMatriz[inxmat], linha, coluna ) - e insere a lista na posição linhaXcoluna da matriz -* "=excluirelem" - Chama a função MAT_ExcluirElemento( lista ) e exclui o elemento corrente da lista -* "=irinicio" - chama a função MAT_IrInicio( lista ) -* "=irfinal" - chama a função MAT_IrIFinal( lista ) -* "=obtervalorelem" - Chama a função MAT_ObterValor( lista, charRecebido ) - e compara o charRecebido com o valor -* "=avancarelem" - chama a função MAT_AvancarElementoCorrente( lista, numElem ) -* -* "=destruirmatriz" - Chama a função MAT_DestruirMatriz( vtMatriz[inxmat] ) +* =jogardado chama a função DAD_tpCondRet DAD_NumPular(int* NumPular) e retorna um valor inteiro de 1 a 6 e imprime na tela ***************************************************************************/ #include @@ -64,14 +40,13 @@ /* Tabela dos nomes dos comandos de teste específicos */ #define JOGAR_DADO_CMD "=jogardado" -#define INI_DADO_CMD "=inicializardado" /***** Código das funções exportadas pelo módulo *****/ /*********************************************************************** * -* $FC Função: TMAT Efetuar operações de teste específicas para Matrizes +* $FC Função: TDADO Efetuar operações de teste específicas para um dado de 6 faces * * $ED Descrição da função * Efetua os diversos comandos de teste específicos para o módulo @@ -99,7 +74,7 @@ int NumLidos = -1 ; int i = 0; int valorDado; - /* Testar MAT Criar Matriz */ + /* Testar DADO Jogar Dado */ if ( strcmp( ComandoTeste , JOGAR_DADO_CMD ) == 0 ) { @@ -109,17 +84,14 @@ return TST_CondRetParm ; } /* if */ - while( i < 60) { CondRetObtido = DAD_NumPular(&valorDado) ; printf(" \n dado: %d\n", valorDado); - i++; - } return TST_CondRetOK; - } /* fim ativa: Testar MAT Criar Matriz */ + } /* fim ativa: Testar DADO Jogar Dado */ return TST_CondRetNaoConhec ; - } /* Fim função: TMAT Efetuar operações de teste específicas para árvore */ \ No newline at end of file + } /* Fim função: TDADO Efetuar operações de teste específicas para um dado de 6 faces*/ \ No newline at end of file diff --git a/Dado/TRAB2-2.exe b/Dado/TRAB2-2.exe deleted file mode 100644 index af8fdf2..0000000 Binary files a/Dado/TRAB2-2.exe and /dev/null differ diff --git a/Dado/TRAB2-4.exe b/Dado/TRAB2-4.exe new file mode 100644 index 0000000..f15d295 Binary files /dev/null and b/Dado/TRAB2-4.exe differ diff --git a/Dado/logtestedado.txt b/Dado/logtestedado.txt index 7be1abb..fbfbf49 100644 --- a/Dado/logtestedado.txt +++ b/Dado/logtestedado.txt @@ -4,7 +4,7 @@ LES - Laborat Arcabouço de teste de módulos C (c) 2006 --------------------------------------------- - Construto sob teste: TRAB2-2 + Construto sob teste: TRAB2-4 Arquivo de teste: testedadoscript @@ -16,21 +16,21 @@ LES - Laborat dado: 1 - dado: 6 + dado: 2 - dado: 6 + dado: 2 dado: 4 dado: 1 - dado: 6 + dado: 4 dado: 3 dado: 6 - dado: 6 + dado: 4 !!! Número de linhas lidas: 14 diff --git a/Dado/testedado.bat b/Dado/testedado.bat index caf2525..3f53677 100644 --- a/Dado/testedado.bat +++ b/Dado/testedado.bat @@ -1 +1 @@ -TRAB2-2 /stestedadoscript > logtestedado.txt \ No newline at end of file +TRAB2-4 /stestedadoscript > logtestedado.txt \ No newline at end of file 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/ArcaboucoTeste.lib b/DadoPontos/Source dadopontos/ArcaboucoTeste.lib similarity index 100% rename from ArcaboucoTeste.lib rename to DadoPontos/Source dadopontos/ArcaboucoTeste.lib diff --git a/DadoPonto/DADOPONTOS.c b/DadoPontos/Source dadopontos/DADOPONTOS.c similarity index 84% rename from DadoPonto/DADOPONTOS.c rename to DadoPontos/Source dadopontos/DADOPONTOS.c index a19cd12..a51b103 100644 --- a/DadoPonto/DADOPONTOS.c +++ b/DadoPontos/Source dadopontos/DADOPONTOS.c @@ -2,14 +2,14 @@ * $MCI Módulo de implementação: Gerador de numeroes aleatorios restrito ao * numero de faces * -* Arquivo gerado: DADO.c -* Letras identificadoras: DAD +* Arquivo gerado: DADOPONTOS.c +* 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 +* Autores: * fvc - Felipe Vieira Côrtes * tbm - Tássio Borges de Miranda * db - Daniela Brazão @@ -24,6 +24,7 @@ #include #include #include +#include "GENERICO.H" #define DADO_OWN #include "DADOPONTOS.h" @@ -57,7 +58,7 @@ * Função: DADPnt Criar Dado de Pontos * ****/ -DADPnt_tpCondRet DADPtn_CriarDado(tppDadoPontos * DadoPontoCriado) +DADPnt_tpCondRet DADPnt_CriarDado(tppDadoPontos * DadoPontoCriado) { *DadoPontoCriado = (tpDadoPontos*)malloc(sizeof(tpDadoPontos)); @@ -77,11 +78,13 @@ DADPnt_tpCondRet DADPtn_CriarDado(tppDadoPontos * DadoPontoCriado) * Função: DADPnt Dobrar Dado de Pontos e Mudar "Dono" do Dado de Pontos * ****/ -DADPnt_tpCondRet DADPtn_DobrarDado(tppDadoPontos DadoDobrar, char CorNovoDono) +DADPnt_tpCondRet DADPnt_DobrarDado(tppDadoPontos DadoDobrar, char CorNovoDono) { + if(CorNovoDono == DadoDobrar->CorDoJogador) + return DADPnt_CondRetErro; DadoDobrar->valor = DadoDobrar->valor * 2; - DadoDobrar->CorDoJogador = CorNovoDono; /*Pega o valor atual do dado e multiplica por 2*/ + DadoDobrar->CorDoJogador = CorNovoDono; return DADPnt_CondRetOK; } @@ -90,7 +93,7 @@ DADPnt_tpCondRet DADPtn_DobrarDado(tppDadoPontos DadoDobrar, char CorNovoDono) * Função: DADPnt Gerar Valor da Partida * ****/ -DADPnt_tpCondRet DADPtn_ValorPartida(tppDadoPontos DadoAtual, int * valorjogo) +DADPnt_tpCondRet DADPnt_ValorPartida(tppDadoPontos DadoAtual, int * valorjogo) { if(DadoAtual->CorDoJogador == 's' ) *valorjogo = 2; @@ -110,7 +113,7 @@ DADPnt_tpCondRet DADPtn_ValorPartida(tppDadoPontos DadoAtual, int * valorjogo) * ***********************************************************************/ -DADPnt_tpCondRet DADPtn_ObterDono(tppDadoPontos DadoPonto, char * CorDonoAtual) +DADPnt_tpCondRet DADPnt_ObterDono(tppDadoPontos DadoPonto, char * CorDonoAtual) { *CorDonoAtual = DadoPonto->CorDoJogador; return DADPnt_CondRetOK; @@ -121,8 +124,10 @@ DADPnt_tpCondRet DADPtn_ObterDono(tppDadoPontos DadoPonto, char * CorDonoAtual) * Função: DADPnt Destruir Dado de Pontos * ****/ -DADPnt_tpCondRet DADPtn_DestruirDado(tppDadoPontos Dado) +DADPnt_tpCondRet DADPnt_DestruirDado(tppDadoPontos Dado) { + if(Dado == NULL) + return DADPnt_CondRetDadoPontosNaoExiste; free(Dado); return DADPnt_CondRetOK; } diff --git a/DadoPonto/DADOPONTOS.h b/DadoPontos/Source dadopontos/DADOPONTOS.h similarity index 87% rename from DadoPonto/DADOPONTOS.h rename to DadoPontos/Source dadopontos/DADOPONTOS.h index b73dd7a..decba33 100644 --- a/DadoPonto/DADOPONTOS.h +++ b/DadoPontos/Source dadopontos/DADOPONTOS.h @@ -9,8 +9,7 @@ * * Projeto: Disciplinas INF 1628 / 1301 * Gestor: DI/PUC-Rio -* Autores: avs - Arndt von Staa -* fvc - Felipe Vieira Côrtes +* Autores: fvc - Felipe Vieira Côrtes * tbm - Tássio Borges de Miranda * db - Daniela Brazão @@ -31,11 +30,13 @@ #define DADOPONTOS_EXT extern #endif +#include "Generico.h" + typedef struct tgDadoPontos * tppDadoPontos; typedef struct tgPlayers * tppPlayers; /*********************************************************************** * -* $TC Tipo de dados: MAT Condicoes de retorno +* $TC Tipo de dados: DADPnt Condicoes de retorno * * ***********************************************************************/ @@ -48,7 +49,7 @@ typedef struct tgPlayers * tppPlayers; DADPnt_CondRetErro = 1 , /* Estrutura do DadoPontos está errada */ - DADPnt_CondRetMatrizNaoExiste = 2 , + DADPnt_CondRetDadoPontosNaoExiste = 2 , /* DadoPontos não existe */ DADPnt_CondRetFaltouMemoria = 3 @@ -69,7 +70,7 @@ typedef struct tgPlayers * tppPlayers; * ***********************************************************************/ -DADPnt_tpCondRet DADPtn_CriarDado(tppDadoPontos * DadoCriado); +DADPnt_tpCondRet DADPnt_CriarDado(tppDadoPontos * DadoCriado); /*************************************************************************** * @@ -83,7 +84,7 @@ DADPnt_tpCondRet DADPtn_CriarDado(tppDadoPontos * DadoCriado); * ***********************************************************************/ -DADPnt_tpCondRet DADPtn_DobrarDado(tppDadoPontos DadoDobrar, char CorNovoDono); +DADPnt_tpCondRet DADPnt_DobrarDado(tppDadoPontos DadoDobrar, char CorNovoDono); /*************************************************************************** * @@ -96,7 +97,7 @@ DADPnt_tpCondRet DADPtn_DobrarDado(tppDadoPontos DadoDobrar, char CorNovoDono); * ***********************************************************************/ -DADPnt_tpCondRet DADPtn_ValorPartida(tppDadoPontos Dado, int * valorjogo); +DADPnt_tpCondRet DADPnt_ValorPartida(tppDadoPontos Dado, int * valorjogo); /*************************************************************************** * @@ -109,7 +110,7 @@ DADPnt_tpCondRet DADPtn_ValorPartida(tppDadoPontos Dado, int * valorjogo); * ***********************************************************************/ -DADPnt_tpCondRet DADPtn_ObterDono(tppDadoPontos Dado, char * corRecebida); +DADPnt_tpCondRet DADPnt_ObterDono(tppDadoPontos Dado, char * corRecebida); /*************************************************************************** * @@ -123,7 +124,7 @@ DADPnt_tpCondRet DADPtn_ObterDono(tppDadoPontos Dado, char * corRecebida); * ***********************************************************************/ -DADPnt_tpCondRet DADPtn_DestruirDado(tppDadoPontos Dado); +DADPnt_tpCondRet DADPnt_DestruirDado(tppDadoPontos Dado); #undef DADOPONTOS_EXT diff --git a/DadoPontos/Source dadopontos/GENERICO.H b/DadoPontos/Source dadopontos/GENERICO.H new file mode 100644 index 0000000..dcf7430 --- /dev/null +++ b/DadoPontos/Source dadopontos/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/LERPARM.H b/DadoPontos/Source dadopontos/LERPARM.H similarity index 100% rename from LERPARM.H rename to DadoPontos/Source dadopontos/LERPARM.H diff --git a/DadoPonto/TESTDADOPONTOS.c b/DadoPontos/Source dadopontos/TESTDADOPONTOS.c similarity index 62% rename from DadoPonto/TESTDADOPONTOS.c rename to DadoPontos/Source dadopontos/TESTDADOPONTOS.c index e7b289b..138d65e 100644 --- a/DadoPonto/TESTDADOPONTOS.c +++ b/DadoPontos/Source dadopontos/TESTDADOPONTOS.c @@ -4,17 +4,17 @@ * Módulo modificado para operar matrizes que armazenam listas! * * Arquivo gerado: TESTDADOPONTOS.C -* Letras identificadoras: TPec +* Letras identificadoras: TDADPnt * * Nome da base de software: Exemplo de teste automatizado * * Projeto: Disciplinas INF 1628 / 1301 * Gestor: DI/PUC-Rio -* Autores: avs - Arndt von Staa +* Autores: fvc - Felipe Vieira Cortes * tbm - Tássio Borges de Miranda * db - Daniela Brazão -* + * $HA Histórico de evolução: * Versão Autor Data Observações 4.00 tbm 23/08/2015 Módulo modificado para operar dadospontos @@ -31,9 +31,11 @@ * $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); +* =criardadoponto - Chama a função DADPnt_tpCondRet DADPnt_CriarDado(tppDadoPontos * DadoCriado); +* =destruirdadoponto - Chama a função DADPnt_tpCondRet DADPnt_DestruirDado(tppDadoPontos Dado); +* =obtervalorjogo - Chama a função DADPnt_tpCondRet DADPnt_ValorPartida(tppDadoPontos Dado, int * valorjogo); +* =dobrardado - Chama a função DADPnt_tpCondRet DADPnt_DobrarDado(tppDadoPontos DadoDobrar, char CorNovoDono); +* =obterdono - B Chama a função DADPnt_tpCondRet DADPnt_ObterDono(tppDadoPontos Dado, char * corRecebida); ***************************************************************************/ #include @@ -55,16 +57,16 @@ #define OBTER_DONO_CMD "=obterdono" -tppDadoPontos P[MAX]; +tppDadoPontos DadoPnt; /***** Código das funções exportadas pelo módulo *****/ /*********************************************************************** * -* $FC Função: TPec Efetuar operações de teste específicas para o Modulo Peca +* $FC Função: TDADPnt Efetuar operações de teste específicas para o Modulo DadoPontos * * $ED Descrição da função * Efetua os diversos comandos de teste específicos para o módulo -* Peca sendo testado. +* DadoPontos sendo testado. * * $EP Parâmetros * $P ComandoTeste - String contendo o comando @@ -90,43 +92,41 @@ tppDadoPontos P[MAX]; int i = 0; int ValorPontos,valoresperado; char corRecebida; - int inxpec; TST_tpCondRet Ret; - /* Testar Pec Criar Dado Pontos */ + /* Testar TDADPnt &Criar Dado Pontos */ if ( strcmp( ComandoTeste , CRIAR_DADOPONTOS_CMD ) == 0 ) { - NumLidos = LER_LerParametros( "ici" , - &inxpec,&corEsperada, &CondRetEsperada ) ; - if ( NumLidos != 3 ) + NumLidos = LER_LerParametros( "i" , + &CondRetEsperada ) ; + if ( NumLidos != 1) { return TST_CondRetParm ; } /* if */ - if(inxpec > 5 || inxpec < 0) return TST_CondRetErro; - CondRetObtido = DADPtn_CriarDado(&P[inxpec]); + CondRetObtido = DADPnt_CriarDado(&DadoPnt); return TST_CompararInt( CondRetEsperada , CondRetObtido , - "Retorno errado ao criar a peca." ); + "Retorno errado ao criar ao criar dadopontos." ); } /* fim ativa: Testar Criar Dado Pontos */ - /* Testar Pec Destruir DadoPontos */ + /* Testar TDADPnt &Destruir DadoPontos */ else if ( strcmp( ComandoTeste , DESTRUIR_DADOPONTOS_CMD ) == 0 ) { - NumLidos = LER_LerParametros( "ii" , - &inxpec, &CondRetEsperada ) ; - if ( NumLidos != 2 ) + NumLidos = LER_LerParametros( "i" , + &CondRetEsperada ) ; + if ( NumLidos != 1 ) { return TST_CondRetParm ; } /* if */ - CondRetObtido = DADPtn_DestruirDado(P[inxpec]) ; + CondRetObtido = DADPnt_DestruirDado(DadoPnt) ; return TST_CompararInt( CondRetEsperada , CondRetObtido , "Retorno errado ao destruir o dadopontos." ); @@ -134,17 +134,17 @@ tppDadoPontos P[MAX]; } /* fim ativa: Testar DadoPontos Destruir*/ - /* Testar Obter Dono do DadoPonto */ + /* Testar TDADPnt &Obter Dono do DadoPonto */ else if ( strcmp( ComandoTeste , OBTER_DONO_CMD ) == 0 ) { - NumLidos = LER_LerParametros( "ici" , - &inxpec, &corEsperada ,&CondRetEsperada ) ; - if ( NumLidos != 3 ) + NumLidos = LER_LerParametros( "ci" , + &corEsperada ,&CondRetEsperada ) ; + if ( NumLidos != 2 ) { return TST_CondRetParm ; } /* if */ - CondRetObtido = DADPtn_ObterDono(P[inxpec],&corRecebida) ; + CondRetObtido = DADPnt_ObterDono(DadoPnt,&corRecebida) ; Ret = TST_CompararChar( corRecebida , corEsperada , "Cor do jogador errado, diferente do esperado" ) ; @@ -154,54 +154,55 @@ 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 */ + /* Testar TDADPnt &Dadoponto DobrarDado */ else if ( strcmp( ComandoTeste , DOBRAR_DADO_CMD ) == 0 ) { - NumLidos = LER_LerParametros( "ici" , - &inxpec,&corEsperada, &CondRetEsperada ) ; - if ( NumLidos != 3 ) + NumLidos = LER_LerParametros( "ci" , + &corEsperada, &CondRetEsperada ) ; + if ( NumLidos != 2 ) { return TST_CondRetParm ; } /* if */ - if(inxpec > 5 || inxpec < 0) return TST_CondRetErro; - CondRetObtido = DADPtn_DobrarDado(P[inxpec],corEsperada); + CondRetObtido = DADPnt_DobrarDado(DadoPnt, 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 TDADPnt &Dadoponto Obter Valor */ else if ( strcmp( ComandoTeste , OBTER_VALORPARTIDA_CMD ) == 0 ) { - NumLidos = LER_LerParametros( "iii" , - &inxpec,&valoresperado, &CondRetEsperada ) ; - if ( NumLidos != 3 ) + NumLidos = LER_LerParametros( "ii" , + &valoresperado, &CondRetEsperada ) ; + if ( NumLidos != 2 ) { return TST_CondRetParm ; } /* if */ - if(inxpec > 5 || inxpec < 0) return TST_CondRetErro; - CondRetObtido = DADPtn_ValorPartida(P[inxpec],&ValorPontos); + CondRetObtido = DADPnt_ValorPartida(DadoPnt,&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 ; - } /* Fim função: TPec Efetuar operações de teste específicas para DadoPonto */ \ No newline at end of file + } /* Fim função: TDADPnt Efetuar operações de teste específicas para DadoPonto */ \ No newline at end of file diff --git a/TST_ESPC.H b/DadoPontos/Source dadopontos/TST_ESPC.H similarity index 100% rename from TST_ESPC.H rename to DadoPontos/Source dadopontos/TST_ESPC.H diff --git a/DadoPontos/TRAB2-3.exe b/DadoPontos/TRAB2-3.exe new file mode 100644 index 0000000..9f9cfc1 Binary files /dev/null and b/DadoPontos/TRAB2-3.exe differ diff --git a/DadoPontos/TesteDadoPontos.bat b/DadoPontos/TesteDadoPontos.bat new file mode 100644 index 0000000..88972cf --- /dev/null +++ b/DadoPontos/TesteDadoPontos.bat @@ -0,0 +1 @@ +TRAB2-3 /sTesteDadoPontos > logTesteDadoPontos.txt \ No newline at end of file diff --git a/DadoPontos/TesteDadoPontos.script b/DadoPontos/TesteDadoPontos.script new file mode 100644 index 0000000..659e949 --- /dev/null +++ b/DadoPontos/TesteDadoPontos.script @@ -0,0 +1,51 @@ +// SCRIPT DE TESTE PARA O MODULO DADOSPnt + +== Criar DadoPontos + +=criardadopontos 0 + +== Obter Dono +=obterdono 's' 0 + +== Obter Valor +=obtervalorpartida 2 0 + +== Dobrar Dado +=dobrardado 'b' 0 + +== Obter Dono +=obterdono 'b' 0 + +== Obter Valor +=obtervalorpartida 4 0 + +== Dobrar Dado +=dobrardado 'p' 0 + +== Dobrar Dado +=dobrardado 'b' 0 + +== Dobrar Dado +=dobrardado 'p' 0 + +== Obter Valor +=obtervalorpartida 32 0 + +== Dobrar Dado Errado (Nao eh dono do dado) +=dobrardado 'p' 1 + +== Dobrar Dado +=dobrardado 'b' 0 + +== Obter Dono +=obterdono 'b' 0 + +== Obter Valor Errado +=obtervalorpartida 63 0 +=recuperar + +== Obter Valor +=obtervalorpartida 64 0 + +== Destruir DadoPontos +=destruirdadoponto 0 \ No newline at end of file diff --git a/DadoPontos/logTesteDadoPontos.txt b/DadoPontos/logTesteDadoPontos.txt new file mode 100644 index 0000000..1c9a88e --- /dev/null +++ b/DadoPontos/logTesteDadoPontos.txt @@ -0,0 +1,40 @@ + + +LES - Laboratório de Engenharia de Software DI/PUC-Rio + Arcabouço de teste de módulos C (c) 2006 + +--------------------------------------------- + Construto sob teste: TRAB2-3 + + Arquivo de teste: TesteDadoPontos + + +!!! 0 Linha: 1 // SCRIPT DE TESTE PARA O MODULO DADOSPnt + 3 == Criar DadoPontos + 7 == Obter Dono + 10 == Obter Valor + 13 == Dobrar Dado + 16 == Obter Dono + 19 == Obter Valor + 22 == Dobrar Dado + 25 == Dobrar Dado + 28 == Dobrar Dado + 31 == Obter Valor + 34 == Dobrar Dado Errado (Nao eh dono do dado) + 37 == Dobrar Dado + 40 == Obter Dono + 43 == Obter Valor Errado +>>> 1 Linha: 44 Valor da Partida Errado Deveria ser: 63 É: 64 +<<< 0 Linha: 45 Falha esperada foi recuperada. + 47 == Obter Valor + 50 == Destruir DadoPontos + +!!! Número de linhas lidas: 51 +!!! Número de casos de teste: 16 +!!! Número comandos corretos: 15 +!!! Número de falhas encontradas: 0 + +!!! Não foram encontrados problemas + + +!!! Numero de espacos ainda alocados: 0 \ No newline at end of file diff --git a/GERAALT.C b/GERAALT.C deleted file mode 100644 index 869519a..0000000 --- a/GERAALT.C +++ /dev/null @@ -1,123 +0,0 @@ -/*************************************************************************** -* $MCI Módulo de implementação: ALT Gerador de números aleatórios -* -* Arquivo gerado: GERAALT.c -* Letras identificadoras: ALT -* -* 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 -* -***************************************************************************/ - -#include -#include - -#define GERAALT_OWN -#include "GERAALT.h" -#undef GERAALT_OWN - -/***** Código das funções exportadas pelo módulo *****/ - -/*************************************************************************** -* -* Função: ALT &Inicializar o gerador de números aleatórios -* ****/ - - void ALT_Inicializar( unsigned int Base ) - { - - if ( Base == 0 ) - { - srand( 3141592653 ) ; - } else if ( Base == 1 ) - { - srand( 3141592653 | ( unsigned int ) time( NULL )) ; - } else - { - srand( Base ) ; - } /* if */ - - } /* Fim função: ALT &Inicializar o gerador de números aleatórios */ - -/*************************************************************************** -* -* Função: ALT &Gerar inteiro em uniformemente distribuído -* ****/ - - int ALT_GerarDistUniforme( int Inf , int Sup ) - { - - double x ; - int i ; - do - { - x = rand( ) ; /* converte para flutuante */ - x /= RAND_MAX ; /* 0.0000 <= x <= 1.0000 */ - } while ( x == 1.0 ); /* evitar valor == 1 */ - - #pragma warning(disable:4244) - i = ( Sup - Inf + 1 ) * x ; /* converte/trunca de volta para inteiro */ - #pragma warning(default:4244) - return Inf + i ; - - } /* Fim função: ALT &Gerar inteiro em uniformemente distribuído */ - -/*************************************************************************** -* -* Função: ALT &Gerar distribuição dada por tabela de freqüências -* ****/ - - int ALT_GerarFrequencia( int numElem , int * vetElem , int Limite ) - { - - int i , - j ; - - i = ALT_GerarDistUniforme( 0 , Limite ) ; - for( j = 0 ; j < numElem ; j++ ) - { - if ( i <= vetElem[ j ] ) - { - return j ; - } /* if */ - } /* for */ - return numElem ; - - } /* Fim função: ALT &Gerar distribuição dada por tabela de freqüências */ - -/*************************************************************************** -* -* Função: ALT &Gerar permutação randômica uniformemente distribuída -* ****/ - - void ALT_GerarPermutacao( int tamVetor , - int * Vetor ) - { - - int Temp , - inx , - i ; - - for( i = tamVetor - 1 ; i >= 1 ; i-- ) - { - inx = ALT_GerarDistUniforme( 0 , i ) ; - Temp = Vetor[ inx ] ; - Vetor[ inx ] = Vetor[ i ] ; - Vetor[ i ] = Temp ; - } /* for */ - - } /* Fim função: ALT &Gerar permutação randômica uniformemente distribuída */ - -/********** Fim do módulo de implementação: ALT Gerador de números aleatórios **********/ - diff --git a/GERAALT.H b/GERAALT.H deleted file mode 100644 index dac322d..0000000 --- a/GERAALT.H +++ /dev/null @@ -1,169 +0,0 @@ -#if ! defined( GERAALT_ ) -#define GERAALT_ -/*************************************************************************** -* -* $MCD Módulo de definição: ALT Gerador de números aleatórios -* -* Arquivo gerado: GERAALT.h -* Letras identificadoras: ALT -* -* 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 -* Implementa um pequeno conjunto de geradores de números aleatórios. -* -* $EIM Interface com outros módulos -* Antes de gerar qualquer número deve ser chamada a função -* ALT_Inicializar. -* -***************************************************************************/ - -#if defined( GERAALT_OWN ) - #define GERAALT_EXT -#else - #define GERAALT_EXT extern -#endif - - -/*********************************************************************** -* -* $FC Função: ALT &Inicializar o gerador de números aleatórios -* -* $ED Descrição da função -* Inicializa o gerador de números aleatórios. -* Esta função deve ser chamada antes de qualquer outra do módulo GERAALT -* -* $EP Parâmetros -* Base - se == 0 utiliza a semente normal (PI 3141592653 ) -* isto gerará a mesma seqüência de números aleatórios -* a seguir da inicialização. Esta semente é tida como -* uma boa semente, a distribuição é virtualmente uniforme -* e a cardinalidade é a maior possível. -* se == 1 utiliza a PI | time( ) -* isto gera uma seqüência de números aleatórios -* diferente a cada inicialização -* outros - utiliza o valor fornecido como semente -* deve ser tomado cuidado pois uma semente mal escolhida -* pode levar à geração de uma seqüência não aleatória, -* ou de cardinalidade limitada. -* -* $ER Requisitos -* Esta função deve ser chamada uma única vez e isso antes de gerar -* o primeiro número aleatório -* -***********************************************************************/ - - void ALT_Inicializar( unsigned int Base ) ; - - -/*********************************************************************** -* -* $FC Função: ALT &Gerar inteiro em uniformemente distribuído -* -* $ED Descrição da função -* Gerar um número inteiro uniformemente distribuído em um -* intervalo dado -* -* $EP Parâmetros -* $P Inf - limite inferior, inclusive -* $P Sup - limite superior, inclusive -* -* $FV Valor retornado -* Inf <= x <= Sup -* -* $EAE Assertivas de entradas esperadas -* Inf <= Sup -* Dados errados provocarão um comportamento errático no programa. -* -***********************************************************************/ - - int ALT_GerarDistUniforme( int Inf , int Sup ) ; - - -/*********************************************************************** -* -* $FC Função: ALT &Gerar distribuição dada por tabela de freqüências -* -* $ED Descrição da função -* Gerar distribuição segundo tabela de freqüências -* -* $EP Parâmetros -* $P numElem - número de elementos (intervalos) da tabela -* o número de intervalos é na realidade igual a numElem + 1 -* $P vetElem - vetor de elementos da tabela -* Os valores dos elementos são números entre 0 e Limite - 1 -* Os elementos devem estar em ordem crescente. -* Os elementos correspondem a uma função cumulativa -* Exemplo, se forem desejados as freqüências -* 10% 30% e 60% -* devem ser fornecidos os dados 2 {10 , 40} 100 -* $P Limite - é o limite superior da distribuição de freqüências -* Permite chegar a freqüências muito pequenas, por exemplo -* para uma distribuição de freqüências 9999/10000 e -* 1/10000 forneça os parâmetros -* 1 9999 10000 -* -* $FV Valor retornado -* O índice da freqüência 0 <= indice <= numElem, com uma probabilidade -* igual ao correspondente intervalo. -* -* A probabilidade x é dada por -* x = ( vetElem[ i ] - vetElem[ i - 1 ] ) / Limite -* para todos i , 0 <= i <= numElem -* sendo que vetElem[ -1 ] é assumido igual a 0 -* sendo que vetElem[ numElem ] é assumido igual a Limite -* -* $EAE Assertivas de entradas esperadas -* numElem >= 1 -* vetElem[ numElem - 1 ] < Limite -* para todos i, 0 <= i < numElem : vetElem[ i - 1 ] < vetElem[ i ] -* sendo que vetElem[ -1 ] é considerado igual a 0 -* Dados errados provocarão um comportamento errático no programa. -* -***********************************************************************/ - - int ALT_GerarFrequencia( int numElem , int * vetElem , int Limite ) ; - - -/*********************************************************************** -* -* $FC Função: ALT &Gerar permutação randômica uniformemente distribuída -* -* $ED Descrição da função -* Gera uma permutação de n elementos uniformemente distribuída. -* O algoritmo utilizado é o "Knuth shuffle" descrito na Wikipedia. -* -* $EP Parâmetros -* $P tamVetor - número de elementos a serem embaralhados -* $P Vetor - elementos a serem embaralhados. O vetor deve conter -* pelo menos tamVetor elementos. Caso não contenha, os -* resultados serão impreditíveis, possivelmente -* desastrosos. -* O vetor deve estar inicializado com os elementos a -* serem permutados. Por exemplo, no caso de um baralho, -* o vetor deve ser inicializado com a seqüência de -* índices das cartas (0 a 51). -* -***********************************************************************/ - - void ALT_GerarPermutacao( int tamVetor , - int * Vetor ) ; - -#undef GERAALT_EXT - -/********** Fim do módulo de definição: ALT Gerador de números aleatórios **********/ - -#else -#endif diff --git a/INF1301_Escopo do Trabalho.pdf b/INF1301_Escopo do Trabalho.pdf new file mode 100644 index 0000000..9cd7e3d Binary files /dev/null and b/INF1301_Escopo do Trabalho.pdf differ diff --git a/LEIA-ME.txt b/LEIA-ME.txt new file mode 100644 index 0000000..fa8c9f5 --- /dev/null +++ b/LEIA-ME.txt @@ -0,0 +1,46 @@ +INF1301 - Trabalho 2 + +Esta pasta contém: - Os relatórios de cada integrante do grupo. + - O pdf INF1301_Escopo do Trabalho que possui a Especificação de Requisitos, + Arquitetura do Programa, Modelo Estrutural da aplicação com exemplo, e assertivas de entrada e saída. + +Pasta Tabuleiro : Contém um script de teste para o módulo de tabuleiro de gamão +sem as regras implementadas, um executável gerado a partir do conteúdo da pasta source, +um arquivo .bat que executa o teste gerando um log de saída. + -TRAB2-1.exe + -testetabuleiroscript.script + -testetabuleiro.bat + -logsaidatabuleiro.txt +Pasta source tabuleiro : Contém os arquivos fonte usados para a geração do executável listado anteriormente + +Pasta peca : Contém um script de teste para o módulo de peça que representa peças do jogo de gamão, + um executável gerado a partir do conteúdo da pasta source peca, um arquivo .bat que executa o teste + gerando um log de saída. + -TAB2-2.exe + -testepecascript.script + -testepeca.bat + -logtestepeca.txt +Pasta source peca : Contém os arquivos fonte usados para a geração do executável listado anteriormente + +Pasta DadoPontos : Contém um script de teste para o módulo de dado pontos, que representa o dado + de dobrar os pontos com as faces 2, 4, 8, 16, 32, 64 do jogo de gamão, um arquivo executável gerado +a partir do conteúdo da pasta source dadopontos e um arquivo .bat que realiza o teste gerando um log de saída. + -TAB2-3.exe + -testeDadoPontos.script + -testeDadoPontos.bat + -logtesteDadosPonto.txt +Pasta source dadopontos : Contém os arquivos fonte usados para a geração do executável lista anteriormente + +Pasta Dado: Contém um script de teste para o módulo de dado que simula um dado de 6 faces sendo jogado, +um arquivo executável gerado pelo conteúdo da pasta source dado, um arquivo .bat que executa todo o teste +gerando um log de saída. + -TRAB2-4.exe + -testeadodoscript.script + -testedado.bat + -logtestedado.txt +Pasta Source Dado : Contém todos os arquivos necessários para a geração do executável dito anteriormente + +----------------------- COMO USAR ----------------------------------- +Para testar cada módulo basta clicar duas vezes no arquivo em lotes (.bat) referente ao módulo. +Será gerado um log contendo as informações do teste realizado. + diff --git "a/Pe\303\247a/TRAB2-2.exe" "b/Pe\303\247a/TRAB2-2.exe" new file mode 100644 index 0000000..2fc9b09 Binary files /dev/null and "b/Pe\303\247a/TRAB2-2.exe" differ diff --git a/peca/logtestepeca.txt "b/Pe\303\247a/logtestepeca.txt" similarity index 91% rename from peca/logtestepeca.txt rename to "Pe\303\247a/logtestepeca.txt" index 7f41f51..fcbd99c 100644 --- a/peca/logtestepeca.txt +++ "b/Pe\303\247a/logtestepeca.txt" @@ -4,7 +4,7 @@ LES - Laborat Arcabouço de teste de módulos C (c) 2006 --------------------------------------------- - Construto sob teste: TRAB2-3 + Construto sob teste: TRAB2-2 Arquivo de teste: testepecascript @@ -19,7 +19,7 @@ LES - Laborat 15 == Testar obter a cor da peca 1 (branca) 18 == Destruir as duas pecas -!!! Número de linhas lidas: 21 +!!! Número de linhas lidas: 20 !!! Número de casos de teste: 5 !!! Número comandos corretos: 6 !!! Número de falhas encontradas: 0 diff --git a/peca/peca source/ArcaboucoTeste.lib "b/Pe\303\247a/source peca/ArcaboucoTeste.lib" similarity index 100% rename from peca/peca source/ArcaboucoTeste.lib rename to "Pe\303\247a/source peca/ArcaboucoTeste.lib" diff --git a/GENERICO.H "b/Pe\303\247a/source peca/GENERICO.H" similarity index 100% rename from GENERICO.H rename to "Pe\303\247a/source peca/GENERICO.H" diff --git a/peca/peca source/LERPARM.H "b/Pe\303\247a/source peca/LERPARM.H" similarity index 100% rename from peca/peca source/LERPARM.H rename to "Pe\303\247a/source peca/LERPARM.H" diff --git a/PECA.C "b/Pe\303\247a/source peca/PECA.C" similarity index 86% rename from PECA.C rename to "Pe\303\247a/source peca/PECA.C" index 696d6a6..bf24f92 100644 --- a/PECA.C +++ "b/Pe\303\247a/source peca/PECA.C" @@ -8,8 +8,7 @@ * * Projeto: Disciplinas INF 1628 / 1301 * Gestor: DI/PUC-Rio -* Autores: avs - Arndt von Staa -* fvc - Felipe Vieira Côrtes +* Autores: fvc - Felipe Vieira Côrtes * tbm - Tássio Borges de Miranda * db - Daniela Brazão * @@ -37,17 +36,13 @@ ***********************************************************************/ 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 *****/ +// vazio /***** Código das funções exportadas pelo módulo *****/ @@ -75,6 +70,8 @@ Pec_tpCondRet Pec_CriarPeca(tppPeca * PecCriado, char CorDaNovaPeca) Pec_tpCondRet Pec_DestruirPeca(tppPeca Peca) { + + free(Peca); return Pec_CondRetOK; } diff --git a/peca/peca source/PECA.h "b/Pe\303\247a/source peca/PECA.h" similarity index 93% rename from peca/peca source/PECA.h rename to "Pe\303\247a/source peca/PECA.h" index a63d488..2458e5e 100644 --- a/peca/peca source/PECA.h +++ "b/Pe\303\247a/source peca/PECA.h" @@ -9,8 +9,7 @@ * * Projeto: Disciplinas INF 1628 / 1301 * Gestor: DI/PUC-Rio -* Autores: avs - Arndt von Staa -* fvc - Felipe Vieira Côrtes +* Autores: fvc - Felipe Vieira Côrtes * tbm - Tássio Borges de Miranda * db - Daniela Brazão @@ -58,7 +57,7 @@ typedef struct tgPeca * tppPeca; /*********************************************************************** * -* $FC Função: DADPnt Criar Peça +* $FC Função: PEC Criar Peça * * $ED Descrição da função * Cria uma nova peça @@ -72,7 +71,7 @@ typedef struct tgPeca * tppPeca; /*********************************************************************** * -* $FC Função: DADPnt Destruir Peça +* $FC Função: PEC Destruir Peça * * $ED Descrição da função * Destroi uma peça @@ -86,7 +85,7 @@ typedef struct tgPeca * tppPeca; /*********************************************************************** * -* $FC Função: DADPnt Obter Cor +* $FC Função: PEC Obter Cor * * $ED Descrição da função * Obtem cor de uma peca diff --git a/peca/peca source/TESTPECA.C "b/Pe\303\247a/source peca/TESTPECA.C" similarity index 96% rename from peca/peca source/TESTPECA.C rename to "Pe\303\247a/source peca/TESTPECA.C" index 199f11b..26cd1af 100644 --- a/peca/peca source/TESTPECA.C +++ "b/Pe\303\247a/source peca/TESTPECA.C" @@ -10,8 +10,7 @@ * * Projeto: Disciplinas INF 1628 / 1301 * Gestor: DI/PUC-Rio -* Autores: avs - Arndt von Staa - fvc - Felipe Vieira Cortes +* Autores: fvc - Felipe Vieira Cortes * tbm - Tássio Borges de Miranda * db - Daniela Brazão * @@ -25,8 +24,7 @@ * * $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. +* módulo Peca. * * $EIU Interface com o usuário pessoa * Comandos de teste específicos para testar o módulo Matriz: diff --git a/peca/peca source/TST_ESPC.H "b/Pe\303\247a/source peca/TST_ESPC.H" similarity index 100% rename from peca/peca source/TST_ESPC.H rename to "Pe\303\247a/source peca/TST_ESPC.H" diff --git "a/Pe\303\247a/testepeca.bat" "b/Pe\303\247a/testepeca.bat" new file mode 100644 index 0000000..9b73628 --- /dev/null +++ "b/Pe\303\247a/testepeca.bat" @@ -0,0 +1 @@ +TRAB2-2 /stestepecascript > logtestepeca.txt \ No newline at end of file diff --git a/peca/testepecascript.script "b/Pe\303\247a/testepecascript.script" similarity index 67% rename from peca/testepecascript.script rename to "Pe\303\247a/testepecascript.script" index 13cf1f9..8b40864 100644 --- a/peca/testepecascript.script +++ "b/Pe\303\247a/testepecascript.script" @@ -1,45 +1,20 @@ // TESTE DO MODULO PECA // TESTE COMPLETO - -== Testar criar 3 pecas - +== Testar criar 2 pecas =criarpeca 0 'p' 0 - =criarpeca 1 'b' 0 -=criarpeca 2 'b' 0 - - == Testar obter a cor da peca 0 (preta) - =obtercorpeca 0 'p' 0 - - == Testar obter a cor da peca 1 errada (branca) - =obtercorpeca 1 'p' 0 - =recuperar - - == Testar obter a cor da peca 1 (branca) - =obtercorpeca 1 'b' 0 - - - -== Testar obter cor da peca 2 (branca) -=obtercorpeca 2 'b' 0 - == Destruir as duas pecas - -=destruirpeca 2 0 - =destruirpeca 1 0 - - -=destruitpeca 0 0 \ No newline at end of file +=destruirpeca 0 0 diff --git a/README.txt b/README.txt deleted file mode 100644 index e69de29..0000000 diff --git a/RELATORIO-Daniela.txt b/RELATORIO-Daniela.txt new file mode 100644 index 0000000..bfb7800 --- /dev/null +++ b/RELATORIO-Daniela.txt @@ -0,0 +1,8 @@ +Data Horas Trabalhadas Tipo de Tarefa Descrição da Tarefa Realizada +14/09 2 Especificar Módulos, Especificar Funções Finalização do entendimento do enunciado do segundo trabalho, início da projeção do segundo trabalho, desenho do modelo estrutural do programa e definição da sua arquitetura. +15/09 3 Codificar Módulo Início da codificação dos módulos DADO e DADOPONTOS. +16/09 2 Revisar Código do Módulo, Projetar Revisar o código do módulo DADOPONTOS e início da projeção do módulo PECA. +21/09 2 Codificar Módulo Codificação do módulo PECA. +23/09 3 Especificar Módulos Escrever as especificações dos requisitos funcionais, não funcionais e das restrições. +25/09 1 Revisar Script de Teste, Diagnosticar e corrigir os problemas encontrados Teste do funcionamento dos módulos DADO, DADOPONTOS, PECA e TABULEIRO. +28/09 2 Revisar Especificações de Requisitos Revisar o pdf de especificações de requisitos. diff --git a/RELATORIO-Felipe.txt b/RELATORIO-Felipe.txt new file mode 100644 index 0000000..3c08bbb --- /dev/null +++ b/RELATORIO-Felipe.txt @@ -0,0 +1,8 @@ +Data Horas Trabalhadas Tipo Tarefa Descrição da Tarefa Realizada + +14/09 2h Especificar os módulos/ especificar as funções Desenhando o modelo estrutural do programa e definindo sua melhor arquitetura +16/09 2h Projetar/espicicar as funções Definido como serão as estruturas dos Módulos Peça e Dado Pontos e suas funções de acesso +21/09 2h Codificar/Revisar especificações Campos da peça retirados sobrando somente a cor dela, codificando teste para o módulo de dados, criando uma função que gera números aleatórios +23/09 2h Redigir Scripts de teste/revisar código do módulo Códigos alterados para criar scripts de teste mais fáceis de usar +24/09 3h codificar/Redigir script de teste/realizar testes/revisar script de teste Teste Dado Pontos, Teste de peça, teste de dado e teste de tabuleiro funcionando sem erros. Realizando as mudanças adequadas em cada módulo +25/09 3h Redigir script de teste/ revisar codigo do módulo/revisar script de teste Todos os módulos testados, acrescentando alguns comandos a mais para um teste mais completo. \ No newline at end of file diff --git a/RELATORIO-Tassio.txt b/RELATORIO-Tassio.txt new file mode 100644 index 0000000..e79a152 --- /dev/null +++ b/RELATORIO-Tassio.txt @@ -0,0 +1,9 @@ +Data Horas Trabalhadas Tipo Tarefa Descrição da Tarefa Realizada + +14/09 3h Especificar os módulos/ especificar as funções Desenhando o modelo estrutural do programa e definindo sua arquitetura +15/09 3h Codificar Módulo Codifigar o modulo dado e dadopontos, modulos que náo são dependentes +16/09 2h Projetar/especificar as funções/Revisar Codigo Módulo Definido como serão as estruturas dos Módulos Peça, suas funções de acesso e a revisão do módulo Dado Pontos. +21/09 2h Codificar Módulo/Revisar especificações Modulo Peca codificado. tendo na estrutura apenas a cor, codificando teste para o módulo de dados, criando uma função que gera números aleatórios +23/09 2h Redigir Scripts de teste/revisar código do módulo Revisado as funçoes testes nos modulos dadopontos e peças, codificando modulo tabuleiro e o seu teste. +25/09 1h codificar/Redigir script de teste/realizar testes/revisar script de teste Teste Dado Pontos, Teste de peça, teste de dado e teste de tabuleiro funcionando sem erros. +26/09 1h Revisar Especificações Revisão dos modelos, das arquiteturas. Criação do exemplo de modelo. \ No newline at end of file diff --git a/TESTDADO.c b/TESTDADO.c deleted file mode 100644 index 73689be..0000000 --- a/TESTDADO.c +++ /dev/null @@ -1,122 +0,0 @@ -/*************************************************************************** -* $MCI Módulo de implementação: Módulo de teste específico - -* Módulo modificado para operar matrizes que armazenam listas! -* -* Arquivo gerado: TESTMAT.C -* Letras identificadoras: TMAT -* -* 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 fvc 23/08/2015 Módulo modificado para operar matrizes -* 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: -* -* =criarmatriz - Chama a função MAT_CriarMatriz( linha, coluna, vtMatriz[inxmat]) -* =criarlista - Chama a função MAT_CriarLista( lista ) -* =avancar - Chama a função MAT_Avancar(vtMatriz[inxmat], direcao ) -* e avança a célula corrente da matriz de acordo com a direção dada. - as direções são: norte, nordeste, leste, sudeste, sul, sudoeste, oeste e noroeste -* =inscharantes" - Chama a função MAT_InserirCharAntes( lista ) e insere o char na posição posterior ao corrente -* =inschardepois" - Chama a função MAT_InserirCharDepois( lista ) e insere o char na posição anterior ao corrente -* "=inslista" - chama a função MAT_InserirLista(vtMatriz[inxmat], linha, coluna ) - e insere a lista na posição linhaXcoluna da matriz -* "=excluirelem" - Chama a função MAT_ExcluirElemento( lista ) e exclui o elemento corrente da lista -* "=irinicio" - chama a função MAT_IrInicio( lista ) -* "=irfinal" - chama a função MAT_IrIFinal( lista ) -* "=obtervalorelem" - Chama a função MAT_ObterValor( lista, charRecebido ) - e compara o charRecebido com o valor -* "=avancarelem" - chama a função MAT_AvancarElementoCorrente( lista, numElem ) -* -* "=destruirmatriz" - Chama a função MAT_DestruirMatriz( vtMatriz[inxmat] ) -***************************************************************************/ - -#include -#include -#include - -#include "TST_ESPC.H" - -#include "generico.h" -#include "lerparm.h" -#include "DADO.H" - - -/* Tabela dos nomes dos comandos de teste específicos */ - -#define JOGAR_DADO_CMD "=jogardado" -#define INI_DADO_CMD "=inicializardado" - -/***** Código das funções exportadas pelo módulo *****/ - - -/*********************************************************************** -* -* $FC Função: TMAT Efetuar operações de teste específicas para Matrizes -* -* $ED Descrição da função -* Efetua os diversos comandos de teste específicos para o módulo -* Matriz 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 = DAD_CondRetOK ; - int CondRetEsperada = DAD_CondRetFaltouMemoria ; - /* inicializa para qualquer coisa */ - - char ValorEsperado = '?' ; - char ValorObtido = '!' ; - char ValorDado = '\0' ; - - int NumLidos = -1 ; - int i = 0; - int valorDado; - /* Testar MAT Criar Matriz */ - - if ( strcmp( ComandoTeste , JOGAR_DADO_CMD ) == 0 ) - { - - if ( NumLidos != -1 ) - { - return TST_CondRetParm ; - } /* if */ - - CondRetObtido = DAD_NumPular(&valorDado) ; - - printf(" \n dado: %d\n", valorDado); - - return TST_CondRetOK; - - } /* fim ativa: Testar MAT Criar Matriz */ - - return TST_CondRetNaoConhec ; - - } /* Fim função: TMAT Efetuar operações de teste específicas para árvore */ \ No newline at end of file diff --git a/TESTPECA.C b/TESTPECA.C deleted file mode 100644 index 199f11b..0000000 --- a/TESTPECA.C +++ /dev/null @@ -1,158 +0,0 @@ -/*************************************************************************** -* $MCI Módulo de implementação: Módulo de teste específico - -* Módulo modificado para operar matrizes que armazenam listas! -* -* Arquivo gerado: TESTPECA.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 fvc 23/08/2015 Módulo modificado para operar matrizes -* 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: -* -* =criarpeca - Chama a função Pec_tpCondRet Pec_CriarPeca(tppPeca * PecCriado); -* =destruirpeca - Chama a função Pec_tpCondRet Pec_DestruirPeca(tppPeca Peca); -* =obtercorpeca - 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 "PECA.h" - - -/* Tabela dos nomes dos comandos de teste específicos */ -#define MAX 5 -#define CRIAR_PECA_CMD "=criarpeca" -#define DESTRUIR_PECA_CMD "=destruirpeca" -#define OBTER_COR_CMD "=obtercorpeca" - -tppPeca 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 = Pec_CondRetOK ; - int CondRetEsperada = Pec_CondRetFaltouMemoria ; - /* inicializa para qualquer coisa */ - - char ValorEsperado = '?' ; - char ValorObtido = '!' ; - char ValorDado = '\0' ; - char corEsperada = 'x'; - - int NumLidos = -1 ; - int i = 0; - char corRecebida; - int inxpec; - - TST_tpCondRet Ret; - - /* Testar Pec Criar Peca */ - if ( strcmp( ComandoTeste , CRIAR_PECA_CMD ) == 0 ) - { - - NumLidos = LER_LerParametros( "ici" , - &inxpec, &corRecebida, &CondRetEsperada ) ; - if ( NumLidos != 3 ) - { - return TST_CondRetParm ; - } /* if */ - - if(inxpec > 5 || inxpec < 0) return TST_CondRetErro; - - CondRetObtido = Pec_CriarPeca(&P[inxpec], corRecebida); - - return TST_CompararInt( CondRetEsperada , CondRetObtido , - "Retorno errado ao criar a peca." ); - - } /* fim ativa: Testar Pec Criar Peca */ - - /* Testar Pec Destruir Peca */ - else if ( strcmp( ComandoTeste , DESTRUIR_PECA_CMD ) == 0 ) - { - - NumLidos = LER_LerParametros( "ii" , - &inxpec, &CondRetEsperada ) ; - if ( NumLidos != 2 ) - { - return TST_CondRetParm ; - } /* if */ - - CondRetObtido = Pec_DestruirPeca(P[inxpec]) ; - - return TST_CompararInt( CondRetEsperada , CondRetObtido , - "Retorno errado ao destruir a peca." ); - - } /* fim ativa: Testar Pec Destruir Peca */ - - /* Testar Pec Obter cor da Peca */ - else if ( strcmp( ComandoTeste , OBTER_COR_CMD ) == 0 ) - { - - NumLidos = LER_LerParametros( "ici" , - &inxpec,&corEsperada, &CondRetEsperada ) ; - if ( NumLidos != 3 ) - { - return TST_CondRetParm ; - } /* if */ - CondRetObtido = Pec_ObterCor(P[inxpec], &corRecebida) ; - - Ret = TST_CompararChar( corRecebida , corEsperada , - "Valor do elemento errado, diferente do esperado" ) ; - - if ( Ret != TST_CondRetOK ) - { - return Ret ; - } /* if */ - - return TST_CompararChar(CondRetObtido, CondRetEsperada, "Retorno errado ao obter o valor da peca"); - - } /* fim ativa: Testar Pec Obter cor da Peca */ - return TST_CondRetNaoConhec ; - - } /* Fim função: TPec Efetuar operações de teste específicas para Peca */ \ No newline at end of file diff --git a/peca/TRAB2-3.exe b/peca/TRAB2-3.exe deleted file mode 100644 index f6c655b..0000000 Binary files a/peca/TRAB2-3.exe and /dev/null differ diff --git a/peca/testepeca.bat b/peca/testepeca.bat deleted file mode 100644 index d0daf44..0000000 --- a/peca/testepeca.bat +++ /dev/null @@ -1 +0,0 @@ -TRAB2-3 /stestepecascript > logtestepeca.txt \ No newline at end of file diff --git a/tabuleiro/TRAB2-1.exe b/tabuleiro/TRAB2-1.exe new file mode 100644 index 0000000..7044a43 Binary files /dev/null and b/tabuleiro/TRAB2-1.exe differ diff --git a/tabuleiro/logsaidatabuleiro.txt b/tabuleiro/logsaidatabuleiro.txt new file mode 100644 index 0000000..8011105 --- /dev/null +++ b/tabuleiro/logsaidatabuleiro.txt @@ -0,0 +1,29 @@ + + +LES - Laboratório de Engenharia de Software DI/PUC-Rio + Arcabouço de teste de módulos C (c) 2006 + +--------------------------------------------- + Construto sob teste: TRAB2-1 + + Arquivo de teste: testetabuleiroscript + + +!!! 0 Linha: 1 //Teste do Módulo Tabuleiro + 3 == Criar tabuleiro + 6 == Mover Peca da casa 1 para casa 2 + 9 == Mover Peca da casa 10 (vazia) para qualquer casa (errado)casa de origem esta vazia + + 12 == Mover Peca da casa 23 para a 0 + 15 == Mover uma peça por todas as casas do tabuleiro de 0 a 23 + 42 == Destruir Tabuleiro + +!!! Número de linhas lidas: 43 +!!! Número de casos de teste: 6 +!!! Número comandos corretos: 28 +!!! Número de falhas encontradas: 0 + +!!! Não foram encontrados problemas + + +!!! Numero de espacos ainda alocados: 0 \ No newline at end of file diff --git a/tabuleiro/source tabuleiro/ArcaboucoTeste.lib b/tabuleiro/source tabuleiro/ArcaboucoTeste.lib new file mode 100644 index 0000000..41ba199 Binary files /dev/null and b/tabuleiro/source tabuleiro/ArcaboucoTeste.lib differ diff --git a/peca/peca source/GENERICO.H b/tabuleiro/source tabuleiro/GENERICO.H similarity index 100% rename from peca/peca source/GENERICO.H rename to tabuleiro/source tabuleiro/GENERICO.H diff --git a/tabuleiro/source tabuleiro/LERPARM.H b/tabuleiro/source tabuleiro/LERPARM.H new file mode 100644 index 0000000..f12cf3d --- /dev/null +++ b/tabuleiro/source 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/LISTA.C b/tabuleiro/source tabuleiro/LISTA.C similarity index 100% rename from LISTA.C rename to tabuleiro/source tabuleiro/LISTA.C diff --git a/LISTA.H b/tabuleiro/source tabuleiro/LISTA.H similarity index 100% rename from LISTA.H rename to tabuleiro/source tabuleiro/LISTA.H diff --git a/peca/peca source/PECA.C b/tabuleiro/source tabuleiro/PECA.C similarity index 95% rename from peca/peca source/PECA.C rename to tabuleiro/source tabuleiro/PECA.C index 696d6a6..35951db 100644 --- a/peca/peca source/PECA.C +++ b/tabuleiro/source tabuleiro/PECA.C @@ -37,8 +37,6 @@ ***********************************************************************/ 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*/ @@ -51,6 +49,7 @@ typedef struct tgPeca{ /***** Código das funções exportadas pelo módulo *****/ + /*************************************************************************** * * Função: Pec Criar Peça diff --git a/PECA.h b/tabuleiro/source tabuleiro/PECA.h similarity index 100% rename from PECA.h rename to tabuleiro/source tabuleiro/PECA.h diff --git a/tabuleiro/source tabuleiro/TABULEIRO.C b/tabuleiro/source tabuleiro/TABULEIRO.C new file mode 100644 index 0000000..a1c0b5f --- /dev/null +++ b/tabuleiro/source tabuleiro/TABULEIRO.C @@ -0,0 +1,211 @@ +/*************************************************************************** +* $MCI Módulo de implementação: TAB Tabuleiro de Gamão +* +* Arquivo gerado: TABULEIRO.C +* Letras identificadoras: TAB +* +* Nome da base de software: Arcabouço para a automação de testes de programas redigidos em C +* +* Projeto: INF 1301 / 1628 Automatização dos testes de módulos C +* Gestor: LES/DI/PUC-Rio +* Autores: fvc - 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 +* 2 fvc, tbm 23/set/2015 término do deselvolvimento +* 1 fvc, tbm 21/set/2015 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: TAB &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]); + + return TAB_CondRetOK; +} + +/*************************************************************************** +* +* Função: TAB &Destruir Tabuleiro +* ****/ + +TAB_tpCondRet TAB_DestruirTabuleiro (TAB_tppTabuleiro pTab) +{ + + LIS_DestruirLista(pTab->Casas); + // Libera o ponteiro para o tabuleiro + free(pTab); + + return TAB_CondRetOK; +} + +/*************************************************************************** +* +* Função: TAB &Mover Peças tabuleiro +* ****/ + +TAB_tpCondRet TAB_MoverPeca( TAB_tppTabuleiro pTab, int casaOrigem, int casaDestino ) +{ + tppPeca pecatemp1, pecatemp2; + char cor; + LIS_tppLista listatemp; + int mov = casaDestino - casaOrigem; + + // Checa a validade das casas de origem e destino + if((casaOrigem < 0) || (casaOrigem > 23)) + { + printf("casaOrigem inválida \n"); + return TAB_CondRetErro; + } + if((casaDestino < 0) || (casaDestino > 23)) + { + printf("casaDestino inválida \n"); + return TAB_CondRetErro; + } + + // Ir para a casa de origem + IrInicioLista(pTab->Casas); + LIS_AvancarElementoCorrente(pTab->Casas, casaOrigem); + + // Obter referência para a lista nela armazenada + listatemp = (LIS_tppLista)LIS_ObterValor(pTab->Casas); + + // Obter a cor da peca na lista temp + pecatemp1 = (tppPeca)LIS_ObterValor(listatemp); + + // se pecatemp1 == NULL entao a lista está vazia + if(pecatemp1 == NULL) + { + printf("casa de origem esta vazia \n"); + return TAB_CondRetErro; + } + else // se nao + { + Pec_ObterCor(pecatemp1, &cor); + } + + // Excluir uma peça da lista temp + if(LIS_ExcluirElemento(listatemp) != LIS_CondRetOK) + { + printf("Erro ao excluir peca da casa de orgiem\n"); + return TAB_CondRetErro; + } + + // Avança para a casa destino. + LIS_AvancarElementoCorrente(pTab->Casas, mov); + + // Obtem a referencia para a lista nela armazenada + listatemp = (LIS_tppLista)LIS_ObterValor(pTab->Casas); + + // Criar uma peça com a mesma cor q a peça antiga + if(Pec_CriarPeca(&pecatemp2, cor) != Pec_CondRetOK) + { + printf("Erro ao criar a peca na casa destino \n"); + return TAB_CondRetErro; + } + + // Adiciona esta peça na casa de destino + if(LIS_InserirElementoApos(listatemp, pecatemp2) != LIS_CondRetOK) + { + printf("Erro ao adicionar peca na casa destino \n"); + return TAB_CondRetErro; + } + + return TAB_CondRetOK; +} + + + + + + + + + + + + + + diff --git a/tabuleiro/source tabuleiro/TABULEIRO.H b/tabuleiro/source tabuleiro/TABULEIRO.H new file mode 100644 index 0000000..ec7371c --- /dev/null +++ b/tabuleiro/source tabuleiro/TABULEIRO.H @@ -0,0 +1,131 @@ +#if ! defined( TABULEIRO_ ) +#define TABULEIRO_ +/*************************************************************************** +* +* $MCD Módulo de definição: TAB Tabuleiro de Gamão +* +* Arquivo gerado: TABULEIRO.H +* Letras identificadoras: TAB +* +* Nome da base de software: Arcabouço para a automação de testes de programas redigidos em C +* +* Projeto: INF 1301 / 1628 Automatização dos testes de módulos C +* Gestor: LES/DI/PUC-Rio +* Autores: fvc + tbm +* +* $HA Histórico de evolução: +* Versão Autor Data Observações +* 2 fvc, tbm 23/set/2015 Ajustes e Término do desenvolvimento +* 1 fvc 21/set/2015 início desenvolvimento +* +* $ED Descrição do módulo +* O módulo implementa um simples tabuleiro de gamão +* e permite que peças sejam movimentadas pelo tabuleiro +* sem nenhuma restrição nem regras do gamão. +* +***************************************************************************/ + +#if defined( TABULEIRO_OWN ) + #define TABULEIRO_EXT +#else + #define TABULEIRO_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: TAB Condições de retorno +* +* +* $ED Descrição do tipo +* Condições de retorno das funções do Tabuleiro +* +***********************************************************************/ + + typedef enum { + + TAB_CondRetOK , + /* Concluiu corretamente */ + TAB_CondRetErro, + + TAB_CondRetFaltouMemoria, + + } TAB_tpCondRet ; + + + + +/*********************************************************************** +* +* $FC Função: TAB &Criar Tabuleiro +* +* $ED Descrição da função +* Cria um tabuleiro inicializado com as peças +* pretas e brancas no lugar correto como no início +* de um jogo de gamão +* +* $EP Parâmetros +* ExcluirValor - ponteiro para a função que processa a +* exclusão do valor referenciado pelo elemento +* a ser excluído. +* +* $FV Valor retornado +* Se executou corretamente retorna TAB_CondRetOK +* +* Se ocorreu algum erro, por exemplo falta de memória ou dados errados, +* a função retornará TAB_CondRetErro +* +***********************************************************************/ + + 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 o Tabuleiro dado +* +* $FV Valor retornado +* TAB_CondRetOK - destruiu sem problemas +* +***********************************************************************/ + + TAB_tpCondRet TAB_DestruirTabuleiro( TAB_tppTabuleiro pTab ) ; + + +/*********************************************************************** +* +* $FC Função: TAB &Mover Peça do Tabuleiro +* +* $ED Descrição da função +* Move a peça da casa de origem para a casa de destino. +* As casas variam de 0 a 23. +* +* $FV Valor retornado +* TAB_CondRetOK - Moveu sem problemas +* TAB_CondRetErro - Nao moveu a peça +* +***********************************************************************/ + + TAB_tpCondRet TAB_MoverPeca( TAB_tppTabuleiro pTab, int casaOrigem, int casaDestino ) ; + +/***********************************************************************/ + + + +#undef TABULEIRO_EXT + +/********** Fim do módulo de definição: TAB Tabuleiro de Gamão **********/ + +#else +#endif \ No newline at end of file diff --git a/tabuleiro/source tabuleiro/TESTTABULEIRO.C b/tabuleiro/source tabuleiro/TESTTABULEIRO.C new file mode 100644 index 0000000..80b8a8c --- /dev/null +++ b/tabuleiro/source tabuleiro/TESTTABULEIRO.C @@ -0,0 +1,154 @@ +/*************************************************************************** +* $MCI Módulo de implementação: TAB Tabuleiro de Gamão +* +* Arquivo gerado: TABULEIRO.C +* Letras identificadoras: TTAB +* +* Nome da base de software: Exemplo de teste automatizado +* +* Projeto: Disciplinas INF 1628 / 1301 +* Gestor: DI/PUC-Rio +* Autores: fvc - Felipe Vieira Cortes +* tbm - Tássio Borges de Miranda +* db - Daniela Brazão +* +* $HA Histórico de evolução: +* Versão Autor Data Observações +* 2 fvc, tbm 23/set/2015 término do deselvolvimento +* 1 fvc, tbm 21/set/2015 início 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: +* +* =criartabuleiro - Chama a função TAB_tpCondRet TAB_CriarTabuleiro(TAB_tppTabuleiro * pTab, void ( * ExcluirValor ) ( void * pDado ) ) ; +* =destruirtabuleiro - Chama a função TAB_tpCondRet TAB_DestruirTabuleiro( TAB_tppTabuleiro pTab ); +* =moverpeca - Chama a função TAB_tpCondRet TAB_MoverPeca( TAB_tppTabuleiro pTab, int casaOrigem, int casaDestino ) ; +***************************************************************************/ + +#include +#include +#include +#include "TST_ESPC.H" +#include "GENERICO.h" +#include "lerparm.h" + +#include "TABULEIRO.H" + +/* Tabela dos nomes dos comandos de teste específicos */ +#define CRIAR_TABULEIRO_CMD "=criartabuleiro" +#define DESTRUIR_TABULEIRO_CMD "=destruirtabuleiro" +#define MOVER_PECA_CMD "=moverpeca" + +TAB_tppTabuleiro Tab; + +/***** Protótipos das funções encapuladas no módulo *****/ + + static void DestruirValor( void * pValor ) ; + +/***** Código das funções exportadas pelo módulo *****/ + + +/*********************************************************************** +* +* $FC Função: TTAB Efetuar operações de teste específicas para o Modulo Tabuleiro +* +* $ED Descrição da função +* Efetua os diversos comandos de teste específicos para o módulo +* de Tabuleiro de gamão. +* +* $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 = TAB_CondRetOK ; + int CondRetEsperada = TAB_CondRetFaltouMemoria ; + /* inicializa para qualquer coisa */ + char ValorEsperado = '?' ; + char ValorObtido = '!' ; + char ValorDado = '\0' ; + char corEsperada = 'x'; + + int NumLidos = -1 ; + int i = 0; + int PosicaoReferencia, PosicaoFinal; + + /* Testar Criar Tabuleiro */ + if ( strcmp( ComandoTeste , CRIAR_TABULEIRO_CMD ) == 0 ) + { + + NumLidos = LER_LerParametros( "i" , + &CondRetEsperada ) ; + if ( NumLidos != 1 ) + { + return TST_CondRetParm ; + } /* if */ + + CondRetObtido = TAB_CriarTabuleiro(&Tab, DestruirValor); + + return TST_CompararInt( CondRetEsperada , CondRetObtido , + "Retorno errado ao criar o tabuleiro." ); + + } /* fim ativa: Testar Criar Tabuleiro */ + + /* Testar Destruir Tabuleiro*/ + else if ( strcmp( ComandoTeste , DESTRUIR_TABULEIRO_CMD ) == 0 ) + { + + NumLidos = LER_LerParametros( "i" , + &CondRetEsperada ) ; + if ( NumLidos != 1 ) + { + return TST_CondRetParm ; + } /* if */ + + CondRetObtido = TAB_DestruirTabuleiro(Tab) ; + + return TST_CompararInt( CondRetEsperada , CondRetObtido , + "Retorno errado ao destruir o tabuleiro" ); + + } /* fim ativa: Testar destruir tabuleiro */ + + /* Testar Tabuleiro Mover Peca*/ + else if ( strcmp( ComandoTeste , MOVER_PECA_CMD ) == 0 ) + { + + NumLidos = LER_LerParametros( "iii" , + &PosicaoReferencia,&PosicaoFinal , &CondRetEsperada ) ; + if ( NumLidos != 3) + { + return TST_CondRetParm ; + } /* if */ + + CondRetObtido = TAB_MoverPeca(Tab, PosicaoReferencia, PosicaoFinal ) ; + + return TST_CompararInt(CondRetObtido, CondRetEsperada, "Retorno errado ao mover a peca"); + + } /* fim ativa: Testar Tabuleiro Mover Peca */ + return TST_CondRetNaoConhec ; + + } /* Fim função: Tab Efetuar operações de teste específicas para Tabuleiro */ + + /*********************************************************************** +* +* $FC Função: TTAB -Destruir valor +* +***********************************************************************/ + +void DestruirValor( void * pValor ) + { + + free( pValor ) ; + + } /* Fim função: TTAB-Destruir valor */ \ No newline at end of file diff --git a/tabuleiro/source tabuleiro/TST_ESPC.H b/tabuleiro/source tabuleiro/TST_ESPC.H new file mode 100644 index 0000000..987ff8e --- /dev/null +++ b/tabuleiro/source 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 diff --git a/tabuleiro/testetabuleiro.bat b/tabuleiro/testetabuleiro.bat new file mode 100644 index 0000000..b3b77ea --- /dev/null +++ b/tabuleiro/testetabuleiro.bat @@ -0,0 +1 @@ +TRAB2-1 /stestetabuleiroscript > logsaidatabuleiro.txt \ No newline at end of file diff --git a/tabuleiro/testetabuleiroscript.script b/tabuleiro/testetabuleiroscript.script new file mode 100644 index 0000000..33b934b --- /dev/null +++ b/tabuleiro/testetabuleiroscript.script @@ -0,0 +1,43 @@ +//Teste do Módulo Tabuleiro + +== Criar tabuleiro +=criartabuleiro 0 + +== Mover Peca da casa 1 para casa 2 +=moverpeca 0 1 0 + +== Mover Peca da casa 10 (vazia) para qualquer casa (errado) +=moverpeca 10 23 1 + +== Mover Peca da casa 23 para a 0 +=moverpeca 23 0 0 + +== Mover uma peça por todas as casas do tabuleiro de 0 a 23 + +=moverpeca 0 1 0 +=moverpeca 1 2 0 +=moverpeca 2 3 0 +=moverpeca 3 4 0 +=moverpeca 4 5 0 +=moverpeca 5 6 0 +=moverpeca 6 7 0 +=moverpeca 7 8 0 +=moverpeca 8 9 0 +=moverpeca 9 10 0 +=moverpeca 10 11 0 +=moverpeca 11 12 0 +=moverpeca 12 13 0 +=moverpeca 13 14 0 +=moverpeca 14 15 0 +=moverpeca 15 16 0 +=moverpeca 16 17 0 +=moverpeca 17 18 0 +=moverpeca 18 19 0 +=moverpeca 19 20 0 +=moverpeca 20 21 0 +=moverpeca 21 22 0 +=moverpeca 22 23 0 + + +== Destruir Tabuleiro +=destruirtabuleiro 0 \ No newline at end of file diff --git a/teste1wz.txt b/teste1wz.txt deleted file mode 100644 index e69de29..0000000