Quand/à quelle fréquence dois-je tester?

Question

En tant que novice développeur qui est d'entrer dans le rythme de mon premier projet professionnel, je suis en train de développer de bonnes habitudes dès que possible.Cependant, j'ai trouvé que j'oublie souvent de tester, le mettre hors tension, ou de faire tout un tas de tests à la fin d'une génération au lieu d'un seul à la fois.

Ma question est quel rythme vous aimez pour obtenir en travaillant sur de grands projets, et où l'essai s'inscrit dans il.

Answer 1

Eh bien, si vous voulez suivre le TDD les gars, avant de commencer à coder ;)

Je suis dans la même situation que vous.Je veux aller plus en avant dans le test, mais je suis actuellement dans une position où nous travaillons à "obtenir le code" plutôt que "obtenir le code de droit" qui fait peur la merde hors de moi.Donc, je suis en train d'essayer d'intégrer les processus de test dans mon cycle de développement.

Actuellement, J'ai test que je code, en essayant de briser le code comme je l'écris.Je trouve cela difficile à obtenir dans le TDD état d'esprit..Son prendre son temps, mais c'est la façon dont je voudrais voulez de travail..

EDIT:

J'ai pensé que je devrais probablement étendre sur ce, c'est ma base de "travail"...

1. Le Plan de ce que je veux de code, possible de l'objet de design, que ce soit.
2. Créer mon premier de la classe, ajouter un énorme commentaire pour le haut de la décrivant ce qui ma "vision" de la classe.
3. Le contour de la base de scénarios de tests..Ces sera essentiellement devenir les tests unitaires.
4. Créer ma première méthode..Également à l'écriture d'un court commentaire expliquant comment il est attendu de travail.
5. Écrire un test automatisé pour voir si elle fait ce que je pense.
6. Répétez les étapes 4 à 6 pour chaque méthode (note les tests automatisés sont dans une liste énorme qui s'exécute sur la touche F5).
7. J'ai ensuite créer une certaine costaud tests pour émuler la classe dans l'environnement de travail, évidemment résoudre les problèmes.
8. Si de nouveaux bugs viennent à la lumière suite à cela, je puis revenir en arrière et écrire le nouveau test, assurez-vous qu'il échoue (c'est aussi la preuve-de-concept pour le bug) puis le fixer..

J'espère que ça aide..Commentaires sur la façon d'améliorer cette situation, comme je l'ai dit c'est une de mes préoccupations..

Answer 2

Avant de vérifier le code.

Answer 3

D'abord et souvent.Si je suis la création de quelques nouvelles fonctionnalités pour le système, je vais être à la recherche de d'abord définir les interfaces et puis écrire des tests unitaires pour ces interfaces.Pour savoir quels sont les tests à écrire envisager l'API de l'interface et la fonctionnalité qu'il propose, sortir un stylo et du papier et réfléchissez un instant au sujet de potentiel conditions d'erreur ou de moyens de prouver qu'il est en train de faire du travail correct.Si c'est trop difficile, alors il est probable que votre API n'est pas assez bon.En ce qui concerne les tests, voir si vous pouvez éviter d'écrire "l'intégration" tests test de plus d'un objet spécifique, et de les garder comme "unité" de test.

Puis créer une implémentation par défaut de votre interface (qui ne fait rien, retourne ordures valeurs, mais ne jette pas des exceptions), branchez-le tests pour s'assurer que le test échoue (ce test vérifie que le test fonctionne!:) ).Ensuite, écrire dans la fonctionnalité et de ré-exécuter les tests.Ce mécanisme n'est pas parfait mais couvrent un grand nombre de simples erreurs de codage et de vous fournir une occasion de lancer une nouvelle fonctionnalité sans avoir à le brancher dans l'ensemble de l'application.

