Quelle est la fonction de go test ?

"go test" est une commande de test, utilisée pour tester des programmes écrits en langage Go ; ce test est basé sur des packages de code. La commande "go test" lira automatiquement le fichier de code source nommé "*_test.go" dans le répertoire du code source qui contient plusieurs fonctions de test. La fonction de test a généralement un préfixe de nom "Test" et un type de "testing". T" " fonction déclarée avec paramètres.

L'environnement d'exploitation de ce tutoriel : système Windows 7, GO version 1.18, ordinateur Dell G3.

Le langage Go dispose d'un ensemble de systèmes de tests unitaires et de tests de performances, qui peuvent tester rapidement un morceau de code requis avec seulement une petite quantité de code ajoutée.

La commande go test lira automatiquement le fichier nommé *_test.go sous le répertoire du code source, générera et exécutera le fichier exécutable pour le test.

commande go test (commande test)

La commande go test est utilisée pour tester les programmes écrits en langage Go. Ce type de test est basé sur des packages de code. Bien entendu, cela nécessite également l’aide de fichiers de code source de test. Nous expliquerons comment écrire et rédiger le code de test du programme Go dans la deuxième section de ce chapitre. Ici, nous discutons uniquement de la façon d’utiliser les commandes pour démarrer des tests. go test命令用于对Go语言编写的程序进行测试。这种测试是以代码包为单位的。当然，这还需要测试源码文件的帮助。关于怎样编写并写好Go程序测试代码，我们会在本章的第二节加以详述。在这里，我们只讨论怎样使用命令启动测试。

go test命令会自动测试每一个指定的代码包。当然，前提是指定的代码包中存在测试源码文件。测试源码文件是名称以“_test.go”为后缀的、内含若干测试函数的源码文件。测试函数一般是以“Test”为名称前缀并有一个类型为“testing.T”的参数声明的函数.

现在，我们来测试goc2p项目中的几个代码包。在使用go test命令时指定代码包的方式与其他命令无异——使用代码包导入路径。如果需要测试多个代码包，则需要在它们的导入路径之间加入空格以示分隔。示例如下：

hc@ubt:~$ go test basic cnet/ctcp pkgtool
ok      basic    0.012s
ok      cnet/ctcp    2.014s
ok      pkgtool    0.014s

go test命令在执行完所有的代码包中的测试文件之后，会以代码包为单位打印出测试概要信息。在上面的示例中，对应三个代码包的三行信息的第一列都是“ok”。这说明它们都通过了测试。每行的第三列显示运行相应测试所用的时间，以秒为单位。我们还可以在代码包目录下运行不加任何参数的运行go test命令。其作用和结果与上面的示例是一样的。

另外，我们还可以指定测试源码文件来进行测试。这样的话，go test命令只会执行指定文件中的测试，像这样：

    hc@ubt:~/golang/goc2p/src/pkgtool$ go test envir_test.go
# command-line-arguments
./envir_test.go:25: undefined: GetGoroot
./envir_test.go:40: undefined: GetAllGopath
./envir_test.go:81: undefined: GetSrcDirs
./envir_test.go:83: undefined: GetAllGopath
./envir_test.go:90: undefined: GetGoroot
FAIL    command-line-arguments [build failed]

我们看到，与指定源码文件进行编译或运行一样，命令程序会为指定的源码文件生成一个虚拟代码包——“command-line-arguments”。但是，测试并没有通过。但其原因并不是测试失败，而是编译失败。对于运行这次测试的命令程序来说，测试源码文件envir_test.go是属于代码包“command-line-arguments”的。并且，这个测试源码文件中使用了库源码文件envir.go中的函数。但是，它却没有显示导入这个库源码文件所属的代码包。这显然会引起编译错误。如果想解决这个问题，我们还需要在执行命令时加入这个测试源码文件所测试的那个源码文件。示例如下：

hc@ubt:~/golang/goc2p/src/pkgtool$ go test envir_test.go envir.go
ok      command-line-arguments    0.010s

现在，我们故意使代码包pkgtool中的某个测试失败。现在我们再来运行测试：

