/*************************************************************************** * * Função: JOG &Criar jogo * ****/ Jogo *JOG_criar() { Jogo *jogo = (Jogo*)malloc(sizeof(Jogo)); //Tratamento de exceção #ifdef _DEBUG if(!jogo) printf("Problema na alocação de memoria para o jogo"); return NULL; #endif //Tratamento de espaço dinamico #ifdef _DEBUG CED_DefinirTipoEspaco(jogo, JOG_Jogo); #endif #ifdef _DEBUG CED_DefinirTipoEspaco(jogo, JOG_Jogo); #endif jogo->tabuleiro = TAB_criar(); //Assertiva de saida #ifdef _DEBUG if(!jogo->tabuleiro) { free(jogo); return NULL; } #endif jogo->funcaoEstado = menu; return jogo; }/* Fim função: JOG &Criar jogo */
tpElemLista * CriarElemento( LIS_tppLista pLista , void * pValor ) { tpElemLista * pElem ; pElem = ( tpElemLista * ) malloc( sizeof( tpElemLista )) ; if ( pElem == NULL ) { return NULL ; } /* if */ #ifdef _DEBUG CED_DefinirTipoEspaco( pElem , LIS_TipoElemento ) ; pElem->listaCabeca = pLista; #endif pElem->pValor = pValor ; pElem->pAnt = NULL ; pElem->pProx = NULL ; pLista->numElem ++ ; return pElem ; } /* Fim função: LIS -Criar o elemento */
LIS_tpCondRet LIS_CriarLista( LIS_tppLista * pLista, void (* pExcluir)( void * pValor)) { #ifdef _DEBUG assert( pLista != NULL ) ; #endif *pLista = ( LIS_tppLista ) malloc( sizeof( LIS_tpLista )) ; if ( *pLista == NULL ) { #ifdef _DEBUG CNT_CONTAR( "LIS_CriarLista_FaltouMemoria" ) ; #endif return LIS_CondRetFaltouMemoria ; } /* if */ #ifdef _DEBUG CED_DefinirTipoEspaco( *pLista , LIS_EspacoCabeca ) ; CNT_CONTAR( "LIS_CriarLista" ) ; #endif LimparCabeca( *pLista ) ; (*pLista)->pExcluir = pExcluir ; return LIS_CondRetOK; } /* Fim função: LIS &Criar lista */
LIS_tppLista LIS_CriarLista( void ( * ExcluirValor ) ( void * pDado ) ) { LIS_tpLista * pLista = NULL ; #ifdef _DEBUG CNT_CONTAR( "CriarLista" ) ; #endif pLista = ( LIS_tpLista * ) malloc( sizeof( LIS_tpLista )) ; if ( pLista == NULL ) { return NULL ; } /* if */ LimparCabeca( pLista ) ; pLista->ExcluirValor = ExcluirValor ; #ifdef _DEBUG CED_DefinirTipoEspaco( pLista , LIS_TipoCabeca ) ; #endif return pLista ; } /* Fim função: LIS &Criar lista */
void TAB_Deturpar(Tabuleiro *tabuleiro, TAB_tpModosDeturpacao ModoDeturpar, int linha, char coluna, TAB_tpModosDeturpacaoLista ModoDeturparLista) { LIS_tppLista lista, lista2; if(!tabuleiro) return; linha--; coluna = tolower(coluna) - 'a'; lista = tabuleiro->lista; switch(ModoDeturpar) { case TAB_DeturpaTipoTabuleiro: { CED_DefinirTipoEspaco(tabuleiro, CED_ID_TIPO_VALOR_NULO); break; } case TAB_DeturparListaPrimaria: { LIS_IrIndice(lista, linha); LIS_Deturpar(lista, ModoDeturparLista); break; } case TAB_DeturparListaSecundaria: { LIS_IrIndice(lista, linha); lista2 = (LIS_tppLista)LIS_ObterValor(lista); LIS_IrIndice(lista2, coluna); LIS_Deturpar(lista2, ModoDeturparLista); break; } } }
LIS_tpCondRet LIS_InserirElementoApos( LIS_tppLista pLista , void * pValor ) { tpElemLista * pElem ; if ( pLista == NULL ) /* Lista não existe */ { return LIS_CondRetListaNaoExiste; } /* if */ /* Criar elemento a inserir após */ pElem = CriarElemento( pLista , pValor ) ; if ( pElem == NULL ) { return LIS_CondRetFaltouMemoria ; } /* if */ #ifdef _DEBUG CED_DefinirTipoEspaco( pElem, LIS_TipoEspacoElemento ) ; #endif /* Encadear o elemento após o elemento */ if ( pLista->pElemCorr == NULL ) { pLista->pOrigemLista = pElem ; pLista->pFimLista = pElem ; } else { if ( pLista->pElemCorr->pProx != NULL ) { pElem->pProx = pLista->pElemCorr->pProx ; pLista->pElemCorr->pProx->pAnt = pElem ; } else { pLista->pFimLista = pElem ; } /* if */ pElem->pAnt = pLista->pElemCorr ; pLista->pElemCorr->pProx = pElem ; } /* if */ pLista->pElemCorr = pElem ; return LIS_CondRetOK ; } /* Fim função: LIS &Inserir elemento após */
void LIS_DeturparElemento(LIS_tppLista lista, int modoDeturpar) { LIS_tpElemLista *elem = lista->pElemCorr; switch(modoDeturpar) { case 4: /* DeturpaTipoElemento */ CED_DefinirTipoEspaco(elem, CED_ID_TIPO_VALOR_NULO); break; case 7: /* DeturpaPtElementoNulo */ lista->pElemCorr = NULL; break; case 8: /* DeturpaDesencadeiaElemento */ elem->pProx->pAnt = NULL; elem->pProx->pProx = NULL; break; } } /* Fim funcao: LIS &Deturpar elemento */
LIS_tpCondRet LIS_CriarLista( LIS_tppLista *ppLista , void ( * ExcluirValor ) ( void * pDado ) ) { *ppLista = ( LIS_tpLista * ) malloc( sizeof( LIS_tpLista )) ; if ( *ppLista == NULL ) { return LIS_CondRetFaltouMemoria ; } /* if */ LimparCabeca( *ppLista ) ; (*ppLista)->ExcluirValor = ExcluirValor ; #ifdef _DEBUG CED_DefinirTipoEspaco(*ppLista,LIS_TipoEspacoElemento); #endif return LIS_CondRetOK ; } /* Fim função: LIS &Criar lista */
static tpElemLista * CriarElemento( LIS_tppLista lista , void * pValor #ifdef _DEBUG , LIS_tpTipo tipo #endif ) { tpElemLista * pElem ; pElem = ( tpElemLista * ) malloc( sizeof( tpElemLista )) ; if ( pElem == NULL ) { #ifdef _DEBUG CNT_CONTAR( "CriarElemento_FaltouMemoria" ) ; #endif return NULL; } /* if */ pElem->pValor = pValor ; pElem->pAnt = NULL ; pElem->pProx = NULL ; #ifdef _DEBUG CED_DefinirTipoEspaco( pElem , LIS_EspacoElemento ) ; CNT_CONTAR( "CriarElemento" ) ; pElem->pTipo = tipo ; pElem->pCabeca = lista ; pElem->tamElem = sizeof( tpElemLista ) ; pElem->tamValor = DefineTamValor( tipo ) ; #endif lista->numElem ++ ; return pElem; } /* Fim função: LIS Criar o elemento */
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 */
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, ¶m) ; 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, ¶m) ; 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 */
/********** Fim do módulo de implementação: LIS Lista duplamente encadeada **********/ void DeturpaLista ( LIS_tppLista pLista, LIS_ModosDeturpacao Deturpacao) { LIS_tpLista * Lista = NULL; if(pLista == NULL) return; Lista = (LIS_tpLista*)(pLista); switch (Deturpacao) { /* Elimina o nó corrente da estrutura */ case DeturpaEliminaCorr : { lixo = ( tpElemLista * ) malloc( sizeof( tpElemLista )) ; lixo->pAnt = NULL; lixo->pProx = NULL; lixo->pValor = NULL; lixo->listaCabeca = Lista; Lista->pElemCorr->pAnt->pProx = lixo; Lista->pElemCorr->pProx->pAnt = lixo; LiberarElemento(Lista, Lista->pElemCorr); break; } /* Anula o ponteiro para o próximo elemento da estrutura */ case DeturpaPtProxNulo : { Lista->pElemCorr->pProx = NULL; break; } /* Anula o ponteiro para o elemento anterior */ case DeturpaPtAntNulo : { Lista->pElemCorr->pAnt = NULL; break; } /* Atribui Lixo para o ponteiro do próximo elemento */ case DeturpaPtProxLixo: { lixo = ( tpElemLista * ) malloc( sizeof( tpElemLista )) ; lixo->pAnt = NULL; lixo->pProx = NULL; lixo->pValor = NULL; lixo->listaCabeca = Lista; Lista->pElemCorr->pProx = lixo; break; } /* Atribui Lixo para o ponteiro para o elemento anterior */ case DeturpaPtAntLixo : { lixo = ( tpElemLista * ) malloc( sizeof( tpElemLista )) ; lixo->pAnt = NULL; lixo->pProx = NULL; lixo->pValor = NULL; lixo->listaCabeca = Lista; Lista->pElemCorr->pAnt = lixo; break; } /* Atribui Nulo ao conteúdo do nó corrente */ case DeturpaPtConteudoCorrNulo : { Lista->pElemCorr->pValor = NULL; break; } /* Modifica o tipo de espaço de dados do nó corrente */ case DeturpaTipoCorr : { CED_DefinirTipoEspaco( Lista->pElemCorr , CED_ID_TIPO_VALOR_NULO ) ; break; } /* Elimina o elemento corrente sem usar free() */ case DeturpaEliminaSemFree : { LIS_DesencadeiaSemFree(Lista); break; } /* Atribui Nulo ao elemento corrente */ case DeturpaPtCorrNulo : { Lista->pElemCorr = NULL; break; } /* Atribui nulo ao ponteiro de origem da estrutura */ case DeturpaPtOrigemNulo : { Lista->pOrigemLista = NULL; break; } /* Altera o tipo de espaço da cabeça de lista*/ case DeturpaTipoCabeca : { CED_DefinirTipoEspaco(Lista , CED_ID_TIPO_VALOR_NULO ) ; break; } default: break; } /* Fim Switch Deturpacao */ }
void LIS_ColocarCabecaTabuleiro(LIS_tppLista lis, void* pCabeca, int tipoEspaco) { lis->pElemCorr->pCabecaTabuleiro = pCabeca; CED_DefinirTipoEspaco(lis->pElemCorr, tipoEspaco); }
LIS_tpCondRet LIS_InserirElementoAntes( LIS_tppLista lista , void * pValor #ifdef _DEBUG , LIS_tpTipo tipo #endif ) { tpElemLista * pElem ; #ifdef _DEBUG assert( lista != NULL ) ; #endif /* Criar elemento a inerir antes */ pElem = CriarElemento( lista , pValor #ifdef _DEBUG , tipo #endif ) ; if ( pElem == NULL ) { #ifdef _DEBUG CNT_CONTAR( "LIS_InserirElementoAntes_FaltouMemoria" ) ; #endif return LIS_CondRetFaltouMemoria ; } /* if */ /* Encadear o elemento antes do elemento corrente */ if ( lista->pElemCorr == NULL ) { #ifdef _DEBUG CNT_CONTAR( "LIS_InserirElementoAntes_CorrNULL" ) ; #endif lista->pOrigemLista = pElem ; lista->pFimLista = pElem ; } else { if ( lista->pElemCorr->pAnt != NULL ) { #ifdef _DEBUG CNT_CONTAR( "LIS_InserirElementoAntes_Ant" ) ; #endif pElem->pAnt = lista->pElemCorr->pAnt ; lista->pElemCorr->pAnt->pProx = pElem ; } else { #ifdef _DEBUG CNT_CONTAR( "LIS_InserirElementoAntes_AntNULL" ) ; #endif lista->pOrigemLista = pElem ; } /* if */ pElem->pProx = lista->pElemCorr ; lista->pElemCorr->pAnt = pElem ; } /* if */ #ifdef _DEBUG CED_DefinirTipoEspaco( pElem , tipo ) ; #endif lista->pElemCorr = pElem ; return LIS_CondRetOK ; } /* Fim função: LIS &Inserir elemento antes */
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 */