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

	  int indice,
		  numLidos = -1,
		  CondRetEsp = -1,
		  indicePeca,
		  casa,
		  passos,
		  quantidadePecasEsp,
		  quantidadePecas;

	  void *valorPeca;

	  int * pecaRecebida;
	  int * vtPeca[10];

	  TST_tpCondRet Ret;

	  for (indice = 0; indice < 10; indice++){

		  vtPeca[indice] = (int*)malloc(sizeof(int));
		  if (vtPeca == NULL)
		  {
			  return TST_CondRetMemoria;

		  } /* if */

		  *vtPeca[indice] = indice;
		  

	  } /* for */

      TAB_tpCondRet CondRet ;

      /* testar criar um tabuleiro */

         if ( strcmp( ComandoTeste , CRIAR_TABULEIRO_CMD ) == 0 )
         {
			 numLidos = LER_LerParametros( "i" ,
                       &CondRetEsp) ;

            if  ( numLidos != 1 ) {
               return TST_CondRetParm ;
            } /* if */

			CondRet = TAB_CriarTabuleiro(&pTabuleiro);

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

         } /* Fim ativa: Testar criar um tabuleiro */

      /* Testar destruir um tabuleiro */

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

            numLidos = LER_LerParametros( "i" ,
                       &CondRetEsp) ;

            if (  numLidos != 1 ) {
               return TST_CondRetParm ;
            } /* if */

			CondRet = TAB_DestruirTabuleiro(&pTabuleiro);

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

         } /* Fim ativa: Testar destruir tabuleiro  */

	  /* Testar inserir peca */

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

			 numLidos = LER_LerParametros("iii",
				 &indicePeca, &casa, &CondRetEsp);

			 if (numLidos != 3) {
				 return TST_CondRetParm;
			 } /* if */

			 CondRet = TAB_InserirPeca(&pTabuleiro, vtPeca[indicePeca], casa);

			 if (CondRet != TAB_CondRetOK)
				 free(vtPeca[indicePeca]);

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

		 } /* Fim ativa: Testar inserir peca  */

	  /* Testar retirar peca */

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

			 numLidos = LER_LerParametros("iii",
				 &indicePeca, &casa, &CondRetEsp);

			 if (numLidos != 3) {
				 return TST_CondRetParm;
			 } /* if */

			 CondRet = TAB_RetirarPeca(&pTabuleiro, &valorPeca, casa);

			 Ret = TST_CompararInt(CondRetEsp, CondRet,
				 "Condicao de retorno errada ao retirar peca.");

			 if (Ret != TST_CondRetOK)
				 return Ret;

			 pecaRecebida = (int *)valorPeca;

			 Ret = TST_CompararInt(*vtPeca[indicePeca], *pecaRecebida, "peca recebida errada");

			 free(pecaRecebida);

			 return Ret;

		 } /* Fim ativa: Testar retirar peca  */

	  /* Testar mover peca */

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

			 numLidos = LER_LerParametros("iii",
				 &casa, &passos, &CondRetEsp);

			 if (numLidos != 3) {
				 return TST_CondRetParm;
			 } /* if */

			 CondRet = TAB_MoverPeca(&pTabuleiro, casa, passos);

			 return TST_CompararInt(CondRetEsp, CondRet,
				 "Condicao de retorno errada ao mover peca.");

		 } /* Fim ativa: Testar mover peca  */

	  /* Testar quantidade peca */

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

			 numLidos = LER_LerParametros("iii",
				 &casa, &quantidadePecasEsp, &CondRetEsp);

			 if (numLidos != 3) {
				 return TST_CondRetParm;
			 } /* if */

			 CondRet =TAB_QuantidadePecasCasa(pTabuleiro, casa, &quantidadePecas);

			 Ret = TST_CompararInt(CondRetEsp, CondRet,
				 "Condicao de retorno errada ao contar peca.");

			 if (Ret != TST_CondRetOK)
				 return Ret;

			 return TST_CompararInt(quantidadePecasEsp, quantidadePecas, "numero de pecas errado");

		 } /* Fim ativa: Testar quantidade peca  */

		 /* Liberar espaco alocado teste */

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

			 for (indice = 0; indice < 10; indice++)
				 free(vtPeca[indice]);

			 return TST_CondRetOK;

		 } /* Fim ativa: Liberar espaco alocado teste  */

      return TST_CondRetNaoConhec ;

   } /* Fim função: TTAB &Testar tabuleiro */
