LIS_tppLista MTZ_criarTab(int x, int y) {
int i,j;
PLH_tppPilha Pilha;
LIS_tppLista Elem;
LIS_tppLista Col;
LIS_tppLista Tab = LIS_CriarLista(0);
/*Cria lista*/
if (Tab == NULL)
return NULL;
/*if NULL*/
for (i = 0; i < x; i++) {
Col = LIS_CriarLista(0);
LIS_InserirElementoApos(Tab, Col);
for (j = 0; j < y; j++) {
Pilha = PLH_CriarTopo();
LIS_InserirElementoApos(Col, Pilha);
}
}
/* Cria toda a matriz de pilhas */
IrInicioLista(Tab);
return Tab;
}
GRA_tppGrafo GRA_CriarGrafo( void (*ExcluirValor) (void* pDado) )
{
GRA_tpGrafo * pGrafo = NULL ;
LIS_tppLista l_vertice = NULL;
LIS_tppLista l_componente = NULL;
pGrafo = (GRA_tpGrafo*) calloc(1, sizeof(GRA_tpGrafo)) ;
if (pGrafo == NULL) {
return NULL ;
} /* if */
l_vertice = LIS_CriarLista(free); //A Exclusão será manual, iterando sobre os elementos;
if (l_vertice == NULL) {
free(pGrafo);
return NULL;
}
l_componente = LIS_CriarLista(NULL); //Controle interno e autocontido; Componentes não cuidam de dados do valor, só armazenam ponteiros.
if (l_componente == NULL) {
free(pGrafo);
LIS_DestruirLista(l_vertice);
return NULL;
}
pGrafo->vertices = l_vertice;
pGrafo->componentes = l_componente;
pGrafo->ExcluirValor = ExcluirValor ;
pGrafo->corrente = -1;
return pGrafo;
}
/***************************************************************************
* Função: GRA Inserir vertice
******/
GRA_tpCondRet GRA_InserirVertice(GRA_tppGrafo pGrafoParm, char *nomeVertice, void *pValor)
{
tpGrafo *pGrafo = (tpGrafo*) pGrafoParm;
tpVertice *pVertice;
if (pGrafo == NULL)
{
return GRA_CondRetGrafoNaoFoiCriado;
}
if (ExisteVertice(pGrafo, nomeVertice))
{
return GRA_CondRetJaExiste;
}
MEM_Alloc(sizeof(tpVertice), (void **) &pVertice);
if (pVertice == NULL)
{
return GRA_CondRetFaltouMemoria;
}
pVertice->nome = nomeVertice;
pVertice->pValor = pValor;
pVertice->destruirValor = pGrafo->destruirValor;
LIS_CriarLista(&pVertice->pAntecessores, NULL, CompararVerticeENome);
LIS_CriarLista(&pVertice->pSucessores, DestruirAresta, CompararArestaENome);
pGrafo->pCorrente = pVertice;
LIS_InserirElementoApos(pGrafo->pVertices, pVertice);
return GRA_CondRetOK;
}
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;
}
static int BFS(tpVertice* v, tpVertice* u) {
LIS_tppLista V = NULL; // LISTA VERTICE VISITADOS
LIS_tppLista Q = NULL; //FILA
LIS_tppLista arestas = NULL;
tpVertice* t = NULL;
tpVertice* s = NULL;
tpAresta* a = NULL;
int achou = 0;
int achou_V = 0;
V = LIS_CriarLista(NULL); // dados são referenciados por outros, não devem ser apagados
Q = LIS_CriarLista(NULL); // dados são referenciados por outros, não devem ser apagados
LIS_InserirElementoApos(V, v);
LIS_InserirElementoApos(Q, v); //Usado como uma Fila.
while (LIS_NumeroDeElementos(Q) > 0) {
LIS_IrInicioLista(Q);
t = (tpVertice *)LIS_ObterValor(Q);
LIS_ExcluirElemento(Q);
if (t == u) {
achou = 1;
break;
}
arestas = t->pNode->arestas;
LIS_IrInicioLista(arestas);
do {
a = (tpAresta *)LIS_ObterValor(arestas);
if(a == NULL) continue;
s = a->pVizinho;
LIS_IrInicioLista(V);
achou_V = 0;
do {
tpVertice * re = (tpVertice *)LIS_ObterValor(V);
if (re == NULL) {
continue;
}
if(re == s) achou_V = 1;
} while(LIS_AvancarElementoCorrente(V, 1) == LIS_CondRetOK);
if (!achou_V) {
if(LIS_InserirElementoApos(V, s)!= LIS_CondRetOK){ achou = -1;break;}
if(LIS_InserirElementoApos(Q, s)!= LIS_CondRetOK){ achou = -1;break;}
}
} while(LIS_AvancarElementoCorrente(arestas, 1) == LIS_CondRetOK);
}
LIS_DestruirLista(V);
LIS_DestruirLista(Q);
return achou;
}
LIS_tppLista FRC_CriarBaralho( )
{
int np ;
int rk ;
CAR_tppCarta pAuxCar;
LIS_tppLista pNovo = LIS_CriarLista( NULL );
if( pNovo == NULL)
{
return NULL ;
} /* if */
for( np = CAR_NaipePaus ;
np <= CAR_NaipeOuros ;
np++ )
{
for( rk = CAR_RankAs ;
rk <= CAR_RankRei ;
rk++ )
{
pAuxCar = CAR_CriarCarta( ( CAR_tpNaipe ) ( np ) ,
( CAR_tpRank ) ( rk ) );
LIS_InserirElementoApos( pNovo , ( void *) pAuxCar ) ;
} /* for */
} /* if */
IrInicioLista( pNovo ) ;
return pNovo;
}
Graph *GRA_New (FDelData fdd)
{
Graph *g;
CNT_CONTAR("GRA_New - Inicializao");
g = (Graph *) malloc(sizeof(Graph));
if (!g){
CNT_CONTAR("GRA_New - Nao alocou g");
return NULL;
}
g->nodes = LIS_CriarLista((FDelData) LIS_DestruirLista );
CNT_CONTAR("GRA_New - Alocando nodes");
if (!g->nodes){
CNT_CONTAR("GRA_New - Nao alocou nodes");
free (g);
return NULL;
}
g->delData = fdd;
g->currentNode = NULL;
CNT_CONTAR("GRA_New - Atribuies, finalizao");
#ifdef _DEBUG
g->nOfNodes = 0;
g->nOfLinks = 0;
CNT_CONTAR("GRA_New - Chamando AssertGraph, finalizando");
AssertGraph(g);
#endif /* _DEBUG */
return g;
}
CPC_tpCondRet CPC_CriarClassePeca( CPC_tppClassePeca * ppClassePeca , char * nome ) {
CPC_tpClassePeca * cp;
cp = (CPC_tppClassePeca)malloc(sizeof(CPC_tpClassePeca));
if(cp == NULL) {
return CPC_CondRetFaltouMemoria;
}
cp->nome = (char*)malloc(sizeof(char) * (strlen(nome) + 1));
if(cp->nome == NULL) {
free(cp);
return CPC_CondRetFaltouMemoria;
}
strcpy(cp->nome, nome);
cp->movimentos = LIS_CriarLista( free );
if(cp->movimentos == NULL) {
free(cp->nome);
free(cp);
return CPC_CondRetFaltouMemoria;
}
*ppClassePeca = cp;
return CPC_CondRetOK;
}
/***************************************************************************
* Função: GRA Criar grafo
******/
GRA_tpCondRet GRA_CriarGrafo(GRA_tppGrafo *ppGrafo,
void (*destruirValor)(void *pValor))
{
tpGrafo *pGrafo;
MEM_Alloc(sizeof(tpGrafo), (void **) &pGrafo);
pGrafo->pCorrente = NULL;
pGrafo->destruirValor = destruirValor;
LIS_CriarLista(&pGrafo->pOrigens, NULL, CompararVerticeENome);
LIS_CriarLista(&pGrafo->pVertices, DestruirVertice, CompararVerticeENome);
*ppGrafo = (GRA_tppGrafo) pGrafo;
return GRA_CondRetOK;
}
FIL_tppFila FIL_criaFila (int capacidade, void( * ExcluirValor ) ( void * pDado ) )
{
FIL_tppFila fila=(FIL_tpFila*)malloc(sizeof(FIL_tpFila));
fila->capacidade=capacidade;
LIS_CriarLista(&(fila->lista),ExcluirValor);
return fila;
}
void GRA_CriaListaSucessoresVertice(tpVerticeGrafo * pVertice)
{
LIS_tppLista pListaSuc ;
LIS_CriarLista (GRA_excluirValorLista, &pListaSuc);
pVertice->pVerSuc = pListaSuc ;
} /* Fim função: GRA &Criar Lista de sucessores do vertice do Grafo */
void GRA_CriaListaAntecessoresVertice(tpVerticeGrafo * pVertice)
{
LIS_tppLista pListaAnt ;
LIS_CriarLista (GRA_excluirValorLista , &pListaAnt);
pVertice->pVerAnt = pListaAnt ;
} /* Fim função: GRA &Criar Lista de antecessores do vertice do Grafo */
LIS_tppLista criarTab(int x, int y) {
int i;
LIS_tppLista Tab = LIS_CriarLista(0);
if (Tab == NULL)
return NULL;
while ( x > 0) {
LIS_tppLista Col = LIS_CriarLista(0);
LIS_InserirElementoApos(Tab, Col);
for (i = y; i > 0; i--) {
PtoTopo * Pilha = criaTopo();
LIS_InserirElementoApos(Col, Pilha);
}
x--;
}
return Tab;
}
void GRA_CriaListaOrigens( GRA_tppGrafo pGrafo )
{
LIS_tppLista pListaOrig ;
LIS_CriarLista (GRA_excluirValorLista , &pListaOrig);
pGrafo->pListaOrigens = pListaOrig ;
} /* Fim função: GRA &Criar Lista de origens Grafo */
/***** Código das funções encapsuladas no módulo *****/
LIS_tppLista criarListaAPartirDeString( char * str ){
int i, len = strlen(str);
LIS_tppLista lista = LIS_CriarLista();
for( i = 0 ; i <= len ; i++) {
LIS_InserirElementoApos( lista, str[i] );
LIS_IrFinalLista( lista );
}
return lista;
}
void GRA_CriaListaVertices( GRA_tppGrafo pGrafo )
{
LIS_tppLista pListaVert ;
LIS_CriarLista (GRA_excluirValorLista, &pListaVert);
pGrafo->pListaVertices= pListaVert ;
} /* Fim função: GRA &Criar Lista de vértices Grafo */
BAR_tpCondRet BAR_CriarBAR(BAR_tppCapturadas *pBAR, char cor, void ( * ExcluirValor ) ( void * pDado ) )
{
*pBAR = (BAR_tppCapturadas)malloc(sizeof(BAR_tpCapturadas));
if(*pBAR == NULL)
return BAR_CondRetFaltouMemoria;
(*pBAR)->ListaCapturadas = LIS_CriarLista(ExcluirValor);
(*pBAR)->cor = cor;
(*pBAR)->tamanho = 0;
return BAR_CondRetOK;
}
Tabuleiro *TAB_criar()
{
int x, y;
Tabuleiro *tabuleiro = (Tabuleiro*)malloc(sizeof(Tabuleiro));
if(!tabuleiro)
return NULL;
//Tratamento de espaço dinamico
#ifdef _DEBUG
CED_DefinirTipoEspaco(tabuleiro, TAB_Tabuleiro);
#endif
tabuleiro->lista = LIS_CriarLista(ListaExcluirLista);
if(!tabuleiro->lista) {
free(tabuleiro);
return NULL;
}
for(y = 0; y < TabuleiroAltura; ++y) {
LIS_tppLista lista = LIS_CriarLista(ListaExcluirPeca);
if(!lista) {
TAB_destruir(tabuleiro);
return NULL;
}
if(LIS_InserirElementoAntes(tabuleiro->lista, lista) != LIS_CondRetOK) {
TAB_destruir(tabuleiro);
return NULL;
}
for(x = 0; x < TabuleiroLargura; ++x){
if(LIS_InserirElementoAntes(lista, NULL) != LIS_CondRetOK) {
TAB_destruir(tabuleiro);
return NULL;
}
}
}
return tabuleiro;
}/* Fim função: TAB &Criar tabuleiro */
LIS_tppLista CriarListaPassos(PAS_tppPasso *passos, const int tamanho)
{
int i;
LIS_tppLista pPassos;
LIS_CriarLista(&pPassos, DestruirValor, NULL);
for (i = 0; i < tamanho; i++)
{
PAS_tppPasso pPasso;
pPasso = *(passos + i);
LIS_InserirElementoApos(pPassos, pPasso);
}
return pPassos;
}
/***************************************************************************
*
* Função: PIL &Criar Pilha Cartas
* ****/
PIL_tpCondRet PIL_CriarPilhaCartas (PIL_tpPilha *pPilha) {
LIS_tpCondRet condRet;
*pPilha = (PIL_tppPilha*) malloc (sizeof(PIL_tppPilha));
if (*pPilha == NULL)
return PIL_CondRetFaltouMemoria;
condRet = LIS_CriarLista( &((*pPilha)->cabeca) ,CAR_DestruirCarta );
if (condRet == LIS_CondRetFaltouMemoria){
free(*pPilha);
return PIL_CondRetFaltouMemoria;
}
else
return PIL_CondRetOK;
} /* Fim função: PIL &Criar Pilha Cartas */
PILHA_tpCondRet PILHA_CriarPilha(PILHA_tppPilha * pp)
{
PILHA_tppPilha p = NULL;
p = (PILHA_tppPilha)malloc(sizeof(PILHA_tpPilha));
if (!p)
return PILHA_CondRetFaltouMemoria;
#ifdef _DEBUG
CNT_CONTAR("PILHA_CriarPilha");
#endif
p->topo = LIS_CriarLista(NULL);
p->ExcluirValor = NULL;
p->quantidade = 0;
*pp = p;
#ifdef _DEBUG
CED_MarcarEspacoAtivo(pp);
#endif
return PILHA_CondRetOK;
} /* Fim função: PILHA Cria Pilha */
PIL_tpCondRet PIL_CriarPilhaVazia( PIL_tppPilha * pPilha )
{
LIS_tpCondRet condRet ;
*pPilha = NULL ;
*pPilha = ( PIL_tpPilha * ) malloc( sizeof( PIL_tpPilha ) ) ;
if( *pPilha == NULL )
{
return PIL_CondRetFaltouMemoria ;
} /* if */
condRet = LIS_CriarLista( &((*pPilha)->pListaCartas) , ExcluirCarta ) ;
if ( condRet == LIS_CondRetFaltouMemoria )
{
return PIL_CondRetFaltouMemoria ;
}
return PIL_CondRetOK ;
} /* Fim função: PIL &Criar Pilha Vazia */
/***********************************************************************
*
* $FC Função: MEN CriarMenu
*
***********************************************************************/
MEN_tpCondRet MEN_CriarMenu(MEN_tppMenus menus, int id, char* nome,int idpai) {
MEN_tpCondRet cr;
MEN_tppMenu m = (MEN_tppMenu)malloc(sizeof(Menu));
if(m==NULL)
return MEN_CondRetFaltouMemoria;
m->opcoes = LIS_CriarLista(free);
if(m->opcoes==NULL){
free(m);
return MEN_CondRetFaltouMemoria;
}
m->nome = nome;
m->id = id;
m->pai = idpai;
GRA_InserirVertice(menus->grafo,m,m->id);
cr = MEN_CriarOpcao(menus, m->id,'0', "Ir para o menu acima\n\t\t (encerrar o programa caso o menu atual seja Inicio)",volta);
if(cr!=MEN_CondRetOK)
{
LIS_DestruirLista(m->opcoes);
free(m);
}
//tratar cond ret
return cr;
}
//cria um vertice e sua estrutura interna
static tpVertice* CriarVertice(GRA_tppGrafo grafo, void* pValor, int id) {
tpVertice* v = NULL;
tpNode* no = NULL;
LIS_tppLista arestas = NULL;
tpVertice* t = NULL;
v = (tpVertice*) malloc( sizeof(tpVertice) );
if (v == NULL) {
return NULL;
}
no = (tpNode*) malloc( sizeof(tpNode) );
if (no == NULL) {
free(v);
return NULL;
}
arestas = LIS_CriarLista(free);
if(arestas == NULL) {
free(v);
free(no);
return NULL;
}
no->arestas = arestas;
no->pValor = pValor;
v->pNode = no;
v->id = id;
if( LIS_InserirElementoApos (grafo->componentes, v) != LIS_CondRetOK) {
free(v);
free(no);
LIS_DestruirLista(arestas);
return NULL ;
}
return v;
}
GRA_tpCondRet GRA_ObterVizinhos ( GRA_tppGrafo pGrafo, int idVertice, LIS_tppLista* pLista) {
tpVertice * pVertice = get_by_id(pGrafo,idVertice);
LIS_tppLista vizinhos = NULL;
LIS_tppLista Ret_vizinhos = NULL;
tpAresta* aresta = NULL;
int* idVerticeVizinho = NULL;
if (pVertice == NULL)
return GRA_CondRetNaoEhVertice;
Ret_vizinhos = LIS_CriarLista(free);
if (Ret_vizinhos == NULL) {
return GRA_CondRetFaltouMemoria;
}
vizinhos = pVertice->pNode->arestas;
LIS_IrInicioLista(vizinhos);
if (LIS_NumeroDeElementos(vizinhos) > 0) {
do {
idVerticeVizinho = (int*) calloc(1, sizeof(int));
aresta = (tpAresta *)LIS_ObterValor(vizinhos);
(*idVerticeVizinho) = aresta->pVizinho->id;
if (LIS_InserirElementoApos( Ret_vizinhos, idVerticeVizinho) != LIS_CondRetOK ) {
LIS_DestruirLista(Ret_vizinhos);
return GRA_CondRetFaltouMemoria;
}
}
while(LIS_AvancarElementoCorrente(vizinhos, 1) == LIS_CondRetOK);
}
*pLista = Ret_vizinhos;
return GRA_CondRetOK;
}
GRA_tpCondRet GRA_ObterOrigens( GRA_tppGrafo pGrafo, LIS_tppLista * pLista) {
LIS_tppLista Ret_origens = NULL;
LIS_tppLista origens = NULL ;
Ret_origens = LIS_CriarLista(NULL);
if (Ret_origens == NULL) {
return GRA_CondRetFaltouMemoria;
}
origens = pGrafo->componentes;
LIS_IrInicioLista(origens);
do {
tpVertice * no = (tpVertice *)LIS_ObterValor(origens);
if(no == NULL) break;
if(LIS_InserirElementoApos(Ret_origens,&(no->id)) != LIS_CondRetOK)
return GRA_CondRetFaltouMemoria;
}
while(LIS_AvancarElementoCorrente(origens, 1) == LIS_CondRetOK);
*pLista = Ret_origens;
return GRA_CondRetOK;
}
TST_tpCondRet TST_EfetuarComando( char * ComandoTeste )
{
int inxLista = -1 ,
numLidos = -1 ,
CondRetEsp = -1 ;
char StringDado[ DIM_VALOR ] ;
int ValEsp = -1 ;
int i ;
int numElem = -1 ;
StringDado[ 0 ] = 0 ;
/* Efetuar reset de teste de lista */
if ( strcmp( ComandoTeste , RESET_LISTA_CMD ) == 0 )
{
for( i = 0 ; i < DIM_VT_LISTA ; i++ )
{
vtListas[ i ] = NULL ;
} /* for */
return TST_CondRetOK ;
} /* fim ativa: Efetuar reset de teste de lista */
/* Testar CriarLista */
else if ( strcmp( ComandoTeste , CRIAR_LISTA_CMD ) == 0 )
{
numLidos = LER_LerParametros( "i" ,
&inxLista ) ;
if ( ( numLidos != 1 )
|| ( ! ValidarInxLista( inxLista , VAZIO )))
{
return TST_CondRetParm ;
} /* if */
vtListas[ inxLista ] =
LIS_CriarLista( DestruirValor ) ;
return TST_CompararPonteiroNulo( 1 , vtListas[ inxLista ] ,
"Erro em ponteiro de nova lista." ) ;
} /* fim ativa: Testar CriarLista */
/* Testar Esvaziar lista lista */
else if ( strcmp( ComandoTeste , ESVAZIAR_LISTA_CMD ) == 0 )
{
numLidos = LER_LerParametros( "i" ,
&inxLista ) ;
if ( ( numLidos != 1 )
|| ( ! ValidarInxLista( inxLista , NAO_VAZIO )))
{
return TST_CondRetParm ;
} /* if */
LIS_EsvaziarLista( vtListas[ inxLista ] ) ;
return TST_CondRetOK ;
} /* fim ativa: Testar Esvaziar lista lista */
/* Testar Destruir lista */
else if ( strcmp( ComandoTeste , DESTRUIR_LISTA_CMD ) == 0 )
{
numLidos = LER_LerParametros( "i" ,
&inxLista ) ;
if ( ( numLidos != 1 )
|| ( ! ValidarInxLista( inxLista , NAO_VAZIO )))
{
return TST_CondRetParm ;
} /* if */
LIS_DestruirLista( vtListas[ inxLista ] ) ;
vtListas[ inxLista ] = NULL ;
return TST_CondRetOK ;
} /* fim ativa: Testar Destruir lista */
/* Testar inserir elemento antes */
else if ( strcmp( ComandoTeste , INS_ELEM_ANTES_CMD ) == 0 )
{
struct user *u = (struct user*) malloc (sizeof (struct user));
LIS_tpCondRet lret;
if (!u)
return TST_CondRetMemoria;
numLidos = LER_LerParametros( "isssi" ,
&inxLista , u->nome, u->tel, u->ender , &CondRetEsp ) ;
if ( ( numLidos != 5 )
|| ( ! ValidarInxLista( inxLista , NAO_VAZIO )) )
{
return TST_CondRetParm ;
} /* if */
lret = LIS_InserirElementoAntes( vtListas[ inxLista ] , u ) ;
if ( lret != LIS_CondRetOK )
{
free( u ) ;
} /* if */
return TST_CompararInt( CondRetEsp , lret ,
"Condicao de retorno errada ao inserir antes." ) ;
} /* fim ativa: Testar inserir elemento antes */
/* Testar inserir elemento apos */
else if ( strcmp( ComandoTeste , INS_ELEM_APOS_CMD ) == 0 )
{
struct user *u = (struct user *)malloc (sizeof (struct user));
LIS_tpCondRet lret;
if (!u)
return TST_CondRetMemoria;
numLidos = LER_LerParametros( "isssi",
&inxLista, u->nome, u->tel, u->ender, &CondRetEsp ) ;
if ( ( numLidos != 5 )
|| ( ! ValidarInxLista( inxLista , NAO_VAZIO )) )
{
return TST_CondRetParm ;
} /* if */
lret = LIS_InserirElementoApos( vtListas[ inxLista ] , u ) ;
if ( lret != LIS_CondRetOK )
{
free( u ) ;
} /* if */
return TST_CompararInt( CondRetEsp , lret,
"Condicao de retorno errada ao inserir antes.") ;
} /* fim ativa: Testar inserir elemento apos */
/* Testar excluir simbolo */
else if ( strcmp( ComandoTeste , EXC_ELEM_CMD ) == 0 )
{
numLidos = LER_LerParametros( "ii" ,
&inxLista , &CondRetEsp ) ;
if ( ( numLidos != 2 )
|| ( ! ValidarInxLista( inxLista , NAO_VAZIO )) )
{
return TST_CondRetParm ;
} /* if */
return TST_CompararInt( CondRetEsp ,
LIS_ExcluirElemento( vtListas[ inxLista ] ) ,
"Condição de retorno errada ao excluir." ) ;
} /* fim ativa: Testar excluir simbolo */
/* Testar obter valor do elemento corrente */
else if ( strcmp( ComandoTeste , OBTER_NOME_CMD ) == 0 )
{
struct user *u;
numLidos = LER_LerParametros( "isi" ,
&inxLista , StringDado , &ValEsp ) ;
if ( ( numLidos != 3 )
|| ( ! ValidarInxLista( inxLista , NAO_VAZIO )) )
{
return TST_CondRetParm ;
} /* if */
u = (struct user*) LIS_ObterValor( vtListas[ inxLista ] ) ;
if ( ValEsp == 0 )
{
return TST_CompararPonteiroNulo( 0 , u,
"Valor não deveria existir." ) ;
} /* if */
if ( u == NULL )
{
return TST_CompararPonteiroNulo( 1 , u,
"Dado tipo um deveria existir." ) ;
} /* if */
return TST_CompararString( StringDado , u->nome,
"Valor nome do elemento esta' errado." ) ;
} /* fim ativa: Testar obter valor do elemento corrente */
/* Testar obter valor do elemento corrente */
else if ( strcmp( ComandoTeste, OBTER_TEL_CMD ) == 0 )
{
struct user *u;
numLidos = LER_LerParametros( "isi" ,
&inxLista , StringDado , &ValEsp ) ;
if ( ( numLidos != 3 )
|| ( ! ValidarInxLista( inxLista , NAO_VAZIO )) )
{
return TST_CondRetParm ;
} /* if */
u = (struct user*) LIS_ObterValor( vtListas[ inxLista ] ) ;
if ( ValEsp == 0 )
{
return TST_CompararPonteiroNulo( 0 , u,
"Valor não deveria existir." ) ;
} /* if */
if ( u == NULL )
{
return TST_CompararPonteiroNulo( 1 , u,
"Dado tipo um deveria existir." ) ;
} /* if */
return TST_CompararString( StringDado , u->tel,
"Valor nome do elemento esta' errado." ) ;
} /* fim ativa: Testar obter valor do elemento corrente */
/* Testar obter valor do elemento corrente */
else if ( strcmp( ComandoTeste , OBTER_ENDER_CMD ) == 0 )
{
struct user *u;
numLidos = LER_LerParametros( "isi" ,
&inxLista , StringDado , &ValEsp ) ;
if ( ( numLidos != 3 )
|| ( ! ValidarInxLista( inxLista , NAO_VAZIO )) )
{
return TST_CondRetParm ;
} /* if */
u = (struct user*) LIS_ObterValor( vtListas[ inxLista ] ) ;
if ( ValEsp == 0 )
{
return TST_CompararPonteiroNulo( 0 , u,
"Valor não deveria existir." ) ;
} /* if */
if ( u == NULL )
{
return TST_CompararPonteiroNulo( 1 , u,
"Dado tipo um deveria existir." ) ;
} /* if */
return TST_CompararString( StringDado , u->ender,
"Valor nome do elemento esta' errado." ) ;
} /* fim ativa: Testar obter valor do elemento corrente */
/* Testar ir para o elemento inicial */
else if ( strcmp( ComandoTeste , IR_INICIO_CMD ) == 0 )
{
numLidos = LER_LerParametros( "i" , &inxLista ) ;
if ( ( numLidos != 1 )
|| ( ! ValidarInxLista( inxLista , NAO_VAZIO )) )
{
return TST_CondRetParm ;
} /* if */
IrInicioLista( vtListas[ inxLista ] ) ;
return TST_CondRetOK ;
} /* fim ativa: Testar ir para o elemento inicial */
/* LIS &Ir para o elemento final */
else if ( strcmp( ComandoTeste , IR_FIM_CMD ) == 0 )
{
numLidos = LER_LerParametros( "i" , &inxLista ) ;
if ( ( numLidos != 1 )
|| ( ! ValidarInxLista( inxLista , NAO_VAZIO )) )
{
return TST_CondRetParm ;
} /* if */
IrFinalLista( vtListas[ inxLista ] ) ;
return TST_CondRetOK ;
} /* fim ativa: LIS &Ir para o elemento final */
/* LIS &Avançar elemento */
else if ( strcmp( ComandoTeste , AVANCAR_ELEM_CMD ) == 0 )
{
numLidos = LER_LerParametros( "iii" , &inxLista , &numElem ,
&CondRetEsp ) ;
if ( ( numLidos != 3 )
|| ( ! ValidarInxLista( inxLista , NAO_VAZIO )) )
{
return TST_CondRetParm ;
} /* if */
return TST_CompararInt( CondRetEsp ,
LIS_AvancarElementoCorrente( vtListas[ inxLista ] , numElem ) ,
"Condicao de retorno errada ao avancar" ) ;
} /* fim ativa: LIS &Avançar elemento */
return TST_CondRetNaoConhec ;
} /* Fim função: TLIS &Testar lista */
TST_tpCondRet TST_EfetuarComando( char * ComandoTeste )
{
/* Variáveis para retorno de operações com lista */
/* Devem ser inicializadas com qualquer valor */
LIS_tpCondRet LIS_CondRetObtido = LIS_CondRetOK ;
LIS_tpCondRet LIS_CondRetEsperada = LIS_CondRetFaltouMemoria ;
int indexFocoLista = '0';
int NumLidos = -1 ;
int i = 0;
int resposta = 0;
int numPassos = 0;
char * caracter;
char stringDado [2] ;
TST_tpCondRet Ret = TST_CondRetOK ;
stringDado[1]='\0';
/* Efetuar reset de teste de lista */
if ( strcmp (ComandoTeste, RESET_LIS_CMD) == 0 )
{
for ( i = 0; i < DIM_VT_LISTA; i++ )
vtListas[ i ] = NULL;
return TST_CondRetOK;
} /* Fim ativa: Efetuar reset de teste de lista */
/* Testar LIS Criar lista */
else if ( strcmp( ComandoTeste , CRIAR_LIS_CMD ) == 0 )
{
NumLidos = LER_LerParametros( "ii" ,
&indexFocoLista,
&LIS_CondRetEsperada ) ;
if ( NumLidos != 2 || !ValidarIndex ( indexFocoLista, DIM_VT_LISTA ) )
{
return TST_CondRetParm ;
} /* if */
LIS_CondRetObtido = LIS_CriarLista( &vtListas[ indexFocoLista ], DestruirConteudoLista );
return TST_CompararInt( LIS_CondRetEsperada , LIS_CondRetObtido ,
"Retorno errado ao criar lista." );
} /* Fim ativa: Testar LIS Criar lista */
/* Testar LIS Inserir elemento na lista antes do elemento corrente */
else if ( strcmp( ComandoTeste , INSERIR_ANTES_CMD ) == 0 )
{
NumLidos = LER_LerParametros( "ici" ,
&indexFocoLista,
stringDado,
&LIS_CondRetEsperada ) ;
if ( NumLidos != 3 || !ValidarIndex ( indexFocoLista, DIM_VT_LISTA ) )
{
return TST_CondRetParm ;
} /* if */
caracter = ( char * ) malloc( strlen( stringDado ) + 1 ) ;
if ( caracter == NULL )
{
return TST_CondRetMemoria ;
} /* if */
strcpy( caracter , stringDado ) ;
LIS_CondRetObtido = LIS_InserirElementoAntes ( vtListas[ indexFocoLista ], caracter );
return TST_CompararInt( LIS_CondRetEsperada , LIS_CondRetObtido ,
"Retorno errado ao inserir à esquerda (antes do elemento corrente da lista)." );
} /* fim ativa: Testar LIS Inserir elemento na lista antes do elemento corrente */
/* Testar LIS Inserir elemento na lista depois do elemento corrente */
else if ( strcmp( ComandoTeste , INSERIR_APOS_CMD ) == 0 )
{
NumLidos = LER_LerParametros( "ici" ,
&indexFocoLista,
stringDado,
&LIS_CondRetEsperada ) ;
if ( NumLidos != 3 || !ValidarIndex ( indexFocoLista, DIM_VT_LISTA ) )
{
return TST_CondRetParm ;
} /* if */
caracter = ( char * ) malloc( strlen( stringDado ) + 1 ) ;
if ( caracter == NULL )
{
return TST_CondRetMemoria ;
} /* if */
strcpy( caracter , stringDado ) ;
LIS_CondRetObtido = LIS_InserirElementoApos ( vtListas[ indexFocoLista ], caracter );
return TST_CompararInt( LIS_CondRetEsperada , LIS_CondRetObtido ,
"Retorno errado ao inserir à direita (após elemento corrente)." );
} /* fim ativa: Testar LIS Inserir elemento na lista depois do elemento corrente */
/* Testar LIS Ir para elemento inicial (origem da lista) */
else if ( strcmp( ComandoTeste , IR_INICIOLISTA_CMD ) == 0 )
{
NumLidos = LER_LerParametros( "ii" ,
&indexFocoLista,
&LIS_CondRetEsperada ) ;
if ( NumLidos != 2 || !ValidarIndex ( indexFocoLista, DIM_VT_LISTA ) )
{
return TST_CondRetParm ;
} /* if */
LIS_CondRetObtido = LIS_IrInicioLista( vtListas[ indexFocoLista ] ) ;
return TST_CompararInt( LIS_CondRetEsperada , LIS_CondRetObtido ,
"Retorno errado ao ir para o início da lista." );
} /* fim ativa: Testar LIS Ir para elemento inicial (origem da lista) */
/* Testar LIS Ir para elemento final (fim da lista) */
else if ( strcmp( ComandoTeste , IR_FIMLISTA_CMD ) == 0 )
{
NumLidos = LER_LerParametros( "ii" ,
&indexFocoLista,
&LIS_CondRetEsperada ) ;
if ( NumLidos != 2 || !ValidarIndex ( indexFocoLista, DIM_VT_LISTA ) )
{
return TST_CondRetParm ;
} /* if */
LIS_CondRetObtido = LIS_IrFinalLista( vtListas[ indexFocoLista ] ) ;
return TST_CompararInt( LIS_CondRetEsperada , LIS_CondRetObtido ,
"Retorno errado ao ir para o fim da lista." );
} /* fim ativa: Testar LIS Ir para elemento final (fim da lista) */
/* Testar LIS Percorre lista */
else if ( strcmp( ComandoTeste , PERCORRE_LIS_CMD ) == 0 )
{
NumLidos = LER_LerParametros( "iii" ,
&indexFocoLista,
&numPassos,
&LIS_CondRetEsperada ) ;
if ( NumLidos != 3 || !ValidarIndex ( indexFocoLista, DIM_VT_LISTA ) )
{
return TST_CondRetParm ;
} /* if */
LIS_CondRetObtido = LIS_PercorreLista( vtListas[ indexFocoLista ], numPassos ) ;
return TST_CompararInt( LIS_CondRetEsperada , LIS_CondRetObtido ,
"Retorno errado ao percorrer a lista." );
} /* fim ativa: Testar LIS Percorre lista */
/* Testar LIS Obter elementos existentes na lista */
else if ( strcmp ( ComandoTeste, OBTER_NUMELEMLISTA_CMD ) == 0 )
{
NumLidos = LER_LerParametros ( "ii",
&indexFocoLista,
&LIS_CondRetEsperada ) ;
if ( NumLidos != 2 || !ValidarIndex ( indexFocoLista, DIM_VT_LISTA ) )
{
return TST_CondRetParm;
}
LIS_CondRetObtido = LIS_ObterNumeroElementos ( vtListas[ indexFocoLista ], &resposta );
if ( LIS_CondRetObtido == LIS_CondRetOK )
{
printf ( "\nNumero de elementos na lista: %d\n", resposta );
}
return TST_CompararInt( LIS_CondRetEsperada , LIS_CondRetObtido ,
"Retorno errado ao requisitar número de elementos de lista." );
} /* fim ativa: Testar LIS Obter elementos existentes na lista */
/* Testar LIS Excluir elemento corrente da lista */
else if ( strcmp ( ComandoTeste, EXC_ELEM_CMD ) == 0 )
{
NumLidos = LER_LerParametros ( "ii",
&indexFocoLista,
&LIS_CondRetEsperada );
if ( NumLidos != 2 || !ValidarIndex ( indexFocoLista, DIM_VT_LISTA ))
{
return TST_CondRetParm;
}
LIS_CondRetObtido = LIS_ExcluirElementoCorrente ( vtListas[ indexFocoLista ] );
return TST_CompararInt( LIS_CondRetEsperada , LIS_CondRetObtido ,
"Retorno errado ao excluir elemento corrente da lista." );
} /* fim ativa: Testar LIS Excluir elemento corrente da lista */
/* Testar LIS Procurar valor nos elementos da lista */
else if ( strcmp ( ComandoTeste, PROCURA_VALISTA_CMD ) == 0 )
{
NumLidos = LER_LerParametros ( "ici",
&indexFocoLista,
stringDado,
&LIS_CondRetEsperada );
if ( NumLidos != 3 || !ValidarIndex ( indexFocoLista, DIM_VT_LISTA ))
{
return TST_CondRetParm;
}
LIS_CondRetObtido = LIS_ProcurarValor ( vtListas[ indexFocoLista ], (void**)&stringDado, ComparaConteudo );
return TST_CompararInt( LIS_CondRetEsperada , LIS_CondRetObtido ,
"Retorno errado ao procurar elemento da lista." );
} /* fim ativa: Testar LIS Procurar valor nos elementos da lista */
/* Testar LIS Obter valor armazenado no elemento corrente */
else if ( strcmp( ComandoTeste , OBTER_VALISTA_CMD ) == 0 )
{
NumLidos = LER_LerParametros( "ici" ,
&indexFocoLista,
stringDado,
&LIS_CondRetEsperada );
if ( NumLidos != 3 || !ValidarIndex( indexFocoLista, DIM_VT_LISTA ) )
{
return TST_CondRetParm ;
} /* if */
LIS_CondRetObtido = LIS_ObterValorCorrente ( vtListas[ indexFocoLista ], (void**)&caracter ) ;
if ( LIS_CondRetObtido == LIS_CondRetOK )
{
printf ("\nCaracter obtido: %c \n", *caracter );
return TST_CompararChar( stringDado[0], *caracter, "Caracteres diferentes" );
}
else
{
return TST_CompararInt( LIS_CondRetEsperada, LIS_CondRetObtido, "Retorno errado para obter elemento do elemento corrente da lista." );
}
} /* fim ativa: Testar LIS Obter valor armazenado no elemento corrente */
/* Testar LIS Esvaziar lista */
else if ( strcmp( ComandoTeste , ESVAZIAR_LIS_CMD ) == 0 )
{
NumLidos = LER_LerParametros ( "ii",
&indexFocoLista,
&LIS_CondRetEsperada );
if (NumLidos != 2 || !ValidarIndex ( indexFocoLista, DIM_VT_LISTA ) )
{
return TST_CondRetParm;
}
LIS_CondRetObtido = LIS_EsvaziarLista ( vtListas[ indexFocoLista ] ) ;
return TST_CompararInt ( LIS_CondRetEsperada, LIS_CondRetObtido, "Retorno de erro ao esvaziar lista." );
} /* fim ativa: Testar LIS Esvaziar lista */
/* Testar LIS Destruir lista */
else if ( strcmp( ComandoTeste , DESTROI_LIS_CMD ) == 0 )
{
NumLidos = LER_LerParametros ( "ii",
&indexFocoLista,
&LIS_CondRetEsperada );
if ( NumLidos != 2 || !ValidarIndex ( indexFocoLista, DIM_VT_LISTA ) )
{
return TST_CondRetParm;
}
LIS_CondRetObtido = LIS_DestruirLista( &vtListas[ indexFocoLista ] ) ;
return TST_CompararInt( LIS_CondRetEsperada , LIS_CondRetObtido ,
"Retorno errado ao destruir lista." );
} /* fim ativa: Testar LIS Destruir lista */
return TST_CondRetNaoConhec ;
} /* Fim função: TLIS Efetuar operações de teste específicas para lista de caracteres */
TST_tpCondRet TST_EfetuarComando(char * ComandoTeste)
{
int inxLista = -1, numLidos = -1, CondRetEsp = -1;
TST_tpCondRet CondRet;
char StringDado[DIM_VALOR];
char * pDado;
int IntDado[DIM_VALOR_INT];
int* pDadoInt;
int ValEsp = -1;
int i;
int numElem = -1;
int inxStoredPtr;
for(i = 0; i < DIM_VT_LISTA; i++)
storedPtr[i][0] = NULL;
StringDado[0] = 0;
/* Efetuar reset de teste de lista */
if(strcmp(ComandoTeste, RESET_LISTA_CMD) == 0) {
for(i = 0; i < DIM_VT_LISTA; i++) {
vtListas[i] = NULL;
storedPtrIndex[i] = 1;
}
return TST_CondRetOK;
} /* fim ativa: Efetuar reset de teste de lista */
/* Testar CriarLista */
else if(strcmp(ComandoTeste, CRIAR_LISTA_CMD) == 0) {
numLidos = LER_LerParametros("i", &inxLista);
if((numLidos != 1) || (!ValidarInxLista(inxLista, VAZIO)))
return TST_CondRetParm;
vtListas[inxLista] = LIS_CriarLista(DestruirValor);
return TST_CompararPonteiroNulo(1, vtListas[inxLista], "Erro em ponteiro de nova lista.");
} /* fim ativa: Testar CriarLista */
/* Testar Esvaziar lista lista */
else if(strcmp(ComandoTeste, ESVAZIAR_LISTA_CMD) == 0) {
numLidos = LER_LerParametros("i", &inxLista);
if((numLidos != 1) || (!ValidarInxLista(inxLista, NAO_VAZIO)))
return TST_CondRetParm;
LIS_EsvaziarLista(vtListas[inxLista]);
return TST_CondRetOK;
} /* fim ativa: Testar Esvaziar lista lista */
/* Testar Destruir lista */
else if(strcmp(ComandoTeste, DESTRUIR_LISTA_CMD) == 0) {
numLidos = LER_LerParametros("i", &inxLista);
if((numLidos != 1) || (!ValidarInxLista(inxLista, NAO_VAZIO)))
return TST_CondRetParm;
LIS_DestruirLista(vtListas[inxLista]);
vtListas[inxLista] = NULL;
return TST_CondRetOK;
} /* fim ativa: Testar Destruir lista */
/* Testar inserir elemento antes */
else if(strcmp(ComandoTeste, INS_ELEM_ANTES_CMD) == 0) {
numLidos = LER_LerParametros("isi", &inxLista, StringDado, &CondRetEsp);
if((numLidos != 3) || (!ValidarInxLista(inxLista, NAO_VAZIO)))
return TST_CondRetParm;
if(!ValidarInxStoredPtr(storedPtrIndex[inxLista]))
return TST_CondRetMemoria;
pDado = (char *) malloc(strlen(StringDado) + 1);
if(pDado == NULL)
return TST_CondRetMemoria;
storedPtr[inxLista][storedPtrIndex[inxLista]++] = pDado;
strcpy(pDado, StringDado);
CondRet = LIS_InserirElementoAntes(vtListas[inxLista], pDado);
if(CondRet != LIS_CondRetOK)
free(pDado);
return TST_CompararInt(CondRetEsp, CondRet, "Condicao de retorno errada ao inserir antes.");
} /* fim ativa: Testar inserir elemento antes */
/* Testar inserir elemento antes INTEIRO */
else if(strcmp(ComandoTeste, INS_ELEM_ANTES_CMD_INT) == 0) {
numLidos = LER_LerParametros("iiii", &inxLista, &IntDado[0], &IntDado[1], &CondRetEsp);
if((numLidos != 4) || (!ValidarInxLista(inxLista, NAO_VAZIO)))
return TST_CondRetParm;
if(!ValidarInxStoredPtr(storedPtrIndex[inxLista]))
return TST_CondRetMemoria;
pDadoInt = (int *) malloc(DIM_VALOR_INT*sizeof(int));
if(pDadoInt == NULL)
return TST_CondRetMemoria;
storedPtr[inxLista][storedPtrIndex[inxLista]++] = pDadoInt;
for(i=0;i<DIM_VALOR_INT;i++)
pDadoInt[i]=IntDado[i];
CondRet = LIS_InserirElementoAntes(vtListas[inxLista], pDadoInt);
if(CondRet != LIS_CondRetOK)
free(pDadoInt);
return TST_CompararInt(CondRetEsp, CondRet, "Condicao de retorno errada ao inserir antes.");
} /* fim ativa: Testar inserir elemento antes INTEIRO*/
/* Testar inserir elemento apos */
else if(strcmp(ComandoTeste, INS_ELEM_APOS_CMD) == 0) {
numLidos = LER_LerParametros("isi", &inxLista, StringDado, &CondRetEsp);
if((numLidos != 3) || (!ValidarInxLista(inxLista, NAO_VAZIO)))
return TST_CondRetParm;
if(!ValidarInxStoredPtr(storedPtrIndex[inxLista]))
return TST_CondRetMemoria;
pDado = (char*)malloc(strlen(StringDado) + 1);
if(pDado == NULL)
return TST_CondRetMemoria;
storedPtr[inxLista][storedPtrIndex[inxLista]++] = pDado;
strcpy(pDado, StringDado);
CondRet = LIS_InserirElementoApos(vtListas[inxLista], pDado);
if(CondRet != LIS_CondRetOK)
free(pDado);
return TST_CompararInt(CondRetEsp, CondRet, "Condicao de retorno errada ao inserir apos.");
} /* fim ativa: Testar inserir elemento apos */
/* Testar inserir elemento apos INTEIRO*/
else if(strcmp(ComandoTeste, INS_ELEM_APOS_CMD_INT) == 0) {
numLidos = LER_LerParametros("iiii", &inxLista, &IntDado[0], &IntDado[1], &CondRetEsp);
if((numLidos != 4) || (!ValidarInxLista(inxLista, NAO_VAZIO)))
return TST_CondRetParm;
if(!ValidarInxStoredPtr(storedPtrIndex[inxLista]))
return TST_CondRetMemoria;
pDadoInt = (int *) malloc(DIM_VALOR_INT * sizeof(int));
if(pDadoInt == NULL)
return TST_CondRetMemoria;
storedPtr[inxLista][storedPtrIndex[inxLista]++] = pDadoInt;
for(i=0;i<DIM_VALOR_INT;i++)
pDadoInt[i]=IntDado[i];
CondRet = LIS_InserirElementoApos(vtListas[inxLista], pDadoInt);
if(CondRet != LIS_CondRetOK)
free(pDadoInt);
return TST_CompararInt(CondRetEsp, CondRet, "Condicao de retorno errada ao inserir apos.");
} /* fim ativa: Testar inserir elemento apos INTEIRO*/
/* Testar excluir simbolo */
else if(strcmp(ComandoTeste, EXC_ELEM_CMD) == 0) {
numLidos = LER_LerParametros("ii", &inxLista, &CondRetEsp);
if((numLidos != 2) || (!ValidarInxLista(inxLista, NAO_VAZIO)))
return TST_CondRetParm;
return TST_CompararInt(CondRetEsp, LIS_ExcluirElemento(vtListas[inxLista]),
"Condição de retorno errada ao excluir.");
} /* fim ativa: Testar excluir simbolo */
/* Testar obter valor do elemento corrente */
else if(strcmp(ComandoTeste, OBTER_VALOR_CMD) == 0) {
numLidos = LER_LerParametros("isi", &inxLista, StringDado, &ValEsp);
if((numLidos != 3) || (!ValidarInxLista(inxLista, NAO_VAZIO)))
return TST_CondRetParm;
pDado = (char *) LIS_ObterValor(vtListas[inxLista]);
if(ValEsp == 0)
return TST_CompararPonteiroNulo(0, pDado, "Valor não deveria existir.");
if(pDado == NULL)
return TST_CompararPonteiroNulo(1, pDado, "Dado tipo um deveria existir.");
return TST_CompararString(StringDado, pDado, "Valor do elemento errado.");
} /* fim ativa: Testar obter valor do elemento corrente */
/* Testar obter valor do elemento corrente INTEIRO*/
else if(strcmp(ComandoTeste, OBTER_VALOR_CMD_INT) == 0) {
numLidos = LER_LerParametros("iiii", &inxLista, &IntDado[0], &IntDado[1], &ValEsp);
if((numLidos != 4) || (!ValidarInxLista(inxLista, NAO_VAZIO)))
return TST_CondRetParm;
pDadoInt = (int *)LIS_ObterValor(vtListas[inxLista]);
if(ValEsp == 0)
return TST_CompararPonteiroNulo(0, pDadoInt, "Valor não deveria existir.");
if(pDadoInt == NULL)
return TST_CompararPonteiroNulo(1, pDadoInt, "Dado tipo um deveria existir.");
return TST_CompararEspaco(IntDado, pDadoInt, DIM_VALOR_INT * sizeof(int),
"Valor do elemento errado.");
} /* fim ativa: Testar obter valor do elemento corrente INTEIRO*/
/* Testar ir para o elemento inicial */
else if(strcmp(ComandoTeste, IR_INICIO_CMD) == 0) {
numLidos = LER_LerParametros("i", &inxLista);
if((numLidos != 1) || (!ValidarInxLista(inxLista, NAO_VAZIO)))
return TST_CondRetParm;
LIS_IrInicioLista(vtListas[inxLista]);
return TST_CondRetOK;
} /* fim ativa: Testar ir para o elemento inicial */
/* LIS &Ir para o elemento final */
else if(strcmp(ComandoTeste, IR_FIM_CMD) == 0) {
numLidos = LER_LerParametros("i", &inxLista);
if((numLidos != 1) || (!ValidarInxLista(inxLista, NAO_VAZIO)))
return TST_CondRetParm;
LIS_IrFinalLista(vtListas[inxLista]);
return TST_CondRetOK;
} /* fim ativa: LIS &Ir para o elemento final */
/* LIS &Avançar elemento */
else if(strcmp(ComandoTeste, AVANCAR_ELEM_CMD) == 0) {
numLidos = LER_LerParametros("iii", &inxLista, &numElem, &CondRetEsp);
if((numLidos != 3) || (!ValidarInxLista(inxLista, NAO_VAZIO)))
return TST_CondRetParm;
return TST_CompararInt(CondRetEsp,
LIS_AvancarElementoCorrente(vtListas[inxLista], numElem),
"Condicao de retorno errada ao avancar");
} /* fim ativa: LIS &Avançar elemento */
/* Testar Ir Indice */
else if(strcmp(ComandoTeste, IR_INDICE_CMD) == 0) {
numLidos = LER_LerParametros("iii", &inxLista, &numElem, &CondRetEsp);
if((numLidos != 3) || (!ValidarInxLista(inxLista, NAO_VAZIO)))
return TST_CondRetParm;
return TST_CompararInt(CondRetEsp, LIS_IrIndice(vtListas[inxLista], numElem),
"Condicao de retorno errada ao ir para o índice");
} /* fim ativa: Testar Ir Indice */
/* Testar Setar Valor INTEIRO*/
else if(strcmp(ComandoTeste, SETAR_VALOR_CMD_INT) == 0) {
numLidos = LER_LerParametros("iiii", &inxLista, &IntDado[0], &IntDado[1], &CondRetEsp);
if((numLidos != 4) || (!ValidarInxLista(inxLista, NAO_VAZIO)))
return TST_CondRetParm;
if(!ValidarInxStoredPtr(storedPtrIndex[inxLista]))
return TST_CondRetMemoria;
pDadoInt = (int *) malloc(DIM_VALOR_INT * sizeof(int));
if(pDadoInt == NULL)
return TST_CondRetMemoria;
storedPtr[inxLista][storedPtrIndex[inxLista]++] = pDadoInt;
for(i=0;i<DIM_VALOR_INT;i++)
pDadoInt[i]=IntDado[i];
return TST_CompararInt(CondRetEsp, LIS_SetarValor(vtListas[inxLista], pDadoInt),
"Condicao de retorno errada ao ir marcar o valor");
} /* fim ativa: LIS Setar Valor INTEIRO*/
/* Testar Procurar Valor */
else if(strcmp(ComandoTeste, PROCURAR_VALOR_CMD) == 0) {
numLidos = LER_LerParametros("iii", &inxLista, &inxStoredPtr, &CondRetEsp);
if((numLidos != 3) || (!ValidarInxLista(inxLista, NAO_VAZIO)))
return TST_CondRetParm;
if(!ValidarInxStoredPtr(inxStoredPtr))
return TST_CondRetParm;
return TST_CompararInt(CondRetEsp, LIS_ProcurarValor(vtListas[inxLista], storedPtr[inxLista][inxStoredPtr]),
"Condicao de retorno errada ao procurar valor");
} /* fim ativa: LIS Procurar Valor */
return TST_CondRetNaoConhec;
} /* Fim função: TLIS &Testar lista */
int main (void)
{
int qtdprocessos, met;
FILE* out = fopen("saida.txt","w");
int i, j, fail = 0, cnt = 0, tamProntos, tamIO, tamIO2, seg = 0, inxExec, inxIO;
Processo *aux, *procExec, *procIO, *procRetirado;
LIS_tppLista listaIO = LIS_CriarLista();
LIS_tppLista listaProntos = LIS_CriarLista();
Memory * mem = (Memory*)malloc(sizeof(Memory));
FILE* fp = fopen("entrada.txt", "r");
Processo *vp = (Processo*)malloc(100*sizeof(Processo));
qtdprocessos = lerEntrada(&fp, vp);
imprimeVetor(vp, qtdprocessos);
InicializaMemoria(mem);
procExec = NULL;
// Insere os elementos lidos numa lista de prontos
for(i = 0; i < qtdprocessos; i++)
{
LIS_InserirElementoApos(listaProntos, &vp[i]);
LIS_AvancarElementoCorrente(listaProntos, 1);
vp[i].segAtual = -1;
vp[i].naMemoria = 0;
vp[i].t_exec = 0;
vp[i].t_io = 0;
}
printf("1: First Fit \n");
printf("2: Best Fit \n");
printf("3: Worst Fit \n");
printf("4: Next Fit \n");
scanf("%d", &met);
EXEC:
IrInicioLista(listaProntos); // vai pro inicio da lista de prontos
aux = (Processo*)LIS_ObterValor(listaProntos);
switch(met)
{
case 1:
firstFit(mem, listaProntos);
break;
case 2:
BestFit(mem, listaProntos);
break;
case 3:
WorstFit(mem, listaProntos);
break;
case 4:
NextFit(mem, listaProntos);
break;
default:
break;
}
imprimeMemoria(mem);
printf("\n Lista de Prontos \n");
ImprimirLista(listaProntos);
printf("\n Lista de IO \n");
ImprimirLista(listaIO);
/* * * * * * * * * * * * * * * * * * * * * * */
// executar o processo
IrInicioLista(listaProntos);
tamProntos = LIS_ObterTamanho(listaProntos);
tamIO = LIS_ObterTamanho(listaIO);
aux = (Processo*)LIS_ObterValor(listaProntos); // obtem o priemeiro elemento da lista de prontos
while(tamProntos > 0)
{
if(!aux->naMemoria) // se o processo não esta em memoria
{
LIS_AvancarElementoCorrente(listaProntos, 1);
aux = (Processo*)LIS_ObterValor(listaProntos);
continue;
}
procExec = aux;
for(i = 0; i < 10; i++) // os 10 clocks de cpu
{
ImprimirEstado(&out, listaIO, procExec, mem, tempoTotal);
clock(1); tempoTotal++;
inxExec = procExec->t_exec;
procExec->exec[inxExec]--;
tamIO = LIS_ObterTamanho(listaIO);
IrInicioLista(listaIO);
for(j = 0; j < tamIO; j++) // diminui 1 de IO para todos q estao na lista de I/O
{
procIO = (Processo*)LIS_ObterValor(listaIO);
inxIO = procIO->t_io;
procIO->io[inxIO]--;
if(procIO->io[inxIO] == 0) // seu tempo de io acabou
{
LIS_ExcluirElemento(listaIO); // retira da lista de io e insere-o na lista de prontos
IrFinalLista(listaProntos);
LIS_InserirElementoApos(listaProntos, procIO);
procIO->t_io++;
}
LIS_AvancarElementoCorrente(listaIO, 1);
}
tamIO2 = LIS_ObterTamanho(listaIO);
if(tamIO != tamIO2)
{
switch(met)
{
case 1:
firstFit(mem, listaProntos);
break;
case 2:
BestFit(mem, listaProntos);
break;
case 3:
WorstFit(mem, listaProntos);
break;
case 4:
NextFit(mem, listaProntos);
break;
default:
break;
}
}
getNext(listaProntos);
if(procExec->exec[inxExec] == 0 || i == 9) // se o seu tempo de exec terminou entao retira da memoria
{
/* * * * * */ //imprimeMemoria(mem);
LIS_ExcluirElemento(listaProntos);
if(procExec->exec[inxExec] == 0) procExec->t_exec++; // se acabou um exec inteiro
if(procExec->exec[inxExec] == 0 && procExec->t_io < procExec->qtdio) // se o processo terminou um exec e ainda tem io para fazer
{
IrFinalLista(listaIO);
LIS_InserirElementoApos(listaIO, procExec);
}
// retira da memoria
// se o processo ainda tem exec para fazer
if(procExec->exec[inxExec] > 0)
{
IrFinalLista(listaProntos);
LIS_InserirElementoApos(listaProntos, procExec);
}
seg = procExec->segAtual;
procRetirado = RetiraProcessoMem(mem, seg);
procRetirado->naMemoria = 0;
switch(met)
{
case 1:
firstFit(mem, listaProntos);
break;
case 2:
BestFit(mem, listaProntos);
break;
case 3:
WorstFit(mem, listaProntos);
break;
case 4:
NextFit(mem, listaProntos);
break;
default:
break;
}
break;
}
imprimeMemoria(mem);
printf("\n Lista de Prontos \n");
ImprimirLista(listaProntos);
printf("\n Lista de IO \n");
ImprimirLista(listaIO);
} /* final dos 10 clocks*/
imprimeMemoria(mem);
printf("\n Lista de Prontos \n");
ImprimirLista(listaProntos);
printf("\n Lista de IO \n");
ImprimirLista(listaIO);
tamProntos = LIS_ObterTamanho(listaProntos);
IrInicioLista(listaProntos);
aux = (Processo*)LIS_ObterValor(listaProntos);
}
tamIO = LIS_ObterTamanho(listaIO);
while(tamIO > 0) // entao tem IO sobrando e ngm para executar
{
IrInicioLista(listaIO);
clock(1);tempoTotal++;
for(j = 0; j < tamIO; j++) // diminui 1 de IO para todos q estao na lista de I/O
{
procIO = (Processo*)LIS_ObterValor(listaIO);
inxIO = procIO->t_io;
procIO->io[inxIO]--;
if(procIO->io[inxIO] == 0) // seu tempo de io acabou
{
LIS_ExcluirElemento(listaIO); // retira da lista de io e insere-o na lista de prontos
IrFinalLista(listaProntos);
LIS_InserirElementoApos(listaProntos, procIO);
procIO->t_io++;
}
LIS_AvancarElementoCorrente(listaIO, 1);
}
tamIO = LIS_ObterTamanho(listaIO);
tamProntos = LIS_ObterTamanho(listaProntos);
imprimeMemoria(mem);
printf("\n Lista de Prontos \n");
ImprimirLista(listaProntos);
printf("\n Lista de IO \n");
ImprimirLista(listaIO);
if(tamProntos > 0) // se alguem voltou par a lista de prontos...
goto EXEC;
}
fclose(out);
free(mem);
free(vp);
free(listaProntos);
free(listaIO);
return 0;
}