hc@ubt:~$ go test basic cnet/ctcp pkgtool
ok      basic   0.010s
ok      cnet/ctcp       2.015s
--- FAIL: TestGetSrcDirs (0.00 seconds)
        envir_test.go:85: Error: The src dir '/usr/local/go/src/pkg' is incorrect.
FAIL
FAIL    pkgtool 0.009s

我们通过以上示例中的概要信息获知，测试源码文件中envir_test.go的测试函数TestGetSrcDirs

La commande go test testera automatiquement chaque package de code spécifié. Bien entendu, le principe est que le fichier de code source du test existe dans le package de code spécifié. Le fichier de code source de test est un fichier de code source dont le nom est suffixé par "_test.go" et contient plusieurs fonctions de test. Une fonction de test est généralement une fonction dont le nom est préfixé par "Test" et possède une déclaration de paramètre de type "testing.T".

Maintenant, testons plusieurs packages de code dans le projet goc2p. La spécification des packages de code lors de l'utilisation de la commande go test est la même qu'avec les autres commandes - en utilisant le chemin d'importation du package de code. Si vous devez tester plusieurs packages de code, vous devez ajouter des espaces entre leurs chemins d'importation pour les séparer. Un exemple est le suivant :

rrreeeLa commande go test imprimera les informations récapitulatives du test en unités de packages de code après avoir exécuté tous les fichiers de test du package de code. Dans l'exemple ci-dessus, la première colonne des trois lignes d'informations correspondant aux trois packages de codes est « ok ». Cela signifie qu’ils ont tous réussi le test. La troisième colonne de chaque ligne indique le temps, en secondes, nécessaire pour exécuter le test correspondant. Nous pouvons également exécuter la commande go test sans aucun paramètre dans le répertoire du package de code. Sa fonction et ses résultats sont les mêmes que ceux de l'exemple ci-dessus.

De plus, nous pouvons également spécifier le fichier de code source du test à tester. Dans ce cas, la commande go test exécutera uniquement les tests dans le fichier spécifié, comme ceci : 🎜rrreee🎜On voit que, tout comme spécifier le fichier de code source à compiler ou exécuter, le programme de commande compilera ou exécutera le fichier de code source spécifié. Générera un package de code factice - "arguments de ligne de commande". Cependant, le test n’a pas réussi. Mais la raison n’est pas que le test a échoué, mais que la compilation a échoué. Pour le programme de commande qui exécute ce test, le fichier de code source du test envir_test.go appartient au package de code « command-line-arguments ». De plus, ce fichier de code source de test utilise les fonctions du fichier de code source de la bibliothèque envir.go. Cependant, il n'affiche pas le package de code dans lequel le fichier de code source de cette bibliothèque est importé. Cela provoquera évidemment des erreurs de compilation. Si nous voulons résoudre ce problème, nous devons également ajouter le fichier de code source testé par ce fichier de code source de test lors de l'exécution de la commande. Voici un exemple : 🎜rrreee🎜Maintenant, nous échouons intentionnellement à un test dans le package de code pkgtool. Maintenant, exécutons à nouveau le test : 🎜rrreee🎜Nous savons grâce aux informations récapitulatives de l'exemple ci-dessus que le test dans la fonction de test TestGetSrcDirs d'envir_test.go dans le fichier source du test a échoué. Dans la ligne d'informations contenant le nom du fichier source de test qui a échoué au test, le numéro séparé par deux points qui suit immédiatement le nom du fichier source de test est le numéro de ligne où se trouve le message d'erreur, et le numéro séparé par deux points après la ligne Le numéro est le message d'erreur. Le contenu de ce message d'erreur est écrit par l'utilisateur. De plus, la dernière ligne des informations récapitulatives est préfixée par « FAIL ». Cela indique que les tests du package de code pkgtool échouent. Les raisons de l'échec sont décrites dans le message précédent. 🎜🎜Normalement, nous placerons le fichier de code source de test et le fichier de code source testé dans le même package de code. De plus, les noms de packages déclarés dans ces fichiers de code source sont également les mêmes. De plus, nous avons une autre option, c'est-à-dire que le nom du package déclaré dans le fichier de code source du test peut être le nom du package correspondant plus le suffixe "_test". Nous appelons ce type de fichier de code source de test un fichier de code source de test hors package. Cependant, il existe un inconvénient à tester les fichiers de code source en dehors du package, c'est-à-dire que les entités de programme privé au niveau du package dans le fichier de code source testé ne peuvent pas être testées dans leurs fonctions de test, telles que les variables privées au niveau du package, les fonctions, et les types de structures. En effet, les packages de codes auxquels appartiennent les deux sont différents. Par conséquent, nous écrivons généralement rarement des fichiers de code source de test hors package. 🎜🎜🎜À propos des tags🎜🎜