Suite à cela, vous avez ensuite besoin de le tester dans l'application principale avec la combinaison de fonctionnalités existantes.C'est là que le test est plus difficile et, si possible, devrait être en partie externalisé à une bonne QA testeur, puisqu'ils ont le don de casser des choses.Bien qu'il aide si vous avez ces compétences trop.Subir un test de droite est un truc que vous devez prendre pour être honnête.De ma propre expérience vient de mon propre naïve des déploiements et de la suite des bugs qui ont été signalés par les utilisateurs lorsqu'ils sont utilisés dans la colère.

D'abord, lorsque cela m'est arrivé j'ai trouvé ça gênant que l'utilisateur a été intentionnellement essayer de casser mon logiciel et j'ai voulu marquer tous les "bugs" vers le bas comme "les enjeux de la formation".Cependant, après en y réfléchissant, j'ai réalisé qu'il est de notre rôle (en tant que développeurs) d'une application aussi simple et fiable que possible à utiliser, même par des idiots.Il est de notre rôle d'autonomisation des idiots et c'est pourquoi nous sommes payés le dollar.Idiot de la manipulation.

Effectivement comme le test de ce que vous avez à entrer dans l'état d'esprit de chercher à tout casser.Assumer le rôle d'un utilisateur qui dénigre les boutons et généralement les tentatives de détruire votre application dans le monde étrange et merveilleux des manières.Supposons que si vous ne trouvez pas de défauts alors qu'ils seront découverts dans la production de vos entreprises grave perte de face.Prendre l'entière responsabilité pour toutes ces questions et la malédiction sur vous-même lorsque un bug, vous êtes responsable (ou même en partie responsable) est découvert dans la production.

Si vous faites la plupart du au dessus, alors vous devriez commencer à produire beaucoup de code plus robuste, mais il est un peu une forme d'art qui nécessite beaucoup d'expérience pour être bon.

Answer 4

Une bonne clé à retenir est

"Test trop tôt, test souvent et tester à nouveau, quand vous pensez que vous vous êtes fait"

Answer 5

Quand à tester?Lorsqu'il est important que le code fonctionne correctement!

Answer 6

En cas de piratage quelque chose ensemble pour moi-même, je test à la fin.Une mauvaise pratique, mais ce sont généralement les petites choses que je vais utiliser quelques fois et c'est tout.

Sur un projet de plus grande envergure, j'écris des tests avant d'écrire une classe et j'exécute les tests après chaque changement de classe.

Answer 7

Je l'ai tester en permanence.Après avoir fini, même une boucle à l'intérieur d'une fonction, je exécutez le programme et cliquez sur un point d'arrêt au début de la boucle, puis exécutez à travers elle.C'est tout juste pour s'assurer que le processus est en train de faire exactement ce que je veux.

Puis, une fois la fonction terminée, vous de le tester dans son intégralité.Vous voulez probablement pour définir un point d'arrêt juste avant l'appel de la fonction, et de vérifier votre débogueur pour s'assurer qu'il fonctionne parfaitement.

Je suppose que je dirais:"Test souvent."

Answer 8

J'ai récemment ajouté les tests unitaires à mon flux de travail mais je écrire des tests unitaires:

