65.000.000.000 tests à exécuter
On m'a demandé comment gérer une suite de 65.000.000.000 tests et je me demande s'il est normal d'avoir un projet avec une telle quantité de tests.
Avez-vous travaillé dans des projets avec cette caractéristique?
Avec 65 milliards de tests, on dirait que vous êtes invité à tester toutes les intrants possibles. Ce n'est pas utile - vous devez essentiellement tester que votre processeur fonctionne correctement, et non que votre code est correct.
Vous devriez être testé classes d'équivalence à la place. Cela réduira considérablement votre gamme d'intrants de test.
Examinez également si vous pouvez subdiviser votre système en pièces plus petites. Chaque pièce sera plus facile à tester en isolement, puis vous pouvez effectuer des tests d'intégration qui apportent toutes les pièces ensemble.
Si vous voulez toujours être rassuré que certaines de ces combinaisons d'entrées fonctionnent, vous pourriez peut-être essayer Test de Fuzz . Vous obtiendrez certains des avantages de tester de nombreux intrants différents, mais sans utiliser les 65 milliards de personnes.
S'il s'agit d'une vraie suite test, vous ne voulez que vous ne voulez aller près de votre travail.
L'ensemble du travail d'un testeur est de trouver un équilibre entre les tests suffisamment sûrs pour être confiant, vous avez des résultats "droit" et d'écrire suffisamment de tests qu'ils peuvent être exécutés dans une durée raisonnable.
De nombreux tests peuvent être résumés dans les "classes d'équivalence", ce qui signifie que, plutôt que de courir 3 milliards de tests, vous courez 1 qui vous donne un niveau raisonnable de confiance que tous les autres tests de cette classe d'équivalence se dérouleraient avec succès, si vous avez décidé de gaspiller le temps les exécuter.
Vous devriez dire quiconque envisage de faire fonctionner 65 milliards de tests dont ils ont besoin de faire un meilleur travail d'essai d'abstraction dans des classes d'équivalence.
Est-ce "normal" ?, no. Où "normal" est défini comme une expérience moyenne ou typique. Je ne peux pas dire que j'ai jamais eu à travailler sur un projet comme celui-là, mais je suis sur un projet où un million de bits dans tous les cinq bits sera retourné. Tester que l'un était ... un défi.
Est-ce potentiellement nécessaire? Eh bien, cela dépend des garanties et des spécificités du projet. C'est un peu incrédule de comprendre au début, mais votre question est une lumière sur des détails.
Comme d'autres (Michaelt) ont souligné, le temps de terminer cette tâche avec des tests en série rend cette pratique impraticable. Donc, la parallélisation devient votre première considération. Combien de systèmes de test pouvez-vous lancer à ce problème et quel soutien avez-vous pour associer les résultats de ces systèmes multiples?
Quelles garanties avez-vous que l'appareil ou l'algorithme que vous testez est répliqué de manière fiable? Le logiciel est assez fiable dans la réplication, mais les périphériques matériels (en particulier la première génération) peuvent avoir des problèmes de fabrication. Un faux échec de test dans ce cas pourrait indiquer un mauvais algorithme ou l'appareil ne s'est pas assemblé correctement. Avez-vous besoin de faire la distinction entre ces deux cas?
Vous devrez également déterminer comment vous allez valider les systèmes de test eux-mêmes. Présumer une raison légitime de ce nombre de cas de test, vous aurez besoin de beaucoup d'automatisation. Cette automatisation doit être inspectée pour s'assurer qu'elle ne se trompe pas dans la génération de vos cas de test. Les contrôles sur place des erreurs seraient vraiment l'équivalent de trouver une aiguille dans la fointe.
Cela link arstechnica peut ou ne peut pas donner une idée de vos considérations de test. Les grappes GPU sont couramment utilisées pour les mots de passe de craquage brute. Celui cité dans l'article peut can cycle through as many as 350 billion guesses per second, donc ce type de mise en perspective de 65b. C'est probablement un domaine différent, mais cela montre comment approcher la tâche de différents angles peut donner une solution viable.
Je ne pense pas que cela soit réalisable de Maintenir 6.5e + 10 teste la première place, donc les exécuter peut être discutable. Même les plus grands projets, comme Debian avec tous ses forfaits, n'ont que plusieurs centaines de millions de SLOC.
Mais si vous devez suivre un grand nombre de tests de toute façon, il existe quelques stratégies.
Ne les courez pas tous. La plupart probablement, tous les tests ne dépendent pas de chaque chemin de code. Définir les dépendances entre les sous-systèmes et leurs tests et entre les suites de tests, et vous pourrez uniquement exécuter des tests unitaires pertinents pour un changement particulier, seuls les tests d'intégration en fonction de ces tests d'unités, etc.
Courez-les en parallèle. Avec une base de code qui énorme, vous avez probablement une ferme de construction massive (retour à JetBrains, une opération relativement petite, nous avions l'habitude d'avoir 40 à 50 agents de construction fonctionnant sur l'IDEA la ferme continue de construction/d'intégration unique). Étant donné que les tests d'unités sont indépendants et que des tests d'intégration peuvent réutiliser un code déjà construit, les tests sont relativement faciles à paralléliser.
Arrêtez de courir tôt. Si vous savez qu'une suite de test particulière dépend de son fonctionnement raisonnable sur l'exactitude d'une autre suite de tests, vous pouvez couper la chaîne entière une fois que vous voyez un lien échoue.
Disclaimer: Je ne suis pas un ingénieur de test professionnel. Prenez ce qui précède avec un grain de sel.
Bien qu'il y ait eu plusieurs bonnes suggestions ici sur la façon d'essayer de se faufiler avec moins de tests, je doute sérieusement que votre système ne comporte que 65 milliards de combinaisons d'entrée. C'est moins de 36 bits d'entrée. Supposons que vous aviez déjà pris tous les conseils ci-dessus.
Si chaque test prend environ un milliseconde à exécuter et que vous distribuez les tests sur seulement 10 processeurs (un PC normal), le test fonctionnera dans un peu plus de 69 jours. C'est un moment, mais pas complètement déraisonnable. Distribuez-vous sur 100 processeurs (une douzaine de PC Normal PC ou un PC Server raisonnable) et les tests terminés dans un moins de 7 jours. Vous pouvez les exécuter toutes les semaines pour vérifier les régressions.