Пример #1
0
GRA_tpCondRet GRA_DestruirGrafo(GRA_tppGrafo pGrafo)
{
	int numElem = 0;
	tpVerticeGrafo * pVert ;
	GRA_tpCondRet RET;

	if(pGrafo==NULL){

		return GRA_CondRetGrafoNulo;

	} /* if */

	LIS_IrInicioLista(pGrafo->pListaVertices);

	LIS_NumElem(pGrafo->pListaVertices , &numElem);

	while(numElem > 0){

		LIS_IrInicioLista(pGrafo->pListaVertices);

		LIS_ObterValor(pGrafo->pListaVertices , (void**)&pVert);

		pGrafo->pCorrente = pVert;

	    GRA_ExcluirVerticeCorrente(pGrafo);
		
		LIS_NumElem(pGrafo->pListaVertices , &numElem);


	} /* while */

	LIS_DestruirLista(pGrafo->pListaOrigens);

	LIS_DestruirLista(pGrafo->pListaVertices);

	free(pGrafo);

	pGrafo  = NULL;

	return GRA_CondRetOK;

}
Пример #2
0
   TST_tpCondRet TST_EfetuarComando( char * ComandoTeste )
   {

	  GRA_tpCondRet CondRetObtido   = GRA_CondRetOK ;
      GRA_tpCondRet CondRetEsperada = GRA_CondRetFaltouMemoria ;

      char ValorDado     = '\0' ;
	  char ValorOrig     = '\0' ;
	  char ValorDest     = '\0' ;

	  char StringDado[DIM_VALOR];

	  int inxGrafo     = -1 ,
          NumLidos     = -1 ,
		  i            = 0  ;

	  #ifdef _DEBUG
			int indDeturpa = 0;
	  #endif
	  
		/* Testar GRA Criar grafo */

		if ( strcmp( ComandoTeste , CRIAR_GRAFO_CMD ) == 0 )
         {

            NumLidos = LER_LerParametros( "ii" ,
                               &inxGrafo , &CondRetEsperada ) ;

            if ( (NumLidos != 2) || ( ! ValidarInxGrafo(inxGrafo, VAZIO) ) )
            {
               return TST_CondRetParm ;
            } /* if */

			vtGrafo[ inxGrafo ] = NULL;

			CondRetObtido = GRA_CriarGrafo( &vtGrafo[ inxGrafo ] , TES_excluirInfo );

            return TST_CompararInt( CondRetEsperada , CondRetObtido ,
                                    "Retorno errado ao criar grafo." );

         } /* fim ativa: Testar GRA Criar grafo */		


		/* Testar GRA Criar vertice para grafo */

		else if( strcmp( ComandoTeste , CRIAR_VERTICE_GRAFO_CMD ) == 0 )
		{

			NumLidos = LER_LerParametros ( "isci" , &inxGrafo , &StringDado , &ValorDado , &CondRetEsperada );

			if ( NumLidos != 4 )
            {
               return TST_CondRetParm ;
            } /* if */

			CondRetObtido = GRA_CriaVerticeGrafo( vtGrafo[ inxGrafo ] , StringDado , ValorDado , TES_excluirInfo );

            return TST_CompararInt( CondRetEsperada , CondRetObtido ,
                                    "Retorno errado ao criar vertice no grafo." );


		} /* fim ativa: Testar GRA Criar vertice para grafo */


		/* Testar GRA Inserir aresta */

		else if(strcmp ( ComandoTeste, CRIA_ARESTA_CMD ) == 0)
		{
			NumLidos = LER_LerParametros ( "ccisi" , &ValorOrig, &ValorDest , &inxGrafo, &StringDado , &CondRetEsperada );
			if(NumLidos != 5){
				return TST_CondRetParm;
			}

			CondRetObtido = GRA_CriarAresta( ValorOrig , ValorDest , vtGrafo[ inxGrafo ] , StringDado  );

			return TST_CompararInt( CondRetEsperada , CondRetObtido ,
                                    "Retorno errado ao criar aresta." );

		} /* fim ativa: Testar GRA Inserir aresta */

				
		/* Testar GRA Excluir vértice */

		else if (strcmp (ComandoTeste, EXCLUIR_VERT_CMD) == 0)
		{
			NumLidos = LER_LerParametros ( "ii" , &inxGrafo , &CondRetEsperada );
			if(NumLidos != 2){

				return TST_CondRetParm;

			}

			CondRetObtido = GRA_ExcluirVerticeCorrente( vtGrafo[ inxGrafo ] );

			return TST_CompararInt( CondRetEsperada , CondRetObtido ,
                                    "Retorno errado ao excluir vértice." );

		} /* fim ativa: Testar GRA Excluir vértice */
		
		/* Testar GRA Obter valor do vértice corrente */

		else if(strcmp (ComandoTeste, OBTER_VALOR_VERT_CMD) == 0)
		{
			NumLidos = LER_LerParametros ( "isi" , &inxGrafo , &StringDado , &CondRetEsperada );
			if(NumLidos != 3){
				return TST_CondRetParm;
			}
			
			CondRetObtido = GRA_ChecarNomeVerticeCorrente( vtGrafo[inxGrafo] , StringDado );

			return TST_CompararInt( CondRetEsperada , CondRetObtido ,
                                    "Retorno errado ao obter valor do vértice corrente." );

		} /* fim ativa: Testar GRA Obter valor do vértice corrente */

		/* Testar GRA Inserir vértice no início da lista de origens */

		else if(strcmp (ComandoTeste, INSERE_VERT_ORIG_CMD ) == 0)
		{
			NumLidos = LER_LerParametros ( "ici" , &inxGrafo , &ValorDado , &CondRetEsperada );

			if(NumLidos != 3){
				return TST_CondRetParm;
			}
			
			CondRetObtido = GRA_InsereOrigem(vtGrafo[ inxGrafo ] , ValorDado);

			return TST_CompararInt( CondRetEsperada , CondRetObtido ,
                                    "Retorno errado ao inserir vertice na lista de origens" );

		} /* fim ativa: Testar GRA Inserir vértice no início da lista de origens */

		/* Testar GRA Inserir vértice no início da lista de origens */

		else if(strcmp (ComandoTeste, EXCLUIR_ARES_CMD ) == 0)
		{
			NumLidos = LER_LerParametros ( "ccii" , &ValorDado , &ValorDest ,  &inxGrafo , &CondRetEsperada );

			if(NumLidos != 4){
				return TST_CondRetParm;
			}
			
			CondRetObtido = GRA_ExcluirAresta( ValorDado , ValorDest , vtGrafo[ inxGrafo ]);

			return TST_CompararInt( CondRetEsperada , CondRetObtido ,
                                    "Retorno errado ao excluir aresta" );

		} /* fim ativa: Testar GRA Inserir vértice no início da lista de origens */

		/* Testar GRA Definir corrente */

		else if(strcmp (ComandoTeste, DEFINIR_CORR_GRA_CMD ) == 0)
		{

			NumLidos = LER_LerParametros ( "ici" , &inxGrafo , &ValorDado , &CondRetEsperada );

			if(NumLidos != 3){
				return TST_CondRetParm;
			}

			CondRetObtido = GRA_DefinirCorrente( vtGrafo[ inxGrafo ] , ValorDado);

			return TST_CompararInt( CondRetEsperada , CondRetObtido ,
                                    "Retorno errado ao definir corrente" );

		} /* fim ativa: Testar GRA Inserir vértice no início da lista de origens */

		/* Testar GRA Destruir Grafo */

		else if(strcmp (ComandoTeste, DESTRUIR_GRA_CMD ) == 0)
		{

			NumLidos = LER_LerParametros ( "ii" , &inxGrafo , &CondRetEsperada );

			if(NumLidos != 2){
				return TST_CondRetParm;
			}

			CondRetObtido = GRA_DestruirGrafo( vtGrafo[ inxGrafo ]);

			vtGrafo[ inxGrafo ] = NULL;

			return TST_CompararInt( CondRetEsperada , CondRetObtido ,
                                    "Retorno errado ao destruir grafo!" );

		} /* fim ativa: Testar GRA Destruir Grafo */
		
		/* Testar VerificarMemoria */
            #ifdef _DEBUG
                    else if ( strcmp( ComandoTeste , VER_MEMO_GRA_CMD ) == 0 )
                    {
                        CED_ExibirTodosEspacos( CED_ExibirTodos ) ;        
                        return TST_CondRetOK ;

                    } /* fim ativa: VerificarMemoria */
            #endif 

			/* Verificacao do Grafo */
		  #ifdef _DEBUG
			 else if ( strcmp( ComandoTeste , VERIFICAR_GRA_CMD ) == 0 )
			 {
				 NumLidos = LER_LerParametros( "ii" , &inxGrafo , &CondRetEsperada ) ;

				if ( ( NumLidos != 2 ) || ( inxGrafo < 0 ) || ( inxGrafo >= DIM_VT_GRAFO ))
				{
				   return TST_CondRetParm ;
				} /* if */
				
				CondRetObtido = GRA_VerificarGrafo( vtGrafo[ inxGrafo ] );

				return TST_CompararInt( CondRetEsperada , CondRetObtido ,
                                    "Retorno errado ao verificar grafo" );

			 } /* fim ativa: Verificacao do Grafo */
		   #endif 
				
				/* Testar Deturpar */
		  #ifdef _DEBUG
			 else if ( strcmp( ComandoTeste , DETURPAR_GRA_CMD ) == 0 )
			 {
				NumLidos = LER_LerParametros( "iii" , &inxGrafo, &indDeturpa , &CondRetEsperada ) ;

				if ( ( NumLidos != 3 )
				  || ( inxGrafo < 0 ) || ( inxGrafo >= DIM_VT_GRAFO ))
				{
				   return TST_CondRetParm ;
				} /* if */

				CondRetObtido = GRA_DeturparGrafo ( vtGrafo[ inxGrafo ], (GRA_tpTiposDeturpacao)indDeturpa ) ; 

				return TST_CompararInt( CondRetEsperada , CondRetObtido ,
                                    "Retorno errado ao verificar grafo" );

			 } /* fim ativa: Deturpar */
		   #endif


      return TST_CondRetNaoConhec ;

   } /* Fim função: TGRA Efetuar operações de teste específicas para grafo */
