Example #1
0
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;
}
Example #2
0
     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;
     } 
Example #3
0
/***************************************************************************
*  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;
}
Example #4
0
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;
}
Example #5
0
    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;
    }
Example #6
0
   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;

   }
Example #7
0
File: graph.c Project: rbertoche/t2
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;
}
Example #8
0
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;
}
Example #9
0
/***************************************************************************
*  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;
}
Example #10
0
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;
}
Example #11
0
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 */
Example #12
0
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 */
Example #13
0
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;
}
Example #14
0
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 */
Example #15
0
/*****  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;
   }
Example #16
0
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 */
Example #17
0
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 */
Example #21
0
File: PILHA.C Project: Rifeli/t4
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 */
Example #22
0
   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 */
Example #23
0
/***********************************************************************
*
*  $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;
    }
Example #24
0
    //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;
    }
Example #25
0
    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;
    }
Example #26
0
    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;
    }
Example #27
0
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 */
Example #28
0
   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 */
Example #29
0
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;
}