O que é o teste de macaco e gorila? Exemplos, diferença

⚡ Resumo Inteligente

O teste de macaco (monkey testing) alimenta um aplicativo em execução com entradas aleatórias e não planejadas e observa se ele sobrevive, de modo que falhas, congelamentos e estados não tratados são expostos muito antes de qualquer caso de teste predefinido ter sido escrito.

🐒 Ideia central: Cliques aleatórios, pressionamentos de teclas e gestos sondam o sistema em busca de pontos de falha, em vez de resultados esperados.
🦍 Contraste de gorilas: O teste de gorila submete um módulo a testes repetidos, enquanto o teste de macaco percorre toda a aplicação.
🧠 Três níveis de escolaridade: Macacos burros, inteligentes e brilhantes diferem na quantidade de conhecimento que possuem sobre o sistema em teste.
⚖️ Troca honesta: Barato e rápido de executar, mas os defeitos são difíceis de reproduzir e a cobertura não pode ser garantida.
🛠️ Ferramentas: Android Ferramentas como UI/Application Exerciser Monkey, MonkeyRunner e similares geram fluxos de eventos automaticamente.
🎯 Melhor ajuste: Versões preliminares, interfaces interativas e testes de estabilidade, sempre acompanhados de testes exploratórios e com scripts.

Saiba Mais

O que é o teste do macaco?

Teste com macacos O teste de macaco é uma técnica de teste de software na qual o testador insere entradas aleatórias em um aplicativo sem casos de teste predefinidos e verifica como o aplicativo se comporta, em particular se ele trava. O objetivo do teste de macaco é encontrar bugs e erros por meio de interação experimental e não roteirizada.

O nome vem de uma imagem simples, ilustrada abaixo.

No teste de macaco, o testador (e às vezes o desenvolvedor) é tratado como o "macaco".
Se um macaco usasse um computador, ele executaria tarefas aleatoriamente, sem entender o sistema.
Da mesma forma, o testador aplica entradas aleatórias ao sistema em teste para encontrar erros sem pré-definir nenhum caso de teste.
Em alguns casos, o teste com macacos visa a teste de unidade or Teste de GUI.

O que é teste de gorila?

Testes com gorilas É uma técnica de teste de software na qual um módulo do programa é testado repetidamente para confirmar se ele funciona corretamente e não contém defeitos.

Um único módulo pode ser testado cem vezes ou mais exatamente da mesma maneira, razão pela qual o teste de gorila também é conhecido como "teste frustrante". O teste de macaco se espalha aleatoriamente pela aplicação; o teste de gorila se concentra em um ponto específico até que ele apresente falhas ou se mostre sólido.

Tipos de teste de macaco

O teste de macaco é dividido em categorias de acordo com o nível de conhecimento do testador sobre o sistema. O diagrama abaixo resume os três tipos.

Macaco burro: O testador não tem conhecimento algum sobre o sistema ou sua funcionalidade, e não há garantia de que qualquer entrada seja válida.
Macaco esperto: O testador tem uma ideia precisa do sistema, de seu propósito e de sua funcionalidade, navega por ele e fornece entradas válidas.
Macaco brilhante: O testador trabalha com base no comportamento real do usuário e pode indicar onde é provável que os defeitos apareçam.

Testes com macacos vs. testes com gorilas vs. testes ad-hoc

Testes com macacos, testes com gorilas e testes ad-hoc Compartilham um sabor espontâneo, razão pela qual são frequentemente confundidos. As duas tabelas abaixo os separam.

Testes com macacos versus testes com gorilas

Teste de Macacos	Teste de Gorila
Realizado aleatoriamente, sem casos de teste predefinidos.	Nem predefinidas nem aleatórias — as mesmas verificações são simplesmente repetidas.
Realizado em todo o sistema e pode envolver muitos casos de teste.	Realizado em alguns módulos selecionados com poucos casos de teste.
O objetivo é verificar se ocorreu uma falha no sistema.	O objetivo é verificar se o módulo funciona corretamente.

Testes com macacos versus testes ad-hoc

Teste de Macacos	Teste Ad-hoc
Realizado aleatoriamente, sem casos de teste predefinidos.	Executado sem planejamento ou documentação, portanto, nenhum caso de teste ou SRS foi preparado.
Os testadores podem não saber o que é o sistema ou para que serve.	O testador deve compreender bem o sistema antes de iniciar os testes.
O objetivo é verificar se ocorreu uma falha no sistema.	O objetivo é dividir o sistema em subpartes aleatoriamente e verificar sua funcionalidade.

Vantagens e desvantagens dos testes com macacos

Como a técnica troca planejamento por velocidade, seus benefícios e suas desvantagens derivam da mesma propriedade.

Vantagens dos testes com macacos

Novos tipos de insetos: O testador tem liberdade para trabalhar fora dos cenários previamente definidos, o que revela erros que ninguém pensou em incluir no script.
Fácil de executar: Executar ações aleatórias com base em dados aleatórios é uma maneira rápida de exercitar o sistema.
Less Pessoas qualificadas: Os testes com macacos podem, muitas vezes, ser realizados sem a necessidade de testadores altamente experientes.
Less dispendioso: Requer um investimento consideravelmente menor para ser configurado e executado do que um pacote de software com scripts.

Desvantagens dos testes com macacos

Os erros podem ser difíceis de reproduzir: Como as entradas são aleatórias, recriar uma falha pode não ser possível sem uma semente registrada.
Less precisão: O testador não pode definir um cenário exato e não pode garantir a precisão do que foi abordado.
O conhecimento técnico ainda ajuda: Para que as conclusões sejam relevantes, os testadores precisam ter um bom conhecimento da área.
Lento em relação ao rendimento: As execuções podem se prolongar por um longo período e ainda assim apresentar poucos defeitos, deixando lacunas no sistema.