La partie traitement des balises de la commande go test est si volumineuse et compliquée que les développeurs du langage Go doivent déplacer cette partie de la logique du corps principal de la commande go test programme Séparez et créez des fichiers de code source séparés. Étant donné que la commande go test inclut une action de compilation, elle peut accepter toutes les balises disponibles pour la commande go build. De plus, il possède de nombreuses marques uniques. Ces balises sont utilisées pour contrôler les actions de la commande elle-même, certaines sont utilisées pour contrôler et configurer le processus et l'environnement de test, et d'autres sont utilisées pour générer des résultats de test et des informations statistiques plus détaillés. go test命令的标记处理部分是庞大且繁杂的，以至于使Go语言的开发者们不得不把这一部分的逻辑从go test命令程序主体中分离出来并建立单独的源码文件。因为go test命令中包含了编译动作，所以它可以接受可用于go build命令的所有标记。另外，它还有很多特有的标记。这些标记的用于控制命令本身的动作，有的用于控制和设置测试的过程和环境，还有的用于生成更详细的测试结果和统计信息。

可用于go test命令的几个比较常用的标记是-c、-i和-o。这两个就是用于控制go test命令本身的动作的标记。详见下表。

表0-6 go test命令的标记说明

标记名称	标记描述
-c	生成用于运行测试的可执行文件，但不执行它。这个可执行文件会被命名为“pkg.test”，其中的“pkg”即为被测试代码包的导入路径的最后一个元素的名称。
-i	安装/重新安装运行测试所需的依赖包，但不编译和运行测试代码。
-o	指定用于运行测试的可执行文件的名称。追加该标记不会影响测试代码的运行，除非同时追加了标记-c或-i。

上述这几个标记可以搭配使用。搭配使用的目的可以是让go test命令既安装依赖包又编译测试代码，但不运行测试。也就是说，让命令程序跑一遍运行测试之前的所有流程。这可以测试一下测试过程。注意，在加入-c

Quelques-unes des balises les plus courantes qui peuvent être utilisées avec la commande go test sont -c, -i et - o. Ces deux balises sont utilisées pour contrôler les actions de la commande go test elle-même. Voir le tableau ci-dessous pour plus de détails.

Tableau 0-6 Description de la marque de la commande go test

Nom de la marque	Description de la marque
-c	Génère un fichier exécutable pour exécuter les tests, mais ne l'exécute pas. Ce fichier exécutable sera nommé "pkg.test", où "pkg" est le nom du dernier élément du chemin d'importation du package de code testé.
-i	Installe/réinstalle les packages de dépendances requis pour exécuter le test, mais ne compile ni n'exécute le code de test.
-o	Spécifie le nom du fichier exécutable utilisé pour exécuter le test. L'ajout de cette balise n'affectera pas l'exécution du code de test à moins que la balise -c ou -i ne soit également ajoutée.

Les balises ci-dessus peuvent être utilisées ensemble. Le but de leur utilisation ensemble peut être de laisser la commande go test installer les packages dépendants et compiler le code de test, mais pas exécuter les tests. En d’autres termes, laissez le programme de commande exécuter tous les processus avant d’exécuter le test. Cela peut être utilisé pour tester le processus de test. Notez qu'après avoir ajouté la balise -c, le programme de commande stockera le fichier exécutable utilisé pour exécuter le test dans le répertoire courant. 【Recommandations associées : 🎜Tutoriel vidéo Go🎜, 🎜Enseignement de la programmation🎜】🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!