Пример #2
0
TST_tpCondRet TST_EfetuarComando( char *ComandoTeste )
{

    int inxTab  = -1 ,
        numLidos   = -1 ;

    short int tamColuna = -1 ,
              tamLinha  = -1 ,
              Coluna    = -1 ,
              Linha     = -1 ,
              ColunaDest = -1,
              LinhaDest  = -1;

    PECA_tpCor cor;

    TAB_tpTamanho tam;
    TAB_tpPosicao pos,
                  posOrigem,
                  posDestino;
    TAB_tpCondRet condEsp;
    TAB_tpCondRet tabCondRet;

    PECA_tppPeca pDado ;
    int valEsp = -1 ;

#ifdef _DEBUG
    TAB_tpModoDeturpacao modoDeturpacao;
#endif

    int i ;

    /* Efetuar reset de teste de tabuleiro */

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

        for ( i = 0 ; i < DIM_VT_TABULEIRO ; i++ )
        {
            vtTab[ i ] = NULL ;
        } /* for */

        return TST_CondRetOK ;

    } /* fim ativa: Efetuar reset de teste de tabuleiro */

    /* Testar Criar Tabuleiro */

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

        numLidos = LER_LerParametros( "iiii" ,
                                      &inxTab, &tamColuna, &tamLinha, &valEsp ) ;

        if ( ( numLidos != 4 )
                || ( ! ValidarInxTabuleiro( inxTab )))
        {
            return TST_CondRetParm ;
        }

        vtTab[ inxTab ] =
            TAB_CriarTabuleiro( tamColuna, tamLinha, DestruirPeca ) ;

        return TST_CompararPonteiroNulo( 1 , vtTab[ inxTab ] ,
                                         "Erro em ponteiro de nova tabuleiro."  ) ;

    } /* fim ativa: Testar CriarTabuleiro */

    /* Testar Destruir Tabuleiro  */

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

        numLidos = LER_LerParametros( "i" ,
                                      &inxTab ) ;

        if ( ( numLidos != 1 )
                || ( ! ValidarInxTabuleiro( inxTab )))
        {
            return TST_CondRetParm ;
        }

        TAB_DestruirTabuleiro( vtTab[ inxTab ] ) ;
        vtTab[ inxTab ] = NULL;

        return TST_CondRetOK ;

    } /* fim ativa: Testar Destruir Tabuleiro*/

    /* Testar Obter Tamanho */

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

        numLidos = LER_LerParametros( "iii" ,
                                      &inxTab, &tamColuna, &tamLinha ) ;

        if ( ( numLidos != 3 )
                || ( ! ValidarInxTabuleiro( inxTab )))
        {
            return TST_CondRetParm ;
        }

        tam = TAB_ObterTamanho( vtTab[ inxTab ] ) ;
        if ((tam.colunas == tamColuna) && (tam.linhas == tamLinha))
            return TST_CondRetOK ;
        return TST_CondRetErro;

    } /* fim ativa: Testar Obter Tamanho */

    /* Testar Incluir Peca */
    else if ( strcmp( ComandoTeste , INCLUIR_PECA_CMD ) == 0 )
    {

        numLidos = LER_LerParametros( "iiiii" ,
                                      &inxTab , &Coluna, &Linha, &cor , &condEsp ) ;

        if ( ( numLidos != 5 )
                || ( ! ValidarInxTabuleiro( inxTab )) )
        {
            return TST_CondRetParm ;
        }

        pDado = (PECA_tppPeca) PECA_CriarPeca (cor) ;
        if ( pDado == NULL )
        {
            return TST_CondRetMemoria ;
        }

        pos.coluna = Coluna;
        pos.linha = Linha;
        tabCondRet = TAB_IncluirPeca( vtTab[ inxTab ] , pDado , pos) ;

        if ( tabCondRet != TAB_CondRetOK )
        {
            PECA_DestruirPeca(pDado) ;
        }

        return TST_CompararInt( condEsp , tabCondRet ,
                                "Condicao de retorno errada ao incluir peca no tabuleiro." ) ;

    } /* fim ativa: Testar Incluir Peca*/
    /* Testar Mover Peça*/
    else if ( strcmp( ComandoTeste , MOVER_PECA_CMD ) == 0 )
    {

        numLidos = LER_LerParametros( "iiiiii" ,
                                      &inxTab , &Coluna, &Linha, &ColunaDest , &LinhaDest, &condEsp ) ;

        if ( ( numLidos != 6 )
                || ( ! ValidarInxTabuleiro( inxTab )) )
        {
            return TST_CondRetParm ;
        }


        posOrigem.coluna = Coluna;
        posOrigem.linha = Linha;
        posDestino.coluna = ColunaDest;
        posDestino.linha = LinhaDest;
        tabCondRet = TAB_MoverPeca( vtTab[ inxTab ] , posOrigem , posDestino) ;


        return TST_CompararInt( condEsp , tabCondRet ,
                                "Condicao de retorno errada ao mover a peca no tabuleiro." ) ;

    } /* fim ativa: Testar Mover Peca*/
    /* Testar Obter Peca */
    else if ( strcmp( ComandoTeste , OBTER_PECA_CMD ) == 0 )
    {

        numLidos = LER_LerParametros( "iiii" ,
                                      &inxTab , &Coluna, &Linha, &valEsp ) ;

        if ( ( numLidos != 4  )
                || ( ! ValidarInxTabuleiro( inxTab )) )
        {
            return TST_CondRetParm ;
        }

        pos.coluna = Coluna;
        pos.linha = Linha;
        pDado = (PECA_tppPeca) TAB_ObterPeca( vtTab[ inxTab ] , pos) ;

        if ( valEsp == 0 )
        {
            return TST_CompararPonteiroNulo( 0, pDado,
                                             "Peça não devia existir");
        }

        if ( pDado == NULL)
        {
            return TST_CompararPonteiroNulo( 1, pDado,
                                             "Peça deveria existir");
        }
        return TST_CondRetOK;

    } /* fim ativa: Testar Obter Peca*/
    /* Testar Destruir Peca */
    else if ( strcmp( ComandoTeste , DESTRUIR_PECA_CMD ) == 0 )
    {

        numLidos = LER_LerParametros( "iiii" ,
                                      &inxTab , &Coluna, &Linha, &condEsp ) ;

        if ( ( numLidos != 4 )
                || ( ! ValidarInxTabuleiro( inxTab )) )
        {
            return TST_CondRetParm ;
        }

        pos.coluna = Coluna;
        pos.linha = Linha;
        tabCondRet = TAB_DestruirPeca( vtTab[ inxTab ] , pos) ;

        return TST_CompararInt( condEsp , tabCondRet ,
                                "Condicao de retorno errada ao excluir peca do tabuleiro." ) ;

    } /* fim ativa: Testar Destruir Peca*/
    /* Testar Remover Peca */
    else if ( strcmp( ComandoTeste , REMOVER_PECA_CMD ) == 0 )
    {

        numLidos = LER_LerParametros( "iiii" ,
                                      &inxTab , &Coluna, &Linha, &valEsp ) ;

        if ( ( numLidos != 4  )
                || ( ! ValidarInxTabuleiro( inxTab )) )
        {
            return TST_CondRetParm ;
        }

        pos.coluna = Coluna;
        pos.linha = Linha;
        pDado = (PECA_tppPeca) TAB_RemoverPeca( vtTab[ inxTab ] , pos) ;

        if ( valEsp == 0 )
        {
            return TST_CompararPonteiroNulo( 0, pDado, "Peça não devia existir");
        }

        if ( pDado == NULL )
        {
            return TST_CompararPonteiroNulo( 1, pDado, "Peça deveria existir");
        }
        return TST_CondRetOK;

    } /* fim ativa: Testar Remover Peca*/

    /* Início instrumentação */
    #ifdef _DEBUG
    /* Testar verificador de tabuleiro */
    else if ( strcmp( ComandoTeste, VERIFICAR_TABULEIRO_CMD ) == 0 )
    {
        numLidos = LER_LerParametros( "ii",
                                      &inxTab, &condEsp ) ;
        if ( ( numLidos != 2 )
            || !ValidarInxTabuleiro( inxTab ))
        {
            return TST_CondRetParm;
        }

        return TST_CompararInt( condEsp ,
                                TAB_VerificarTabuleiro( vtTab[ inxTab ] ) ,
                                "Retorno incorreto ao verificar tabuleiro") ;
    } /* fim ativa: Testar verificador de tabuleiro */
    /* Deturpar um tabuleiro */
    else if ( strcmp( ComandoTeste, DETURPAR_CMD ) == 0 )
    {
        numLidos = LER_LerParametros( "ii" ,
                                       &inxTab , &modoDeturpacao ) ;
        if ( ( numLidos != 2 )
             || !ValidarInxTabuleiro( inxTab ))
        {
            return TST_CondRetParm;
        }

        TAB_Deturpar( vtTab [ inxTab ] , modoDeturpacao ) ;

        return TST_CondRetOK ;
    } /* fim ativa: Deturpar um tabuleiro */
    /* Verificar vazamento de memória */
    else if ( strcmp( ComandoTeste, VERIFICAR_MEMORIA_CMD ) == 0 )
    {
        CED_ExibirTodosEspacos( CED_ExibirTodos ) ;

        return TST_CondRetOK ;
    } /* fim ativa: Verificar vazamento de memória */
    #endif
    /* Fim instrumentação */

    return TST_CondRetNaoConhec ;

} /* Fim função: TTAB &Testar tabuleiro */