Aproveitando LLMs pra Melhorar a Geração de Oráculos de Teste

Testar software é essencial pra encontrar bugs nos programas. Uma parte chave desse processo é o oráculo de teste, que ajuda a determinar se o software tá funcionando direitinho. Embora existam métodos automáticos pra criar esses oráculos de teste, muitos deles geram resultados errados demais. Modelos de linguagem grandes (LLMs) mostraram que podem ajudar em várias tarefas de software, como escrever código, criar casos de teste e corrigir bugs, mas não rolou muita pesquisa sobre a eficácia deles em gerar oráculos de teste confiáveis.

Neste estudo, a gente vê se os LLMs conseguem produzir oráculos de teste corretos, variados e fortes que conseguem identificar bugs únicos. A gente treinou sete LLMs diferentes usando vários prompts numa base de dados chamada SF110. Identificando a combinação mais eficaz de modelo e prompt, desenvolvemos um novo método pra gerar oráculos de teste. Pra ver como esse método funciona, testamos em 25 grandes projetos em Java. Consideramos não só a correção, mas também a diversidade e a força dos oráculos gerados, comparando nossos resultados com outros métodos como o EvoSuite e o TOGA.

#Importância dos Oráculos de Teste

Os oráculos de teste são super importantes nos testes de software porque definem o comportamento esperado do software. Um conjunto de testes é feito de casos de teste, onde cada caso testa uma parte específica do programa. O oráculo de teste verifica se o programa agiu como esperado. Tem dois tipos principais de oráculos de teste:

1. Oráculos de Aserção: Esses checam se a saída do programa tá correta.
2. Oráculos de Exceção: Esses checam se o programa identifica os erros direitinho.

Pra um oráculo de teste ser eficaz, ele não pode ser só correto, mas também forte. Um oráculo correto significa que ele bate com o comportamento esperado sem dar alarmes falsos. Um oráculo forte consegue detectar quando o programa faz algo errado. É importante ter essas duas qualidades pra garantir uma detecção precisa de bugs.

Embora criar oráculos de teste manualmente seja mais eficaz, dá muito trabalho e leva muito tempo. Pra resolver isso, os pesquisadores têm buscado maneiras de automatizar esse processo.

#Métodos Usados pra Geração de Oráculos

Teve várias abordagens pra criar oráculos de teste automaticamente, usando técnicas de processamento de linguagem natural e reconhecimento de padrões. Alguns métodos geram oráculos com base em comentários e documentação. Esses podem produzir tanto oráculos de asserção quanto de exceção.

Recentemente, redes neurais têm sido usadas na geração de oráculos. O método TOGA mostrou desempenho melhor que os métodos antigos. Mas ainda tem limitações, gerando oráculos de asserção corretos só 38% das vezes, com uma taxa alta de falsos positivos tanto pra oráculos de asserção quanto de exceção. Isso mostra que ainda precisa avançar na criação de oráculos automáticos confiáveis.

#Explorando LLMs pra Geração de Oráculos de Teste

Os LLMs tão chamando atenção pra várias tarefas de engenharia de software, incluindo testes. Tentativas anteriores de usar LLMs pra gerar casos de teste enfrentaram desafios pra alcançar uma boa cobertura de teste. Alguns estudos mostraram sucesso limitado em gerar prefixos de teste pra grandes programas Java. Outros tentaram usar LLMs pra produzir tanto prefixos de teste quanto oráculos de teste, mas não avaliaram a qualidade dos oráculos gerados pra detecção de bugs.

Na nossa pesquisa, a gente separou a tarefa. Usamos métodos bem estabelecidos como o EvoSuite pra criar prefixos de teste e focamos só em usar LLMs pra gerar oráculos de teste. Ajustamos sete LLMs de código diferentes usando vários prompts que davam diferentes quantidades de contexto sobre o software sendo testado.

#Os Modelos Usados

A gente explorou vários LLMs pré-treinados, cada um com tamanhos e capacidades diferentes. Os modelos que examinamos incluem:

