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 */
TST_tpCondRet TST_EfetuarComando( char * ComandoTeste ) { int NumLidos = -1 ; int IntEsperado, IntObtido ; char CharEsperado, CharObtido ; long LongEsperado, LongObtido ; double FloatEsperado , FloatObtido , Tolerancia ; char StringEsperado[ 250 ] , StringObtido[ 250 ] ; char EspacEsperado[ 100 ] ; char EspacObtido[ 100 ] ; /* Testar Booleano */ if ( strcmp( ComandoTeste , BOOL_CMD ) == 0 ) { NumLidos = LER_LerParametros( "ii" , &IntEsperado , &IntObtido ) ; if ( NumLidos != 2 ) { return TST_CondRetParm ; } /* if */ return TST_CompararBool( IntEsperado , IntObtido , "Booleanos não são iguais." ) ; } /* fim ativa: Testar Booleano */ /* Testar caractere */ else if ( strcmp( ComandoTeste , CHAR_CMD ) == 0 ) { NumLidos = LER_LerParametros( "cc" , &CharEsperado , &CharObtido ) ; if ( NumLidos != 2 ) { return TST_CondRetParm ; } /* if */ return TST_CompararChar( CharEsperado , CharObtido , "Caracteres não são iguais." ) ; } /* fim ativa: Testar caractere */ /* Testar inteiro normal */ else if ( strcmp( ComandoTeste , INT_CMD ) == 0 ) { NumLidos = LER_LerParametros( "ii" , &IntEsperado , &IntObtido ) ; if ( NumLidos != 2 ) { return TST_CondRetParm ; } /* if */ return TST_CompararInt( IntEsperado , IntObtido , "Inteiros não são iguais." ) ; } /* fim ativa: Testar inteiro normal */ /* Testar inteiro longo */ else if ( strcmp( ComandoTeste , LONG_CMD ) == 0 ) { NumLidos = LER_LerParametros( "ii" , &LongEsperado , &LongObtido ) ; if ( NumLidos != 2 ) { return TST_CondRetParm ; } /* if */ return TST_CompararInt( LongEsperado , LongObtido , "Inteiros longos não são iguais." ) ; } /* fim ativa: Testar inteiro longo */ /* Testar flutuante */ else if ( strcmp( ComandoTeste , FLOAT_CMD ) == 0 ) { NumLidos = LER_LerParametros( "fff" , &FloatEsperado , &FloatObtido , &Tolerancia ) ; if ( NumLidos != 3 ) { return TST_CondRetParm ; } /* if */ return TST_CompararFloat( FloatEsperado , FloatObtido , Tolerancia , "Flutuantes fora da tolerância." ) ; } /* fim ativa: Testar flutuante */ /* Testar string */ else if ( strcmp( ComandoTeste , STRING_CMD ) == 0 ) { NumLidos = LER_LerParametros( "ss" , StringEsperado , StringObtido ) ; if ( NumLidos != 2 ) { return TST_CondRetParm ; } /* if */ return TST_CompararString( StringEsperado , StringObtido , "Strings não são iguais." ) ; } /* fim ativa: Testar string */ /* Testar acesso a espaços */ else if ( strcmp( ComandoTeste , ESPAC_CMD ) == 0 ) { NumLidos = LER_LerParametros( "ss" , EspacEsperado , EspacObtido ) ; if ( NumLidos != 2 ) { return TST_CondRetParm ; } /* if */ if ( EspacEsperado[ 0 ] == '.' ) /* gera string vazio */ { EspacEsperado[ 0 ] = 0 ; } /* if */ if ( EspacObtido[ 0 ] == '.' ) /* gera string com algum lixo */ { memcpy( EspacObtido , &NumLidos , 20 ) ; /* força espaco errado contendo resíduo da pilha */ } /* if */ return TST_CompararEspaco( EspacEsperado , EspacObtido , strlen( EspacEsperado ) , "Espaços não são iguais." ) ; } /* fim ativa: Testar acesso a espaços */ return TST_CondRetNaoConhec ; } /* Fim função: TGEN &Testar módulo TesteGen */
TST_tpCondRet TST_EfetuarComando(char *ComandoTeste) { int inxLista = -1; int numLidos = -1; int CondRetEsp = -1; char StringDado[DIM_VALOR]; int i; int CondRet; int tipo = -1; int caracter = -1; StringDado[0] = 0; /* Efetuar reset de teste de peca */ if(strcmp(ComandoTeste, RESET_PECA_CMD) == 0) { for(i = 0; i < DIM_VT_PECA; i++) vtPecas[i] = NULL; return TST_CondRetOK; } /* fim ativa: Efetuar reset de teste de lista */ /* Testar Criar peca */ else if(strcmp(ComandoTeste, CRIAR_PECA_CMD) == 0) { numLidos = LER_LerParametros("iis", &inxLista, &tipo, StringDado); if((numLidos != 3) || (!ValidarInxPeca(inxLista, VAZIO))) return TST_CondRetParm; vtPecas[inxLista] = PEC_criar(tipo, StringDado[0]); return TST_CompararPonteiroNulo(1, vtPecas[inxLista], "Erro em ponteiro de nova peca."); } /* fim ativa: Testar Criar peca */ /* Testar Destruir peca*/ else if(strcmp(ComandoTeste, DESTRUIR_PECA_CMD) == 0) { numLidos = LER_LerParametros("ii", &inxLista, &CondRetEsp); if((numLidos != 2) || (!ValidarInxPeca(inxLista, INDIFERENTE))) return TST_CondRetParm; CondRet = PEC_destruir(vtPecas[inxLista]); vtPecas[inxLista] = NULL; return TST_CompararInt(CondRetEsp, CondRet, "Condicao de retorno errada ao destruir a peca.") ; } /* fim ativa: Testar Destruir peca */ /* Testar Obter Tipo da peca*/ else if(strcmp(ComandoTeste, OBTER_TIPO_CMD) == 0) { numLidos = LER_LerParametros("ii", &inxLista, &CondRetEsp); if((numLidos != 2) || (!ValidarInxPeca(inxLista, NAO_VAZIO))) return TST_CondRetParm; tipo = PEC_obterTipo(vtPecas[inxLista]); return TST_CompararInt(CondRetEsp, tipo, "Tipo errado ao obter tipo."); } /* fim ativa: Testar Obter Tipo da peca */ /* Testar Setar Tipo da peca*/ else if(strcmp(ComandoTeste, SETAR_TIPO_CMD) == 0) { numLidos = LER_LerParametros("iii", &inxLista, &tipo, &CondRetEsp); if((numLidos != 3) || (!ValidarInxPeca(inxLista, INDIFERENTE))) return TST_CondRetParm; CondRet = PEC_setarTipo(vtPecas[inxLista], tipo); return TST_CompararInt(CondRetEsp, CondRet, "Condicao de retorno errada ao setar tipo da peca."); } /* fim ativa: Testar Setar Tipo da peca */ /* Testar Obter Caracter da peca*/ else if(strcmp(ComandoTeste, OBTER_CARACTER_CMD) == 0) { numLidos = LER_LerParametros("is", &inxLista, StringDado); if((numLidos != 2) || (!ValidarInxPeca(inxLista, NAO_VAZIO))) return TST_CondRetParm; caracter = PEC_obterCaracter(vtPecas[inxLista]); return TST_CompararEspaco(StringDado, &caracter, 1, "Caracter errado ao obter caracter."); } /* fim ativa: Testar Obter Caracter da peca */ /* Testar Setar Caracter da peca*/ else if(strcmp(ComandoTeste, SETAR_CARACTER_CMD) == 0) { numLidos = LER_LerParametros("isi", &inxLista, StringDado, &CondRetEsp); if((numLidos != 3) || (!ValidarInxPeca(inxLista, INDIFERENTE))) return TST_CondRetParm; CondRet = PEC_setarCaracter(vtPecas[inxLista], StringDado[0]); return TST_CompararInt(CondRetEsp, CondRet, "Condicao de retorno errada ao setar caracter da peca."); } /* fim ativa: Testar Setar Caracter da peca */ return TST_CondRetNaoConhec; } /* Fim função: TPEC &Testar peca */
TST_tpCondRet TST_EfetuarComando( char * ComandoTeste ) { int i ; int numLidos = -1 ; int inxEspaco = -1 ; int valEsperado = -1 ; int valObtido = -1 ; #define DIM_STRING_PARM 100 char StringParm[ DIM_STRING_PARM ] ; int Deslocamento ; int Valor ; int Tamanho ; int numLinhaFonte ; int idTipo ; int numAllocs = -1 , Frequencia = 0 , ContaNULL = 0 ; double Tolerancia , PercentEsperado , PercentObtido ; void * pEspaco = NULL ; InstrumentarString( StringParm , DIM_STRING_PARM ) ; /* Tratar: Reinicializar módulo de teste espeçifico */ if ( strcmp( ComandoTeste , ResetEspacosCmd ) == 0 ) { if ( EhPrimeiraVez ) { EhPrimeiraVez = FALSE ; for( i = 0 ; i < DIM_VT_ESPACO ; i ++ ) { vtEspaco[ i ] = NULL ; } /* for */ return TST_CondRetOK ; } /* if */ for( i = 0 ; i < DIM_VT_ESPACO ; i++ ) { if ( vtEspaco[ i ] != NULL ) { CED_Free( vtEspaco[ i ] ) ; vtEspaco[ i ] = NULL ; } /* if */ } /* for */ return TST_CondRetOK ; } /* fim ativa: Tratar: Reinicializar módulo de teste espeçifico */ /* Tratar: Deturpar espaço */ else if ( strcmp( ComandoTeste , DeturparEspacoCmd ) == 0 ) { numLidos = LER_LerParametros( "iii" , &inxEspaco , &Deslocamento , &Valor ) ; if ( ( numLidos != 3 ) || !VerificarInxEspaco( inxEspaco , TRUE )) { return TST_CondRetParm ; } /* if */ (( char * ) vtEspaco[ inxEspaco ] )[ Deslocamento ] = ( char ) Valor ; return TST_CondRetOK ; } /* fim ativa: Tratar: Deturpar espaço */ /* Tratar: Atribuir string ao espaço */ else if ( strcmp( ComandoTeste , InserirStringEspacoCmd ) == 0 ) { numLidos = LER_LerParametros( "is" , &inxEspaco , StringParm ) ; if ( ( numLidos != 2 ) || !VerificarInxEspaco( inxEspaco , TRUE ) || !VerificarString( StringParm , DIM_STRING_PARM )) { return TST_CondRetParm ; } /* if */ strcpy( vtEspaco[ inxEspaco ] , StringParm ) ; return TST_CondRetOK ; } /* fim ativa: Tratar: Atribuir string ao espaço */ /* Testar: Obter string contido no espaço */ else if ( strcmp( ComandoTeste , ObterStringEspacoCmd ) == 0 ) { numLidos = LER_LerParametros( "is" , &inxEspaco , StringParm ) ; if ( ( numLidos != 2 ) || !VerificarInxEspaco( inxEspaco , TRUE ) || !VerificarString( StringParm , DIM_STRING_PARM )) { return TST_CondRetParm ; } /* if */ return TST_CompararEspaco( StringParm , vtEspaco[ inxEspaco ] , strlen( StringParm ) , "Conteúdo do valor errado." ) ; } /* fim ativa: Testar: Obter string contido no espaço */ /* Testar: CED &Alocar espaço */ else if ( strcmp( ComandoTeste , AlocarEspacoCmd ) == 0 ) { numLidos = LER_LerParametros( "iiis" , &inxEspaco , &Tamanho , &numLinhaFonte , StringParm ) ; if ( ( numLidos != 4 ) || ( Tamanho <= 0 ) || ( numLinhaFonte < 1 ) || !VerificarInxEspaco( inxEspaco , FALSE ) || !VerificarString( StringParm , DIM_STRING_PARM )) { return TST_CondRetParm ; } /* if */ vtEspaco[ inxEspaco ] = CED_Malloc( Tamanho , numLinhaFonte , StringParm ) ; return TST_CondRetOK ; } /* fim ativa: Testar: CED &Alocar espaço */ /* Testar: CED &Desalocar espaço */ else if ( strcmp( ComandoTeste , DesalocarEspacoCmd ) == 0 ) { numLidos = LER_LerParametros( "i" , &inxEspaco ) ; if ( ( numLidos != 1 ) || !VerificarInxEspaco( inxEspaco , FALSE )) { return TST_CondRetParm ; } /* if */ CED_Free( vtEspaco[ inxEspaco ] ) ; vtEspaco[ inxEspaco ] = NULL ; return TST_CondRetOK ; } /* fim ativa: Testar: CED &Desalocar espaço */ /* Testar: CED &Exibir conteúdo bruto do espaço */ else if ( strcmp( ComandoTeste , ExibirEspacoBrutoCmd ) == 0 ) { #define DIM_ESPACO 70 numLidos = LER_LerParametros( "i" , &inxEspaco ) ; if ( ( numLidos != 1 ) || !VerificarInxEspaco( inxEspaco , FALSE )) { return TST_CondRetParm ; } /* if */ TST_ExibirEspacoHexa( DIM_ESPACO + 4 , (( char * ) vtEspaco[ inxEspaco ] ) - DIM_ESPACO ) ; return TST_CondRetOK ; } /* fim ativa: Testar: CED &Exibir conteúdo bruto do espaço */ /* Testar: CED &Exibir conteúdo útil do espaço */ else if ( strcmp( ComandoTeste , ExibirEspacoCmd ) == 0 ) { numLidos = LER_LerParametros( "i" , &inxEspaco ) ; if ( ( numLidos != 1 ) || !VerificarInxEspaco( inxEspaco , FALSE )) { return TST_CondRetParm ; } /* if */ CED_ExibirEspaco( vtEspaco[ inxEspaco ] ) ; return TST_CondRetOK ; } /* fim ativa: Testar: CED &Exibir conteúdo útil do espaço */ /* Testar: CED &Verificar a integridade de um espaço de dados */ else if ( strcmp( ComandoTeste , VerificarEspacoCmd ) == 0 ) { numLidos = LER_LerParametros( "ii" , &inxEspaco , &valEsperado ) ; if ( ( numLidos != 2 ) || !VerificarInxEspaco( inxEspaco , FALSE )) { return TST_CondRetParm ; } /* if */ valObtido = CED_VerificarEspaco( vtEspaco[ inxEspaco ] , VerificarValor ) ; return TST_CompararBool( valEsperado , valObtido , "Verificação resultou errado." ) ; } /* fim ativa: Testar: CED &Verificar a integridade de um espaço de dados */ /* Testar: CED &Definir o tipo do espaço */ else if ( strcmp( ComandoTeste , DefinirTipoEspacoCmd ) == 0 ) { numLidos = LER_LerParametros( "iii" , &inxEspaco , &idTipo , &valEsperado ) ; if ( ( numLidos != 3 ) || !VerificarInxEspaco( inxEspaco , FALSE )) { return TST_CondRetParm ; } /* if */ valObtido = CED_DefinirTipoEspaco( vtEspaco[ inxEspaco ] , idTipo ); return TST_CompararInt( valEsperado , valObtido , "Condição de retorno errada." ) ; } /* fim ativa: Testar: CED &Definir o tipo do espaço */ /* Testar: CED &Obter o tipo do espaço */ else if ( strcmp( ComandoTeste , ObterTipoEspacoCmd ) == 0 ) { numLidos = LER_LerParametros( "ii" , &inxEspaco , &valEsperado ) ; if ( ( numLidos != 2 ) || !VerificarInxEspaco( inxEspaco , FALSE )) { return TST_CondRetParm ; } /* if */ valObtido = CED_ObterTipoEspaco( vtEspaco[ inxEspaco ] ) ; return TST_CompararInt( valEsperado , valObtido , "Tipo do espaço errado." ) ; } /* fim ativa: Testar: CED &Obter o tipo do espaço */ /* Testar: CED &Obter tamanho do valor contido no espaço */ else if ( strcmp( ComandoTeste , ObterTamanhoEspacoCmd ) == 0 ) { numLidos = LER_LerParametros( "ii" , &inxEspaco , &valEsperado ) ; if ( ( numLidos != 2 ) || !VerificarInxEspaco( inxEspaco , FALSE )) { return TST_CondRetParm ; } /* if */ valObtido = CED_ObterTamanhoValor( vtEspaco[ inxEspaco ] ) ; return TST_CompararInt( valEsperado , valObtido , "Tamanho do valor errado." ) ; } /* fim ativa: Testar: CED &Obter tamanho do valor contido no espaço */ /* Testar: CED &Marcar ativo o espaço */ else if ( strcmp( ComandoTeste , MarcarEspacoAtivoCmd ) == 0 ) { numLidos = LER_LerParametros( "i" , &inxEspaco ) ; if ( ( numLidos != 1 ) || !VerificarInxEspaco( inxEspaco , TRUE )) { return TST_CondRetParm ; } /* if */ CED_MarcarEspacoAtivo( vtEspaco[ inxEspaco ] ) ; return TST_CondRetOK ; } /* fim ativa: Testar: CED &Marcar ativo o espaço */ /* Testar: CED &Marcar não ativo o espaço */ else if ( strcmp( ComandoTeste , MarcarEspacoNaoAtivoCmd ) == 0 ) { numLidos = LER_LerParametros( "i" , &inxEspaco ) ; if ( ( numLidos != 1 ) || !VerificarInxEspaco( inxEspaco , TRUE )) { return TST_CondRetParm ; } /* if */ CED_MarcarEspacoNaoAtivo( vtEspaco[ inxEspaco ] ) ; return TST_CondRetOK ; } /* fim ativa: Testar: CED &Marcar não ativo o espaço */ /* Testar: CED &Marcar não ativos todos os espaços */ else if ( strcmp( ComandoTeste , MarcarTodosNaoAtivosCmd ) == 0 ) { CED_MarcarTodosEspacosInativos( ) ; return TST_CondRetOK ; } /* fim ativa: Testar: CED &Marcar não ativos todos os espaços */ /* Testar: CED &Verificar se espaço é ativo */ else if ( strcmp( ComandoTeste , VerificarEspacoAtivoCmd ) == 0 ) { numLidos = LER_LerParametros( "ii" , &inxEspaco , &valEsperado ) ; if ( ( numLidos != 2 ) || !VerificarInxEspaco( inxEspaco , TRUE )) { return TST_CondRetParm ; } /* if */ valObtido = CED_EhEspacoAtivo( vtEspaco[ inxEspaco ] ) ; return TST_CompararInt( valEsperado , valObtido , "Marca de espaço ativo errada." ) ; } /* fim ativa: Testar: CED &Verificar se espaço é ativo */ /* Testar CED &Limitar com freqüência de geração de NULL */ else if ( strcmp( ComandoTeste , VerificarFrequenciaCmd ) == 0 ) { numLidos = LER_LerParametros( "iif" , &numAllocs , &Frequencia , &Tolerancia ) ; if ( ( numLidos != 3 ) || ( numAllocs < 100 )) { return TST_CondRetParm ; } /* if */ valObtido = CED_LimitarFrequencia( Frequencia ) ; if ( !valObtido ) { return TST_NotificarFalha( "Freqüência limite de malloc em erro." ) ; } /* if */ for( i = 0 ; i < numAllocs ; i++ ) { pEspaco = CED_Malloc( 100 , i + 1 , "TesteFrequencia" ) ; if ( pEspaco == NULL ) { ContaNULL ++ ; } else { CED_Free( pEspaco ) ; } /* if */ } /* for */ PercentEsperado = ( 1000. - Frequencia ) / 1000. ; PercentObtido = ContaNULL ; PercentObtido = PercentObtido / numAllocs ; return TST_CompararFloat( PercentEsperado , PercentObtido , Tolerancia , "Número de NULLs gerados está fora da tolerância." ) ; } /* fim ativa: Testar CED &Limitar com freqüência de geração de NULL */ /* Testar: CED &Iterador: iniciar iterador de espaços */ else if ( strcmp( ComandoTeste , IniciarIteradorEspacosCmd ) == 0 ) { CED_InicializarIteradorEspacos( ) ; return TST_CondRetOK ; } /* fim ativa: Testar: CED &Iterador: iniciar iterador de espaços */ /* Testar: CED &Iterador: avançar para o próximo espaço */ else if ( strcmp( ComandoTeste , AvancarProximoEspacoCmd ) == 0 ) { numLidos = LER_LerParametros( "i" , &valEsperado ) ; if ( numLidos != 1 ) { return TST_CondRetParm ; } /* if */ valObtido = CED_AvancarProximoEspaco( ) ; return TST_CompararInt( valEsperado , valObtido , "Condição de avanço errada." ) ; } /* fim ativa: Testar: CED &Iterador: avançar para o próximo espaço */ /* Testar: CED &Iterador: obter referência para o espaço corrente */ else if ( strcmp( ComandoTeste , ObterEspacoCorrenteCmd ) == 0 ) { numLidos = LER_LerParametros( "i" , &inxEspaco ) ; if ( ( numLidos != 1 ) || !VerificarInxEspaco( inxEspaco , FALSE )) { return TST_CondRetParm ; } /* if */ vtEspaco[ inxEspaco ] = CED_ObterPonteiroEspacoCorrente( ) ; return TST_CondRetOK ; } /* fim ativa: Testar: CED &Iterador: obter referência para o espaço corrente */ /* Testar: CED &Iterador: existe espaço corrente */ else if ( strcmp( ComandoTeste , ExisteEspacoCorrenteCmd ) == 0 ) { numLidos = LER_LerParametros( "i" , &valEsperado ) ; if ( numLidos != 1 ) { return TST_CondRetParm ; } /* if */ valObtido = CED_ExisteEspacoCorrente( ) ; return TST_CompararInt( valEsperado , valObtido , "Condição de existência de iterador errada." ) ; { } /* fim repete: Testar: CED &Iterador: existe espaço corrente */ } /* fim ativa: Testar: CED &Iterador: existe espaço corrente */ /* Testar: CED &Iterador: terminar iterador */ else if ( strcmp( ComandoTeste , TerminarIteradorEspacoCmd ) == 0 ) { CED_TerminarIteradorEspacos( ) ; return TST_CondRetOK ; } /* fim ativa: Testar: CED &Iterador: terminar iterador */ /* Testar: CED &Iterador: excluir espaço corrente */ else if ( strcmp( ComandoTeste , ExcluirEspacoCorrenteCmd ) == 0 ) { CED_ExcluirEspacoCorrente( ) ; return TST_CondRetOK ; } /* fim ativa: Testar: CED &Iterador: excluir espaço corrente */ return TST_CondRetNaoConhec ; } /* Fim função: TCED &Efetuar comando de teste do controle de espaço dinâmico */