def testPodeConstruirUmAutomatoQueGeraApenasEpsilon(self): afd = construirAFDQueGeraEpsilon() afd2 = util.gerar_automato_finito_epsilon() afd3 = util.gerar_automato_finito('a') self.assertTrue(util.sao_equivalentes_af(afd, afd2)) self.assertFalse(util.sao_equivalentes_af(afd, afd3))
def testModificacoesQueNaoAlteramLinguagem(self): exp1 = ExpressaoRegular("a*a*a*") exp2 = ExpressaoRegular("a*") self.assertTrue(util.sao_equivalentes_af(exp1.obterAFD(), exp2.obterAFD())) exp1 = ExpressaoRegular("a|b") exp2 = ExpressaoRegular("b|a") self.assertTrue(util.sao_equivalentes_af(exp1.obterAFD(), exp2.obterAFD()))
def testModificacoesQueAlteramLinguagem(self): exp1 = ExpressaoRegular("a?a?a?") exp2 = ExpressaoRegular("a?") self.assertFalse(util.sao_equivalentes_af(exp1.obterAFD(), exp2.obterAFD())) exp1 = ExpressaoRegular("a.b") exp2 = ExpressaoRegular("b.a") self.assertFalse(util.sao_equivalentes_af(exp1.obterAFD(), exp2.obterAFD()))
def testRobustezDaTransformacaoDaEREmAFD(self): automato = construirAFDComABOndeAsEhPar() exp_reg = ExpressaoRegular("(b*ab*a)*b*") afd_exp = exp_reg.obterAFD() self.assertTrue(util.sao_equivalentes_af(automato, afd_exp)) automato = construirAFDComABOndeBsEhImpar() exp_reg = ExpressaoRegular("a*ba* (a*ba*ba*)*") afd_exp = exp_reg.obterAFD() self.assertTrue(util.sao_equivalentes_af(automato, afd_exp))
def testDadaUmaGramaticaRegularSabeQualEhOSeuAFDMinimoCorrespondente(self): afd1 = construirAFDComABOndeAsEhPar() afd2 = util.obter_afd(construirGRComABOndeAsEhPar()) self.assertTrue(util.sao_equivalentes_af(afd1, afd2)) self.assertTrue(afd2.ehDeterministico()) self.assertTrue(afd2.ehMinimo())
def clicouTestarEquivalencia(self): try: exp1 = ExpressaoRegular(str(self.__ui.exp_reg1.text())) exp2 = ExpressaoRegular(str(self.__ui.exp_reg2.text())) if util.sao_equivalentes_af(exp1.obterAFD(), exp2.obterAFD()): self.__ui.sao_equivalentes.setText("OK") else: self.__ui.sao_equivalentes.setText("NOK") except Exception as excecao: self._error.showMessage(str(excecao))
def testDadoUmAFPodeAplicarFechamentoPositivoNoMesmo(self): afd1 = construirAFDQueGeraOSimboloA() afd_pos = util.obter_fechamento_positivo_af(afd1) self.assertEqual(len(afd_pos.obterEstados()), len(afd1.obterEstados())) self.assertFalse(util.sao_equivalentes_af(afd1, afd_pos)) self.assertTrue(afd1.reconhecePalavra('a')) self.assertFalse(afd1.reconhecePalavra('aa')) self.assertTrue(afd_pos.reconhecePalavra('aa')) self.assertTrue(afd_pos.reconhecePalavra('aaa')) self.assertTrue(afd_pos.reconhecePalavra('a')) self.assertFalse(afd_pos.reconhecePalavra(EPSILON))
def testSabeQualEhOSeuAFDMinimoCorrespondente(self): estados = set() estados.add(Estado("q0", set([Transicao("a", "q1")]), True, False)) estados.add(Estado("q1", set([Transicao("b", "q1"), Transicao("c", "q2")]), False, False)) estados.add(Estado("q2", set(), False, True)) alfabeto = set(["a", "b", "c"]) automato_a_bEstrela_c = AutomatoFinito(alfabeto, estados) exp_reg = ExpressaoRegular("ab*c") afd_exp = exp_reg.obterAFD() self.assertTrue(util.sao_equivalentes_af(automato_a_bEstrela_c, afd_exp)) self.assertTrue(afd_exp.ehDeterministico()) self.assertTrue(afd_exp.ehMinimo())
def testReconheceOOperadorInterrogacao(self): exp1 = ExpressaoRegular("a?") exp2 = ExpressaoRegular("a|" + EPSILON) self.assertTrue(util.sao_equivalentes_af(exp1.obterAFD(), exp2.obterAFD()))
def testReconheceOOperadorFechamentoPosito(self): exp1 = ExpressaoRegular("a+") exp2 = ExpressaoRegular("aa*") self.assertTrue(util.sao_equivalentes_af(exp1.obterAFD(), exp2.obterAFD()))
def testDadoUmAFDSabeQualEhASuaGramaticaRegularCorrespondenteQuandoAFDNaoProduzEpsilon(self): gr1 = util.obter_gramatica_regular(construirAFDComABOndeBsEhImpar()) afd1 = util.obter_afd(gr1) afd2 = construirAFDComABOndeBsEhImpar() self.assertTrue(util.sao_equivalentes_af(afd1, afd2))
def testReconheceOEpsilonComoCaracterEspecialEGeraUmAutomatoMinimoQueGeraEpsilon(self): exp = ExpressaoRegular(EPSILON) self.assertTrue(util.sao_equivalentes_af(exp.obterAFD(), construirAFDQueGeraEpsilon()))
def testDadosDoisAFSabeSeElesNaoSaoEquivalentes(self): afd1 = construirAFDComABOndeAsEhPar() afd2 = construirAFDComABOndeBsEhImpar() self.assertFalse(util.sao_equivalentes_af(afd1, afd2))
def testDefineEscopoDosParentesisCorretamente(self): exp1 = ExpressaoRegular("(a) | (b)") exp2 = ExpressaoRegular("a|b") self.assertTrue(util.sao_equivalentes_af(exp1.obterAFD(), exp2.obterAFD()))
def testDadosDoisAFSabeSeElesSaoEquivalentes(self): afd1 = construirAFDComABOndeAsEhPar() afd2 = construirEquivalenteDoAFDComABOndeAsEhPar() self.assertTrue(util.sao_equivalentes_af(afd1, afd2))
def testSeTodosOsEstadosSaoVivosNaoRemoveEstadoAlgum(self): afd_novo = util.remover_estados_mortos_afd(construirAFDSemEstadosMortosOuInalcancaveis()) self.assertEqual(len(afd_novo.obterEstados()), len(construirAFDSemEstadosMortosOuInalcancaveis().obterEstados())) self.assertTrue(util.sao_equivalentes_af(afd_novo,construirAFDSemEstadosMortosOuInalcancaveis()))
def testDadoUmAFNDRetornaUmAFDEquivalente(self): self.assertFalse(self.afnd.ehDeterministico()) afd = util.determinizar_af(self.afnd) self.assertTrue(afd.ehDeterministico()) self.assertTrue(util.sao_equivalentes_af(self.afnd, afd))
def testDadoUmAFDPodeRemoveTodosOsEstadosInalcancaveis(self): afd_novo = util.remover_estados_inalcancaveis_afd(self.afd_um_estado_inalcancavel) self.assertEqual(3, len(self.afd_um_estado_inalcancavel.obterEstados())) self.assertEqual(2, len(afd_novo.obterEstados())) self.assertTrue(util.sao_equivalentes_af(self.afd_um_estado_inalcancavel, afd_novo))
def testPodeSalvarECarregarUmAutomatoFinitoDoDisco(self): afd1 = construirAFDComABOndeBsEhImpar() util.salvar(afd1, os.path.join(os.getcwd(), 'teste.af')) afd2 = util.carregar(os.path.join(os.getcwd(), 'teste.af')) self.assertTrue(util.sao_equivalentes_af(afd1, afd2))
def testPodeSalvarECarregarUmaGramaticaRegularDoDisco(self): gr1 = util.obter_gramatica_regular(construirAFDComABOndeBsEhImpar()) util.salvar(gr1, os.path.join(os.getcwd(), 'teste.gr')) gr2 = util.carregar(os.path.join(os.getcwd(), 'teste.gr')) self.assertTrue(util.sao_equivalentes_af(util.obter_afd(gr1), util.obter_afd(gr2)))
def testPodeSalvarECarregarUmaExpressaoRegularDoDisco(self): exp = ExpressaoRegular('a*b?.(ab)') util.salvar(exp, os.path.join(os.getcwd(), 'teste.exp')) exp2 = util.carregar(os.path.join(os.getcwd(), 'teste.exp')) self.assertTrue(util.sao_equivalentes_af(exp.obterAFD(), exp2.obterAFD()))
def testUnirDoisAutomatosQueGeramEpsilonGeraOMesmoAutomato(self): afd = util.gerar_automato_finito_epsilon() afd2 = util.unir_af(util.gerar_automato_finito_epsilon(), util.gerar_automato_finito_epsilon()) self.assertTrue(util.sao_equivalentes_af(afd, afd2))
def testDadoUmAFDImcompletoPodeGerarUmNovoAFDCompletoEquivalente(self): afd_imcompleto = construirAFDImcompleto() self.assertFalse(afd_imcompleto.ehCompleto()) afd_completo = util.completar_af(afd_imcompleto) self.assertTrue(afd_completo.ehCompleto()) self.assertTrue(util.sao_equivalentes_af(afd_imcompleto,afd_completo))
def testPodeConstruirOAutomatoQueGeraUmDadoSimbolo(self): afd = construirAFDQueGeraOSimboloA() afd2 = util.gerar_automato_finito('a') afd3 = util.gerar_automato_finito('b') self.assertTrue(util.sao_equivalentes_af(afd, afd2)) self.assertFalse(util.sao_equivalentes_af(afd, afd3))
def testDadoUmAFDNaoMinimoGeraUmAFDMinimoEquivalente(self): afd_nao_minimo = construirAFDNaoMinimo() self.assertFalse(afd_nao_minimo.ehMinimo()) afd_minimo = util.minimizar_afd(afd_nao_minimo) self.assertTrue(afd_minimo.ehMinimo()) self.assertTrue(util.sao_equivalentes_af(afd_nao_minimo,afd_minimo))
def testNaoImportaAQuantidadeDeParentesis(self): exp1 = ExpressaoRegular("((( a* b((ab))* b )))") exp2 = ExpressaoRegular(" a* b(ab)* b ") self.assertTrue(util.sao_equivalentes_af(exp1.obterAFD(), exp2.obterAFD()))
def testExpressaoRegPodeEstarTodaEmglobadaEmParenteses(self): exp1 = ExpressaoRegular("( a* b(ab)* b )") exp2 = ExpressaoRegular(" a* b(ab)* b ") self.assertTrue(util.sao_equivalentes_af(exp1.obterAFD(), exp2.obterAFD()))
def testDadoUmAFDPodeRemoverTodosOsEstadosMortos(self): afd_novo = util.remover_estados_mortos_afd(self.afd_um_estado_morto) self.assertEqual(3, len(self.afd_um_estado_morto.obterEstados())) self.assertEqual(2, len(afd_novo.obterEstados())) self.assertTrue(util.sao_equivalentes_af(afd_novo,self.afd_um_estado_morto))
def testDadoUmAFDQueGeraApenasUmSimboloSabeQualEhASuaGramaticaRegularCorrespondente(self): gr1 = util.obter_gramatica_regular(construirAFDQueGeraOSimboloA()) afd1 = util.obter_afd(gr1) afd2 = construirAFDQueGeraOSimboloA() self.assertTrue(util.sao_equivalentes_af(afd1, afd2))