• pour exprimer les exigences pour chaque nouveau module de code (juste après que j'ai écris l'interface, mais avant l'écriture de la mise en œuvre)
• chaque fois que je pense ", il a mieux ...au moment où je me suis fait"
• quand quelque chose se brise, pour quantifier le bug et prouver que j'ai corrigé
• quand j'écris un code qui attribue explicitement ou libère de la mémoire---je préfère ne pas la chasse pour les fuites de mémoire...

J'exécute les tests sur la plupart des versions, et toujours avant d'exécuter le code.

Answer 9

Commencez avec des tests unitaires.Plus précisément, découvrez TDD, Test Driven Development.Le concept derrière le DRT est vous écrire les tests unitaires abord, puis d'écrire votre code.Si le test échoue, vous revenez en arrière et re-travail de votre code.Si ça passe, vous passez à la suivante.

Je prends une approche hybride de la DRT.Je n'aime pas écrire des tests contre rien, alors j'ai l'habitude d'écrire le code d'abord, puis de mettre les tests unitaires dans.C'est un processus itératif, qui vous n'êtes jamais vraiment fait avec.Vous modifiez le code, l'exécution des tests.Si il y a des échecs, de fixer et de répéter.

L'autre sorte de test est le test de l'intégration, qui vient plus tard dans le processus, et peut généralement être fait par les contrôles de qualité de l'équipe.Dans tous les cas, les tests d'intégration répond à la nécessité de tester les morceaux ensemble.C'est le produit qui vous intéresse le test.Celui-ci est plus difficile à traiter avec b/c il s'agit habituellement d'avoir des outils de test automatisés (comme le Robot, par ex.).

Aussi, jetez un oeil à un produit comme CruiseControl.NET pour générer des versions en continu.CC.NET est nice b/c il va exécuter des tests unitaires avec chaque version, vous informer immédiatement de toute défaillance.

Answer 10

Nous ne faisons pas de TDD ici (même si certains ont préconisé), mais notre règle est que vous êtes censé vérifier vos tests unitaires avec vos modifications.Il n'est pas toujours le cas, mais il est facile de revenir en arrière et regarder à un ensemble de modifications et de voir si oui ou non les tests ont été écrites.

Answer 11

Je trouve que si j'attends jusqu'à la fin de l'écriture de quelques nouvelles fonctionnalités de test, j'ai oublier de nombreux cas de bord que je pensais peut-être briser la fonctionnalité.C'est ok si vous faites des choses à apprendre pour vous-même, mais dans un environnement professionnel, je trouve mon flux de la forme classique de:Rouge, Vert, Refactor.

Rouge:Écrivez votre essai de sorte qu'elle échoue.De cette façon, vous savez le test est à faire valoir à l'encontre de la bonne variable.

Vert:Un nouveau test dans la manière la plus simple possible.Si cela signifie que le codage en dur, c'est ok.Ce qui est excellent pour ceux qui veulent juste quelque chose à travailler.

Refactoriser:Maintenant que votre test est réussi, vous pouvez revenir en arrière et modifier votre code avec confiance.Votre nouveau changement cassé votre test?Grand, votre changement a eu pour conséquence que vous ne savais pas, maintenant, votre test est vous dire.

Ce rythme m'a fait de la vitesse de mon évolution au fil du temps parce que j'ai pratiquement une histoire compilateur pour toutes les choses que je pensais que doit être vérifié pour une fonction de travail!Ceci, à son tour, conduit à de nombreux autres avantages, que je ne vais pas faire ici...

Answer 12

Beaucoup de réponses ici!

J'essaie de tester au niveau le plus bas qui a du sens:

• Si un calcul unique ou conditionnelle est difficile ou complexe, ajoutez le code de test alors que vous êtes de l'écrire et de s'assurer que chaque morceau.Commentaire le code de test lorsque vous avez terminé, mais de l'y laisser de documenter la façon dont vous avez testé l'algorithme.

• Tester chaque fonction.

  • L'exercice de chaque branche au moins une fois.
  • L'exercice de la conditions aux limites -- les valeurs d'entrée à laquelle le code de ses changements de comportement -- attraper "par un" erreurs.
  • Tester différentes combinaisons de valide d'intrants.
  • Regardez pour les situations qui pourraient casser le code, et de les tester.

• Tester chaque module avec la même stratégie que ci-dessus.

• Test le corps du code dans son ensemble, afin d'assurer les composants interagissent correctement.Si vous avez été assidu à niveau inférieur de test, il s'agit essentiellement d'un "test de confiance" pour s'assurer que rien n'a cassé lors de l'assemblage.

Depuis plus de mon code pour les systèmes embarqués, - je payer une attention particulière à la robustesse, l'interaction entre les différents threads, des tâches et des composants, et inattendu de l'utilisation des ressources:de mémoire, le CPU, le système de fichiers de l'espace, etc.

En général, le plus tôt vous rencontrez une erreur, plus il est facile d'isoler, d'identifier et de remédier--et de plus le temps que vous obtenez de passer de la création, plutôt que de faire la chasse de votre queue.*

**Je sais, -1 pour la gratuité de la mémoire tampon du pointeur de référence!*