/***************************************************************************
*
* 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 */
