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;
}
}
}
TAB_tpCondRet TAB_setarCasa(Tabuleiro *tabuleiro, int linha, char coluna, Peca *peca, int limpar)
{
LIS_tppLista lista;
Peca *antiga;
--linha;
coluna = tolower(coluna) - 'a';
if(LIS_IrIndice(tabuleiro->lista, linha) != LIS_CondRetOK)
return TAB_CondRetLinhaInexistente;
lista = (LIS_tppLista)LIS_ObterValor(tabuleiro->lista);
if(!lista)
return TAB_CondRetLinhaInexistente;
if(LIS_IrIndice(lista, coluna) != LIS_CondRetOK)
return TAB_CondRetColunaInexistente;
if(limpar) {
antiga = LIS_ObterValor(lista);
if(antiga)
ListaExcluirPeca(antiga);
}
LIS_SetarValor(lista, peca);
return TAB_CondRetOK;
}/* Fim função: TAB &Setar valor de uma peça no tabuleiro */
void PosicionarElementoCorrente(Tabuleiro *tabuleiro, int linha, char coluna)
{
LIS_tppLista lista;
--linha;
coluna = tolower(coluna) - 'a';
LIS_IrIndice(tabuleiro->lista, linha);
lista = (LIS_tppLista)LIS_ObterValor(tabuleiro->lista);
LIS_IrIndice(lista, coluna) ;
}/* Fim função: TAB &Posicionar Elemento Corrente */
Peca *TAB_obterCasa(Tabuleiro *tabuleiro, int linha, char coluna)
{
LIS_tppLista lista;
--linha;
coluna = tolower(coluna) - 'a';
if(LIS_IrIndice(tabuleiro->lista, linha) != LIS_CondRetOK)
return NULL;
lista = (LIS_tppLista)LIS_ObterValor(tabuleiro->lista);
if(!lista)
return NULL;
if(LIS_IrIndice(lista, coluna) != LIS_CondRetOK)
return NULL;
return LIS_ObterValor(lista);
}/* Fim função: TAB &Obter valor de uma peça no tabuleiro */
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 */
TAB_tpCondRet TAB_VerificarTabuleiro(Tabuleiro* tabuleiro)
{
int condRet, linha, coluna;
Peca*peca;
LIS_tppLista lista;
if(!tabuleiro) {
CNT_CONTAR("Tabuleiro Inexistente");
TST_NotificarFalha("Tentou verificar tabuleiro inexistente.");
return TAB_CondRetErroEstrutura;
}
else
CNT_CONTAR("Tabuleiro Existente");
if(!CED_VerificarEspaco(tabuleiro, NULL)) {
CNT_CONTAR("Tabuleiro possui alguma falha");
TST_NotificarFalha("Controle do espaço acusou erro.");
return TAB_CondRetErroEstrutura ;
}
else
CNT_CONTAR("Tabuleiro nao possui falha");
if(TST_CompararInt(TAB_Tabuleiro, CED_ObterTipoEspaco(tabuleiro),
"Tipo do espaço de dados nao e tabuleiro.") != TST_CondRetOK) {
CNT_CONTAR("Tipo nao e Tabuleiro");
return TAB_CondRetErroEstrutura;
}
else
CNT_CONTAR("Tipo e Tabuleiro");
CED_MarcarEspacoAtivo(tabuleiro);
CNT_CONTAR("Tipo Tabuleiro OK");
/*Verificar a lista das listas, primária*/
if(LIS_VerificarLista(tabuleiro->lista) == LIS_CondRetErroEstrutura)
{
CNT_CONTAR("Lista de listas com erro");
return TAB_CondRetErroEstrutura;
}
/*Verificar Cada elemento da lista, ou seja, cada linha*/
LIS_IrInicioLista(tabuleiro->lista);
for(linha = 0; linha < TabuleiroAltura; ++linha) {
lista = LIS_ObterValor(tabuleiro->lista);
condRet = LIS_VerificarLista(lista);
if(condRet == LIS_CondRetErroEstrutura) {
CNT_CONTAR("Uma das listas de pecas possui algum problema");
return TAB_CondRetErroEstrutura;
}
/*Verificar Cada elemento da lista secundária, ou seja, cada casa do tabuleiro*/
LIS_IrInicioLista(lista);
for(coluna = 0; coluna < TabuleiroLargura; ++coluna) {
peca = LIS_ObterValor(lista);
if(peca) {
CNT_CONTAR("Casa nao Vazia");
if(TST_CompararInt(PEC_Peca, CED_ObterTipoEspaco(peca), "Tipo do espaço de dados nao e peca.") != TST_CondRetOK) {
TST_NotificarFalha("Tipo numa casa do tabuleiro nao e peca");
CNT_CONTAR("Tipo nao e peca");
return TAB_CondRetErroEstrutura;
}
else
{
CNT_CONTAR("Tipo e peca");
CED_MarcarEspacoAtivo(peca);
}
}
else
CNT_CONTAR("Casa Vazia");
LIS_AvancarElementoCorrente(lista, 1);
}
if(LIS_IrIndice(lista, 7) == LIS_CondRetOK && LIS_IrIndice(lista, 8) == LIS_CondRetFimLista)
CNT_CONTAR("Tabuleiro com 8 colunas");
else {
CNT_CONTAR("Tabuleiro nao tem 8 colunas");
TST_NotificarFalha("Tabuleiro nao tem 8 colunas");
return TAB_CondRetErroEstrutura;
}
LIS_AvancarElementoCorrente(tabuleiro->lista, 1);
}
if(LIS_IrIndice(tabuleiro->lista, 7) == LIS_CondRetOK && LIS_IrIndice(tabuleiro->lista, 8) == LIS_CondRetFimLista)
CNT_CONTAR("Tabuleiro com 8 linhas");
else {
CNT_CONTAR("Tabuleiro nao tem 8 linhas");
TST_NotificarFalha("Tabuleiro nao tem 8 linhas");
return TAB_CondRetErroEstrutura;
}
CNT_CONTAR("Ha uma lista de listas e a sublista de pecas sem problemas");
return TAB_CondRetOK;
}