Ao usar extensivamente os fósforos do argumento da Mockito, há várias considerações de desempenho a serem lembradas. Embora o Mockito seja geralmente eficiente, o uso extensivo de fósforos de argumento pode introduzir algumas despesas gerais devido à maneira como o Mockito processa esses partidas.
1. Overhead de processamento de fósforo **
- Avaliação do Matcuador de argumentos: quando você usa Matcores de argumentos como `eq ()`, `qualquer ()` ou `AnyString ()`, Mockito precisa avaliar esses correspondentes em tempo de execução. Esse processo de avaliação pode introduzir uma ligeira sobrecarga em comparação com os valores exatos de passagem diretamente. No entanto, essa sobrecarga é tipicamente insignificante, a menos que você esteja lidando com um número muito grande de invocações ou partidas complexas.2. Regras de combinação de fósforos **
- Todos os argumentos devem usar o Matchers: se você usar um Matcher de argumento para um argumento, todos os argumentos devem usar o Matchers. Essa regra pode levar a um código mais detalhado e potencialmente mais despesas gerais se você estiver usando partidas para todos os argumentos, quando apenas um precisar de uma condição específica. Por exemplo, se um método tiver três parâmetros e você desejar usar `qualquer ()` para um deles, você também deve usar os outros dois para os outros dois, mesmo que você pudesse ter usado valores exatos.3. Matcas personalizados **
- Lógica complexa: embora o Mockito forneça uma ampla gama de partidas embutidas, talvez seja necessário criar lógica personalizada para uma lógica específica. Matcores personalizados podem ser mais caros computacionalmente se envolverem lógica ou operações complexas. Isso ocorre porque eles exigem a implementação da interface `ArgumentMatcher` e definindo um método` Matches () `que pode executar verificações arbitrárias.4. VERIFICAÇÃO DE VERIÇÃO **
- Verificação com Matchers: Ao verificar as interações com objetos simulados usando `verify ()`, o Mockito também usa Matcores para verificar se os argumentos corretos foram passados. Semelhante ao Stubbing, a verificação com os fósforos pode introduzir algumas despesas gerais, especialmente se você estiver verificando várias chamadas com partidas complexas.5. Melhores práticas para desempenho **
- Use a especificidade com sabedoria: use Matcores com o nível certo de especificidade. Por exemplo, `anyint ()` é menos específico e mais rápido que `eq (4)`, mas usar `eq (4)` quando você precisa verificar um valor específico é mais preciso e não afeta significativamente o desempenho.- Evite a complexidade desnecessária: evite usar partidas personalizadas, a menos que seja necessário. Se um teste requer lógica complexa para corresponder a argumentos, considere simplificar o teste ou usar os matcheres existentes de forma criativa.
- Profile seus testes: se você notar problemas de desempenho em seus testes, perfil -os para identificar gargalos. É raro o Mockito Matchers ser a principal causa de problemas significativos de desempenho, mas é sempre bom verificar.
Em resumo, embora os matcheres de argumento da Mockito introduzam algumas despesas gerais, isso geralmente não é uma preocupação significativa, a menos que você esteja lidando com testes extremamente complexos ou críticos de desempenho. Os benefícios do uso de partidores, como flexibilidade e clareza no código de teste, geralmente superam os custos menores de desempenho.
Citações:[1] https://stackoverflow.com/questions/56559146/junit-using-eq-argument-matcher-vs-passing-tring-directly/56572275
[2] https://www.digitalocean.com/community/tutorials/mockito-argument-matchers-any-eq
[3] https://kenkousen.substack.com/p/tales-from-the-jar-side-a-mockito
[4] https://www.softwaretestinghelp.com/mockito-matchers/
[5] https://www.toptal.com/java/a-guide-to-everyday-mockito
[6] https://github.com/ettorreborre/specs2/issues/854
[7] https://www.lambdatest.com/automation-testing-advisor/selenium/classes/org.mockito.additionalmatchers
[8] https://stackoverflow.com/questions/73046134/when-shapta