Пример #3
0
TST_tpCondRet TST_EfetuarComando( char * ComandoTeste )
{

    int inxGrafo  = -1 ,
        numLidos   = -1 ,
        CondRetEsp = -1 ,
        param, numErros;

    char idVertice;
    char idVertice2;

    char StringDado[ DIM_VALOR ];

    VER_tppVertice novoVertice;

    TST_tpCondRet CondRet ;

    void * pDado ;

    char * pValor;

    /* Testar criar Grafo */
    if ( strcmp( ComandoTeste , CRIAR_GRAFO_CMD  ) == 0 ) {

        numLidos = LER_LerParametros( "ii" , &inxGrafo, &CondRetEsp ) ;

        if ( ( numLidos != 2 ) || ( ValidarInxGrafo( inxGrafo , NAO_VAZIO ) ) )
        {
            return TST_CondRetParm ;
        } /* if */

        CondRet = GRA_CriarGrafo( &vtGRAFO[ inxGrafo ], DestruirValor );

        return TST_CompararInt( CondRetEsp , CondRet ,
                                "Condicao de retorno errada ao criar grafo."  ) ;

    } /* fim ativa: Testar criar Grafo */

    /* Testar destruir Grafo */
    else if ( strcmp( ComandoTeste , DESTRUIR_GRAFO_CMD  ) == 0 ) {

        numLidos = LER_LerParametros( "ii" , &inxGrafo, &CondRetEsp ) ;

        if ( ( numLidos != 2 ) || ( ValidarInxGrafo( inxGrafo , VAZIO ) ) )
        {
            return TST_CondRetParm ;
        } /* if */

        CondRet = GRA_DestruirGrafo( vtGRAFO[ inxGrafo ] );

        vtGRAFO[ inxGrafo ] = NULL;

        return TST_CompararInt( CondRetEsp , CondRet ,
                                "Condicao de retorno errada ao destruir grafo."  ) ;

    } /* fim ativa: Testar destruir Grafo */

    /* Testar esvaziar Grafo */
    else if ( strcmp( ComandoTeste , ESV_GRAFO_CMD  ) == 0 ) {

        numLidos = LER_LerParametros( "ii" , &inxGrafo, &CondRetEsp ) ;

        if ( ( numLidos != 2 ) || (ValidarInxGrafo( inxGrafo , VAZIO ) ) )
        {
            return TST_CondRetParm ;
        } /* if */

        CondRet = GRA_EsvaziarGrafo( vtGRAFO[ inxGrafo ] );

        return TST_CompararInt( CondRetEsp , CondRet ,
                                "Condicao de retorno errada ao esvaziar grafo."  ) ;

    } /* fim ativa: Testar esvaziar Grafo */

    /* Testar obter vertice corrente em Grafo */
    else if ( strcmp( ComandoTeste , CORR_GRAFO_CMD  ) == 0 ) {

        numLidos = LER_LerParametros( "isi" , &inxGrafo, StringDado, &CondRetEsp ) ;

        if ( ( numLidos != 3 ) || ( ValidarInxGrafo( inxGrafo , VAZIO ) ) )
        {
            return TST_CondRetParm ;
        } /* if */


        CondRet = GRA_ObterValorCorrente( vtGRAFO[ inxGrafo ], &novoVertice );

        if(CondRet != GRA_CondRetOK)
            return TST_CompararInt( CondRetEsp , CondRet ,
                                    "Condicao de retorno errada ao obter valor corrente."  ) ;

        VER_ObterValor( novoVertice, &pValor);

        return TST_CompararString( StringDado , pValor ,
                                   "Retorno errado ao obter valor corrente."  ) ;

    } /* fim ativa: Testar obter vertice corrente em Grafo */

    /* Testar alterar vertice corrente em Grafo */
    else if ( strcmp( ComandoTeste , ALTCORR_GRAFO_CMD  ) == 0 ) {

        numLidos = LER_LerParametros( "isi" , &inxGrafo, StringDado, &CondRetEsp ) ;

        if ( ( numLidos != 3 ) || ( ValidarInxGrafo( inxGrafo , VAZIO ) ) )
        {
            return TST_CondRetParm ;
        } /* if */

        VER_CriarVertice( &novoVertice );

#ifdef _DEBUG
        CED_DefinirTipoEspaco( novoVertice, ID_VER_tppVertice );
#endif

        VER_AtribuirValor( novoVertice, StringDado ) ;

        CondRet = GRA_AlterarValorCorrente( vtGRAFO[ inxGrafo ], novoVertice );

        if(CondRet != GRA_CondRetOK)
            VER_DestruirVertice(novoVertice);

        return TST_CompararInt( CondRetEsp , CondRet ,
                                "Condicao de retorno errada ao alterar corrente."  ) ;

    } /* fim ativa: Testar alterar vertice corrente em Grafo */

    /* Testar alterar vertice corrente para null em Grafo */
    else if ( strcmp( ComandoTeste , ALTCORRNULL_GRAFO_CMD  ) == 0 ) {

        numLidos = LER_LerParametros( "ii" , &inxGrafo, &CondRetEsp ) ;

        if ( ( numLidos != 2 ) || ( ValidarInxGrafo( inxGrafo , VAZIO ) ) )
        {
            return TST_CondRetParm ;
        } /* if */


        CondRet = GRA_AlterarValorCorrente( vtGRAFO[ inxGrafo ], NULL );

        return TST_CompararInt( CondRetEsp , CondRet ,
                                "Condicao de retorno errada ao alterar corrente."  ) ;

    } /* fim ativa: Testar alterar vertice corrente em Grafo */

    /* Testar ir para vertice em Grafo */
    else if ( strcmp( ComandoTeste , IRVER_GRAFO_CMD  ) == 0 ) {

        numLidos = LER_LerParametros( "ici" , &inxGrafo, &idVertice, &CondRetEsp ) ;

        if ( ( numLidos != 3 ) || ( ValidarInxGrafo( inxGrafo , VAZIO ) ) )
        {
            return TST_CondRetParm ;
        } /* if */

        CondRet = GRA_IrParaVertice( vtGRAFO[ inxGrafo ], idVertice );

        return TST_CompararInt( CondRetEsp , CondRet ,
                                "Condicao de retorno errada ao ir para vertice."  ) ;

    } /* fim ativa: Testar ir para vertice em Grafo */

    /* Testar andar para vertice em Grafo */
    else if ( strcmp( ComandoTeste , ANDARVER_GRAFO_CMD  ) == 0 ) {

        numLidos = LER_LerParametros( "ici" , &inxGrafo, &idVertice, &CondRetEsp ) ;

        if ( ( numLidos != 3 ) || ( ValidarInxGrafo( inxGrafo , VAZIO ) ) )
        {
            return TST_CondRetParm ;
        } /* if */

        CondRet = GRA_AndarParaVertice( vtGRAFO[ inxGrafo ], idVertice );

        return TST_CompararInt( CondRetEsp , CondRet ,
                                "Condicao de retorno errada ao andar para vertice."  ) ;

    } /* fim ativa: Testar andar para vertice em Grafo */

    /* Testar inserir vertice em Grafo */
    else if ( strcmp( ComandoTeste , INSVER_GRAFO_CMD  ) == 0 ) {

        numLidos = LER_LerParametros( "isci" , &inxGrafo, StringDado, &idVertice, &CondRetEsp ) ;

        if ( ( numLidos != 4 ) || ( ValidarInxGrafo( inxGrafo , VAZIO ) ) )
        {
            return TST_CondRetParm ;
        } /* if */

        VER_CriarVertice( &novoVertice );

#ifdef _DEBUG
        CED_EhEspacoAtivo( novoVertice );
        CED_DefinirTipoEspaco( novoVertice, ID_VER_tppVertice );
#endif

        VER_AtribuirValor( novoVertice, StringDado ) ;

        CondRet = GRA_InserirVertice( vtGRAFO[ inxGrafo ], novoVertice, idVertice );

        return TST_CompararInt( CondRetEsp , CondRet ,
                                "Condicao de retorno errada ao inserir vertice."  ) ;

    } /* fim ativa: Testar inserir vertice em Grafo */

    /* Testar inserir vertice de valor null em Grafo */
    else if ( strcmp( ComandoTeste , INSVERNULL_GRAFO_CMD  ) == 0 ) {

        numLidos = LER_LerParametros( "ici" , &inxGrafo, &idVertice, &CondRetEsp ) ;

        if ( ( numLidos != 3 ) || ( ValidarInxGrafo( inxGrafo , VAZIO ) ) )
        {
            return TST_CondRetParm ;
        } /* if */

        CondRet = GRA_InserirVertice( vtGRAFO[ inxGrafo ], NULL, idVertice );

        return TST_CompararInt( CondRetEsp , CondRet ,
                                "Condicao de retorno errada ao inserir vertice."  ) ;

    } /* fim ativa: Testar inserir vertice de valor null em Grafo */

    /* Testar excluir vertice corrente em Grafo */
    else if ( strcmp( ComandoTeste , EXCCORR_GRAFO_CMD  ) == 0 ) {

        numLidos = LER_LerParametros( "ii" , &inxGrafo,  &CondRetEsp) ;

        if ( ( numLidos != 2 ) || ( ValidarInxGrafo( inxGrafo , VAZIO ) ) )
        {
            return TST_CondRetParm ;
        } /* if */

        CondRet = GRA_ExcluirVerticeCorrente( vtGRAFO[ inxGrafo ] );

        return TST_CompararInt( CondRetEsp , CondRet ,
                                "Condicao de retorno errada ao excluir vertice corrente."  ) ;

    } /* fim ativa: Testar excluir vertice corrente em Grafo */

    /* Testar inserir aresta em Grafo */
    else if ( strcmp( ComandoTeste , INSAR_GRAFO_CMD  ) == 0 ) {

        numLidos = LER_LerParametros( "iccsi" , &inxGrafo, &idVertice, &idVertice2, StringDado, &CondRetEsp) ;

        if ( ( numLidos != 5 ) || ( ValidarInxGrafo( inxGrafo , VAZIO ) ) )
        {
            return TST_CondRetParm ;
        } /* if */

        CondRet = GRA_InserirAresta( vtGRAFO[ inxGrafo ], idVertice, idVertice2, StringDado );

        return TST_CompararInt( CondRetEsp , CondRet ,
                                "Condicao de retorno errada ao inserir aresta."  ) ;

    } /* fim ativa: Testar inserir aresta em Grafo */

    /* Testar inserir aresta em origem no Grafo */
    else if ( strcmp( ComandoTeste , INSARO_GRAFO_CMD  ) == 0 ) {

        numLidos = LER_LerParametros( "icsi" , &inxGrafo, &idVertice, StringDado, &CondRetEsp) ;

        if ( ( numLidos != 4 ) || ( ValidarInxGrafo( inxGrafo , VAZIO ) ) )
        {
            return TST_CondRetParm ;
        } /* if */

        CondRet = GRA_InserirArestaOrigemCorrente( vtGRAFO[ inxGrafo ], idVertice, StringDado );

        return TST_CompararInt( CondRetEsp , CondRet ,
                                "Condicao de retorno errada ao inserir aresta na origem corrente."  ) ;

    } /* fim ativa: Testar inserir aresta em origem no Grafo */

    /* Testar excluir aresta em Grafo */
    else if ( strcmp( ComandoTeste , EXCAR_GRAFO_CMD  ) == 0 ) {

        numLidos = LER_LerParametros( "isi" , &inxGrafo, StringDado, &CondRetEsp) ;

        if ( ( numLidos != 3 ) || ( ValidarInxGrafo( inxGrafo , VAZIO ) ) )
        {
            return TST_CondRetParm ;
        } /* if */

        CondRet = GRA_ExcluirAresta( vtGRAFO[ inxGrafo ], StringDado );

        return TST_CompararInt( CondRetEsp , CondRet ,
                                "Condicao de retorno errada ao excluir aresta."  ) ;

    } /* fim ativa: Testar excluir aresta em Grafo */

    /* Testar adicionar origem em Grafo */
    else if ( strcmp( ComandoTeste , ADDOR_GRAFO_CMD  ) == 0 ) {

        numLidos = LER_LerParametros( "ici" , &inxGrafo, &idVertice, &CondRetEsp) ;

        if ( ( numLidos != 3 ) || ( ValidarInxGrafo( inxGrafo , VAZIO ) ) )
        {
            return TST_CondRetParm ;
        } /* if */

        CondRet = GRA_AdicionarOrigem( vtGRAFO[ inxGrafo ], idVertice );

        return TST_CompararInt( CondRetEsp , CondRet ,
                                "Condicao de retorno errada ao adicionar origem."  ) ;

    } /* fim ativa: Testar adicionar origem em Grafo */

    /* Testar remover origem em Grafo */
    else if ( strcmp( ComandoTeste , RMVOR_GRAFO_CMD  ) == 0 ) {

        numLidos = LER_LerParametros( "ici" , &inxGrafo, &idVertice, &CondRetEsp) ;

        if ( ( numLidos != 3 ) || ( ValidarInxGrafo( inxGrafo , VAZIO ) ) )
        {
            return TST_CondRetParm ;
        } /* if */

        CondRet = GRA_RemoverOrigem( vtGRAFO[ inxGrafo ], idVertice );

        return TST_CompararInt( CondRetEsp , CondRet ,
                                "Condicao de retorno errada ao remover origem."  ) ;

    } /* fim ativa: Testar remover origem em Grafo */

#ifdef _DEBUG
    /* Realizar deturpacao */
    else if ( strcmp( ComandoTeste , DETURPAR_GRAFO_CMD  ) == 0 ) {

        numLidos = LER_LerParametros( "ii" , &inxGrafo, &param) ;

        if ( ( numLidos != 2 ) || ( ValidarInxGrafo( inxGrafo , VAZIO ) ) )
        {
            return TST_CondRetParm ;
        } /* if */

        return TST_CompararInt( GRA_CondRetOK , GRA_Deturpar(vtGRAFO[ inxGrafo ], param),
                                "Erro ao deturpar."  ) ;

    } /* fim ativa: Realizar deturpacao */

    /* Realizar verificao estrututral */
    else if ( strcmp( ComandoTeste , VERIFICAR_GRAFO_CMD  ) == 0 ) {

        numLidos = LER_LerParametros( "ii" , &inxGrafo, &param) ;

        if ( ( numLidos != 2 ) || ( ValidarInxGrafo( inxGrafo , VAZIO ) ) )
        {
            return TST_CondRetParm ;
        } /* if */

        GRA_VerificarEstrutura( vtGRAFO[ inxGrafo ], &numErros );

        return TST_CompararInt( param , numErros ,
                                "Total de erros errado ao verificar estrutura."  ) ;

    } /* fim ativa: Realizar verificao estrututral */

#endif

} /* Fim função: TGRA &Testar grafo */