Testes unitários

test_variacao04.py

from unittest import TestCase

from variacao04 import UtilitariosAnaliseTexto

def setup_instance(texto):
    instance = UtilitariosAnaliseTexto()
    instance.texto = texto
    return instance

class TestPalavraMaisLonga(TestCase):
    def test_palavra_longa(self):
        instance = setup_instance("aaa bbbb cccccc")

        longest = instance.palavra_mais_longa()
        self.assertEqual(longest, "cccccc")

    def test_empate(self):
        instance = setup_instance("aaa bbb")

        longest = instance.palavra_mais_longa()
        self.assertEqual(longest, "aaa")

    def test_vazio(self):
        instance = setup_instance("")

        longest = instance.palavra_mais_longa()
        self.assertEqual(longest, "")

    def test_espaco(self):
        instance = setup_instance("    ")

        longest = instance.palavra_mais_longa()
        self.assertEqual(longest, "")

    def test_sem_texto(self):
        instance = UtilitariosAnaliseTexto()

        self.assertRaises(AttributeError, instance.palavra_mais_longa)

class TestFatoresPrimos(TestCase):
    def test_numero_1(self):
        instance = UtilitariosAnaliseTexto()

        result = instance.fatores_primos(1)
        self.assertEqual(result, [])

    def test_numero_negativo(self):
        instance = UtilitariosAnaliseTexto()

        result = instance.fatores_primos(-10)
        self.assertEqual(result, [])

    def test_numero_normal(self):
        instance = UtilitariosAnaliseTexto()

        result = instance.fatores_primos(30)
        self.assertEqual(result, [2, 3, 5])

    def test_numero_primo(self):
        instance = UtilitariosAnaliseTexto()

        result = instance.fatores_primos(7)
        self.assertEqual(result, [7])

class TestPrefixoComum(TestCase):
    def test_lista_vazia(self):
        instance = UtilitariosAnaliseTexto()

        result = instance.prefixo_comum(None)
        self.assertEqual(result, "")

    def test_1_palavra(self):
        instance = UtilitariosAnaliseTexto()

        result = instance.prefixo_comum(["teste"])
        self.assertEqual(result, "teste")

    def test_palavras_iguais(self):
        instance = UtilitariosAnaliseTexto()

        result = instance.prefixo_comum(["teste", "teste", "teste"])
        self.assertEqual(result, "teste")

    def test_palavras_diferentes(self):
        instance = UtilitariosAnaliseTexto()

        result = instance.prefixo_comum(["teste", "aespa"])
        self.assertEqual(result, "")

    def test_prefixo_diferentes_3(self):
        instance = UtilitariosAnaliseTexto()

        result = instance.prefixo_comum(["teste", "testa", "aespa"])
        self.assertEqual(result, "")

    def test_prefixo_comum(self):
        instance = UtilitariosAnaliseTexto()

        result = instance.prefixo_comum(["teste", "testa", "testu"])
        self.assertEqual(result, "test")

    def test_prefixo_comum_caracteres(self):
        instance = UtilitariosAnaliseTexto()

        result = instance.prefixo_comum(["1@@2900", "1@@2844", "1@@2"])
        self.assertEqual(result, "1@@2")

class TestContarFrases(TestCase):
    def test_sem_texto(self):
        instance = UtilitariosAnaliseTexto()

        self.assertRaises(AttributeError, instance.contar_frases)

    def test_vazio(self):
        instance = setup_instance("")

        longest = instance.contar_frases()
        self.assertEqual(longest, 0)

    def test_sem_frase(self):
        instance = setup_instance("teste")

        longest = instance.contar_frases()
        self.assertEqual(longest, 0)

    def test_com_frase(self):
        instance = setup_instance("frase1. frase2? frase3!")

        longest = instance.contar_frases()
        self.assertEqual(longest, 3)

class TestPalavrasComuns(TestCase):
    def test_sem_texto(self):
        instance = UtilitariosAnaliseTexto()

        self.assertRaises(AttributeError, instance.palavras_mais_comuns)

    def test_vazio(self):
        instance = setup_instance("")

        comuns = instance.palavras_mais_comuns(1)
        self.assertEqual(comuns, [])

    def test_palavras_iguais(self):
        instance = setup_instance("teste teste teste")

        comuns = instance.palavras_mais_comuns(1)
        self.assertEqual(comuns, ['teste'])

    def test_palavras_comuns_n1(self):
        instance = setup_instance("aespa teste aespa")

        comuns = instance.palavras_mais_comuns(1)
        self.assertEqual(comuns, ["aespa"])

    def test_palavras_comuns_n2(self):
        instance = setup_instance("aespa teste aespa")

        comuns = instance.palavras_mais_comuns(2)
        self.assertEqual(comuns, ["aespa", "teste"])