1. CodeGPT: Um modelo menor que mostrou bons resultados em Java.
2. CodeParrot: Esse modelo vai bem apesar de ser leve.
3. CodeGen: Disponível em vários tamanhos, esses modelos são bons em entender código.
4. PolyCoder: Outra família de modelos treinados em várias linguagens de programação.
5. Phi-1: Apesar de ser treinado principalmente em Python, esse modelo teve bom desempenho nas nossas avaliações pra Java.

#Preparação dos Dados de Treinamento

Pra treinar nossos modelos, a gente usou a base de dados SF110, que inclui vários projetos Java com casos de teste gerados pelo EvoSuite. A gente processou esses dados pra criar tuplas que incluíam o prefixo de teste, o método sendo testado e o oráculo correspondente. Essa base de dados foi dividida em partes de treinamento, teste e validação pra garantir uma avaliação justa dos nossos métodos.

#Projetando Prompts Eficazes

A gente criou seis prompts diferentes pra ajustar os LLMs, adicionando gradualmente mais contexto:

1. P1: Só o prefixo de teste.
2. P2: Prefixo de teste e documentação do método.
3. P3: Prefixo de teste e assinatura do método.
4. P4: Prefixo de teste, documentação e assinatura do método.
5. P5: Prefixo de teste e o código inteiro do método.
6. P6: Prefixo de teste, documentação e código inteiro do método.

A gente percebeu que dar mais informações de fundo melhorou a precisão, mas às vezes modelos maiores não se saíram melhor que os menores quando ajustados corretamente.

#Avaliando os Modelos

Uma vez que ajustamos os modelos, testamos o desempenho deles em 25 projetos Java que eram novos pra eles. Geramos oráculos de teste pra cada projeto e validamos executando os testes. A precisão foi medida com base em quantos oráculos gerados passaram nos testes.

#Comparando com Outros Métodos

A gente comparou nossos oráculos gerados por LLM com os gerados pelo TOGA e pelo EvoSuite. O objetivo era ver quantos oráculos corretos cada método conseguia gerar e quão bem eles conseguiam detectar bugs.

#Resultados e Descobertas

#Eficácia dos LLMs

Nossas descobertas sugerem que os LLMs podem, sim, produzir oráculos de teste fortes e corretos. Na verdade, o LLM com melhor desempenho gerou bem mais oráculos de asserção e de exceção corretos comparado ao TOGA. Isso significa que usar LLMs melhora o processo de gerar oráculos de teste confiáveis.

#Diversidade dos Oráculos Gerados

Outro aspecto importante que a gente olhou foi a diversidade. Os oráculos gerados pelos LLMs mostraram uma ampla gama de estilos de asserção, tornando-os adequados pra complementar oráculos escritos por desenvolvedores tradicionais. Essa diversidade é crucial pra detectar bugs que podem ser perdidos por abordagens mais uniformes.

#Força dos Oráculos na Detecção de Bugs

A força dos oráculos criados pelos LLMs foi avaliada através de testes de mutação. Esse processo envolve fazer pequenas mudanças no código pra criar "mutantes" e ver se os oráculos de teste conseguem detectar essas mudanças. Nossos resultados indicaram que os oráculos gerados pelos LLMs conseguiram identificar muitos bugs únicos que outros não conseguiram.

#Desafios e Limitações

Apesar dos resultados promissores, alguns desafios ainda permanecem. Por exemplo, cerca de 5% das asserções geradas não compilaram devido a erros de sintaxe pequenos. Além disso, uma pequena fração das saídas geradas foram falsos positivos-asserções que indicaram um problema quando não tinha nenhum.

#Direções Futuras

Daqui pra frente, refinar os modelos pra reduzir erros de compilação e falsos positivos vai ser uma prioridade. Outra área de foco é encontrar maneiras de usar documentação de melhor qualidade, que pode melhorar os oráculos gerados.

#Conclusão

Os LLMs têm um grande potencial pra melhorar a geração de oráculos de teste em testes de software. Nossa pesquisa mostra que eles podem produzir oráculos de teste mais corretos, diversos e fortes do que os métodos anteriores. Ao abordar os desafios existentes e continuar a refinar essas técnicas, podemos fazer grandes avanços rumo a processos de teste de software mais confiáveis. Esse trabalho estabelece as bases pra futuros avanços na geração automática de oráculos de teste.