Como realizar testes com macacos

O teste de macaco torna-se muito mais eficiente quando uma ferramenta o automatiza e pode ser executado contra Android desenvolve tanto aplicações para desktop quanto para web. O processo geral é:

Registre o aplicativo em teste na ferramenta ou no servidor dedicado que o executará.
Prepare as referências e a configuração necessárias para que a ferramenta possa criar um conjunto de testes.
Execute o conjunto de testes compilado.
Deixe a ferramenta gravar seu registro — o arquivo de registro do “teste do macaco” registra cada evento gerado e os resultados.
Permita que a execução continue até que o sistema atinja um ponto de falha, momento em que a ação causadora do problema é registrada no log.
Compartilhe o relatório com a equipe responsável e armazene os dados do teste para referência futura.

Guarde todos os registros. Uma execução aleatória só será útil posteriormente se a sequência de eventos e a semente que a gerou forem salvas. gerenciamento de defeitos pode-se relacionar a falha a uma entrada reproduzível.

Ferramentas de teste de macaco

Os testes de macaco geralmente são automatizados, pois uma máquina pode gerar milhares de eventos no tempo que uma pessoa leva para produzir algumas dezenas. As opções mais comuns são:

Macaco Exercitador de UI/Aplicativo: uma ferramenta de linha de comando integrada em Android que corre no adb shell e envia fluxos pseudoaleatórios de eventos do usuário, como toques, gestos e pressionamentos de teclas, além de eventos de nível de sistema, para um dispositivo ou emulador.
Macaco Runner: uma separação Python API que controla dispositivos e emuladores a partir de uma estação de trabalho, enviando comandos específicos e capturando screenshots. Apesar do nome, não é a mesma ferramenta que o "exercitador de macacos".
Automator de interface do usuário e Appium: geral teste móvel Frameworks que podem ser programados para disparar sequências de eventos semi-aleatórios durante uma compilação.
Ferramentas de fuzzing como o AFL: A mesma ideia de entrada aleatória aplicada a dados em vez de gestos, que é abordada em teste fuzz.

O suporte de ferramentas para testes de compatibilidade (monkey testing) é mais limitado do que para testes com scripts. teste de automaçãoAssim, a maioria das equipes combina um gerador de eventos genérico com sua estrutura existente em vez de comprar um produto dedicado.

Quando usar o teste de macaco

O teste com macacos justifica sua aplicação em situações específicas, e não como um substituto geral para testes planejados.

Use-o quando:

Uma versão preliminar precisa de um teste de estabilidade simples antes que existam casos de teste formais.
A interface é altamente interativa — jogos, ferramentas de desenho, reprodutores de mídia — e o comportamento real do usuário é difícil de prever.
Você quer um banho ou estresse Execução que busca por falhas, vazamentos de memória e estados não tratados ao longo de várias horas.
Uma versão foi aprovada nas verificações programadas e você deseja uma verificação independente para tudo o que o script não abordou.

Evite quando:

Você precisa de evidências repetíveis de que um requisito foi atendido — essa é a função de um documento escrito. caso de teste.
A versão é tão instável que todas as execuções travam imediatamente, o que esconde tudo por trás da primeira falha.
O tempo é curto, já que uma busca aleatória não oferece garantia de encontrar nada.

Na prática, os melhores resultados vêm de abordagens mistas: testes com scripts abrangem os fluxos conhecidos, testes exploratórios Investiga o desconhecido deliberadamente, enquanto o teste com macacos ataca tudo aquilo que ambos presumiam que nunca aconteceria.

Perguntas Frequentes

O nome remete à imagem do macaco infinito: um macaco que digita aleatoriamente por tempo suficiente acaba produzindo algo significativo. Aplicado ao software, a entrada aleatória eventualmente atinge estados que nenhum projetista previu.

O teste exploratório é deliberado: o testador formula uma hipótese, investiga-a e adapta-a. O teste com macacos, por sua vez, não é direcionado por natureza. Um depende do julgamento, o outro do volume e da aleatoriedade.

Ambos compartilham o princípio da entrada aleatória, mas diferem no objetivo. O teste de macaco dispara eventos do usuário em uma interface. O fuzzing alimenta analisadores e APIs com dados malformados, geralmente em busca de falhas de segurança.

O Chaos Monkey pertence à engenharia do caos: ele desativa serviços ou interrompe a infraestrutura aleatoriamente para testar a resiliência. A ideia central é a aleatoriedade, mas o alvo é a plataforma em execução, não a interface do usuário.

Os modelos podem direcionar o fluxo de eventos para os caminhos que os usuários reais percorrem, transformando um macaco burro em um mais inteligente. Eles também agrupam registros de falhas duplicados e classificam quais falhas aleatórias merecem a atenção prioritária de um desenvolvedor.

Copiloto do GitHub O projeto da infraestrutura é desenvolvido rapidamente — geradores de eventos, gerenciamento de sementes, analisadores de logs e scripts de triagem de falhas. A estratégia de aleatoriedade e os critérios de aprovação ainda precisam ser definidos por um testador.

Métricas úteis incluem falhas por mil ações geradas, a contagem de defeitos únicos encontrados, a cobertura de código alcançada durante a execução e o tempo até a primeira falha. Analise essas métricas ao longo de várias compilações, em vez de observar apenas uma execução.

Registre a semente aleatória e o log de eventos. Ferramentas que aceitam uma semente reproduzirão a mesma sequência, permitindo que a falha seja identificada como um caso reproduzível de curta duração e registrada como um defeito comum.