class TestFrequenciaCaracteres(TestCase):
    def test_frequencia(self):
        instance = setup_instance("aespa")

        frequencia = instance.frequencia_caracteres()
        self.assertEqual(frequencia, {
            'a': 2,
            'e': 1,
            's': 1,
            'p': 1
        })

    def test_case(self):
        instance = setup_instance("AESpa")

        frequencia = instance.frequencia_caracteres()
        self.assertEqual(frequencia, {
            'a': 2,
            'e': 1,
            's': 1,
            'p': 1
        })

    def test_vazio(self):
        instance = setup_instance("")

        frequencia = instance.frequencia_caracteres()
        self.assertEqual(frequencia, {})

    def test_sem_texto(self):
        instance = UtilitariosAnaliseTexto()

        self.assertRaises(AttributeError, instance.frequencia_caracteres)


class TestFrequenciaPalavras(TestCase):
    def test_frequencia(self):
        instance = setup_instance("aespa aaaa bbbb aespa")

        frequencia = instance.frequencia_palavras()
        self.assertEqual(frequencia, {
            'aespa': 2,
            'aaaa': 1,
            'bbbb': 1
        })

    def test_case(self):
        instance = setup_instance("AESPA AesPA aespa AESPa")

        frequencia = instance.frequencia_palavras()
        self.assertEqual(frequencia, {
            'aespa': 4,
        })

    def test_vazio(self):
        instance = setup_instance("")

        frequencia = instance.frequencia_palavras()
        self.assertEqual(frequencia, {})

    def test_sem_texto(self):
        instance = UtilitariosAnaliseTexto()

        self.assertRaises(AttributeError, instance.frequencia_palavras)

class TestAnagramas(TestCase):
    def test_vazio(self):
        instance = UtilitariosAnaliseTexto()

        result = instance.grupos_anagramas([])
        self.assertEqual(result, [])

    def test_sem_anagrama(self):
        instance = UtilitariosAnaliseTexto()

        result = instance.grupos_anagramas(['amor', 'teste'])
        self.assertEqual(result, [])

    def test_anagrama(self):
        instance = UtilitariosAnaliseTexto()

        result = instance.grupos_anagramas(['amor', 'roma'])
        self.assertEqual(result, [['amor', 'roma']])

    def test_dois_anagrama(self):
        instance = UtilitariosAnaliseTexto()

        result = instance.grupos_anagramas(['amor', 'roma', 'carro', 'corar'])
        self.assertEqual(result, [['amor', 'roma'], ['carro', 'corar']])

    def test_com_espaco(self):
        instance = UtilitariosAnaliseTexto()

        result = instance.grupos_anagramas(['amor na roma', 'roma na amor'])
        self.assertEqual(result, [['amor na roma', 'roma na amor']])

variacao04.py

from collections import Counter


class UtilitariosAnaliseTexto:
    def palavra_mais_longa(self):
        """Retorna a palavra mais longa na string. Em caso de empate, retorna a primeira."""
        palavras = self.texto.split()
        return max(palavras, key=len) if palavras else ""

    def fatores_primos(self, numero):
        """Retorna os fatores primos de um número."""
        if numero <= 1:
            return []
        fatores = []
        divisor = 2
        while numero > 1:
            while numero % divisor == 0:
                fatores.append(divisor)
                numero //= divisor
            divisor += 1
        return fatores

    def prefixo_comum(self, lista_palavras):
        """Encontra o prefixo comum mais longo em uma lista de palavras."""
        if not lista_palavras:
            return ""
        palavra_curta = min(lista_palavras, key=len)
        for i, char in enumerate(palavra_curta):
            if any(palavra[i] != char for palavra in lista_palavras):
                return palavra_curta[:i]
        return palavra_curta

    def contar_frases(self):
        """Conta o número de frases no texto."""
        return self.texto.count(".") + self.texto.count("?") + self.texto.count("!")

    def palavras_mais_comuns(self, n=3):
        palavras = self.texto.lower().split()
        contagem = Counter(palavras)
        return [count[0] for count in contagem.most_common(n)]

    def frequencia_caracteres(self):
        """Retorna a frequência de cada caractere em um dicionário, ignorando maiúsculas/minúsculas."""
        if not self.texto:
            return {}
        caracteres = self.texto.lower()
        return dict(Counter(caracteres))

    def frequencia_palavras(self):
        """Retorna a frequência de cada palavra em um dicionário, ignorando maiúsculas/minúsculas."""
        palavras = self.texto.lower().split()
        return dict(Counter(palavras))

    def grupos_anagramas(self, lista_palavras):
        """Agrupa palavras em uma lista que são anagramas entre si."""
        anagramas = {}
        for palavra in lista_palavras:
            chave = "".join(sorted(palavra))
            anagramas.setdefault(chave, []).append(palavra)
        return [grupo for grupo in anagramas.values() if len(grupo) > 1]