Questions fréquentes (FAQ) sur Live Unit TestingLive Unit Testing frequently asked questions

Fonctionnalités les plus récentesLatest features

Live Unit Testing est régulièrement amélioré. Comment puis-je trouver des informations sur les dernières fonctionnalités et améliorations ?Live Unit Testing is improved and enhanced regularly. How can I find information about the latest new features and enhancements?

Pour en savoir plus sur les nouvelles fonctionnalités et les améliorations qui ont été apportées à Live Unit Testing à compter de Visual Studio 2017 version 15.3, consultez Nouveautés de Live Unit Testing.To learn about the new features and enhancements that have been made to Live Unit Testing starting with Visual Studio 2017 version 15.3, see What's New in Live Unit Testing.

Les frameworks et versions pris en charge sont les suivantsSupported frameworks and versions

Quels sont les frameworks de tests pris en charge par Live Unit Testing et quelles sont les versions minimales prises en charge ?What test frameworks does Live Unit Testing support and what are the minimum supported versions?

Live Unit Testing fonctionne avec les trois frameworks de tests unitaires populaires listés dans le tableau suivant.Live Unit Testing works with the three popular unit testing frameworks listed in the table that follows. La version minimale prise en charge des adaptateurs et des frameworks est également listée dans le tableau.The minimum supported version of their adapters and frameworks is also listed in the table. Les frameworks de tests unitaires sont tous disponibles dans NuGet.org.The unit testing frameworks are all available from NuGet.org.

Framework de testTest Framework Version minimale de l’adaptateur Visual StudioVisual Studio Adapter minimum version Version minimale du frameworkFramework minimum version
xUnit.netxUnit.net xunit.runner.visualstudio version 2.2.0-beta3-build1187xunit.runner.visualstudio version 2.2.0-beta3-build1187 xunit 1.9.2xunit 1.9.2
NUnitNUnit NUnit3TestAdapter version 3.5.1NUnit3TestAdapter version 3.5.1 NUnit version 3.5.0NUnit version 3.5.0
MSTestMSTest MSTest.TestAdapter 1.1.4-previewMSTest.TestAdapter 1.1.4-preview MSTest.TestFramework 1.0.5-previewMSTest.TestFramework 1.0.5-preview

Si vous avez des projets de test basés sur MSTest plus anciens qui référencent Microsoft.VisualStudio.QualityTools.UnitTestFramework et que vous ne souhaitez pas passer aux packages NuGet de MSTest plus récents, faites une mise à niveau vers Visual Studio 2017 version 15.4.If you have older MSTest based test projects that reference Microsoft.VisualStudio.QualityTools.UnitTestFramework and you don’t wish to move to the newer MSTest NuGet packages, upgrade to Visual Studio 2017 version 15.4.

Dans certains cas, vous devez peut-être restaurer explicitement les packages NuGet référencés par les projets dans la solution pour que Live Unit Testing fonctionne.In some cases, you may need to explicitly restore the NuGet packages referenced by the projects in the solution in order for Live Unit Testing to work. Vous pouvez restaurer les packages en exécutant une build explicite de la solution (sélectionnez Générer, Regénérer la solution à partir du menu Visual Studio de niveau supérieur) ou en cliquant avec le bouton droit sur la solution, puis en sélectionnant Restaurer des packages NuGet avant d’activer Live Unit Testing.You can restore the packages either by doing an explicit build of the solution (select Build, Rebuild Solution from the top-level Visual Studio menu), or by right-clicking on the solution and selecting Restore NuGet Packages before enabling Living Unit Testing.

Support de .NET Core.NET Core support

Live Unit Testing fonctionne-il avec .NET Core ?Does Live Unit Testing work with .NET Core?

Oui.Yes. Live Unit Testing fonctionne avec.NET Core et .NET Framework.Live Unit Testing works with .NET Core and the .NET Framework. La prise en charge de .NET Core a été ajoutée récemment dans la version 15.3 de Visual Studio 2017.Support for .NET Core was added recently in Visual Studio 2017 version 15.3. Effectuez une mise à niveau vers cette version de Visual Studio si vous souhaitez que .NET Core prenne en charge Live Unit Testing.Upgrade to this version of Visual Studio if you want Live Unit Testing support for .NET Core.

ConfigurationConfiguration

Pourquoi Live Unit Testing ne fonctionne-t-il pas quand je l’active ?Why doesn't Live Unit Testing work when I turn it on?

La Fenêtre Sortie (lorsque vous sélectionnez la liste déroulante Live Unit Testing) doit indiquer les raisons de ce dysfonctionnement.The Output Window (when the Live Unit Testing drop-down is selected) should tell you why Live Unit Testing is not working. Live Unit Testing Test peut ne pas fonctionner pour les raisons suivantes :Live Unit Testing may not work for one of the following reasons:

  • Si les packages NuGet référencés par les projets de la solution n’ont pas été restaurés, Live Unit Testing ne peut pas fonctionner.If NuGet packages referenced by the projects in the solution have not been restored, Live Unit Testing will not work. Pour résoudre ce problème, effectuez une build explicite de la solution ou restaurez les packages NuGet de la solution avant d’activer Live Unit Testing.Doing an explicit build of the solution or restoring NuGet packages in the solution before turning on Live Unit Testing should resolve this issue.

  • Si vous utilisez des tests basés sur MSTest dans vos projets, veillez à supprimer la référence à Microsoft.VisualStudio.QualityTools.UnitTestFramework et à ajouter des références aux derniers packages NuGet MSTest, MSTest.TestAdapter (version 1.1.11 au minimum requise) et MSTest.TestFramework (version 1.1.11 au minimum requise).If you are using MSTest-based tests in your projects, make sure that you remove the reference to Microsoft.VisualStudio.QualityTools.UnitTestFramework, and add references to the latest MSTest NuGet packages, MSTest.TestAdapter (a minimum version of 1.1.11 is required) and MSTest.TestFramework (a minimum version of 1.1.11 is required). Pour plus d’informations, consultez la section « Frameworks de tests pris en charge » de l’article Utiliser Live Unit Testing dans Visual Studio 2017 Enterprise Edition.For more information, see the "Supported test frameworks" section of the Use Live Unit Testing in Visual Studio 2017 Enterprise Edition article.

  • Au moins un projet de votre solution doit contenir une référence NuGet ou une référence directe au framework de tests xUnit, NUnit ou MSTest.At least one project in your solution should have either a NuGet reference or direct reference to the xUnit, NUnit, or MSTest test framework. Ce projet doit également faire référence au package NuGet des adaptateurs de test Visual Studio correspondants.This project should also reference a corresponding Visual Studio test adapters NuGet package. L’adaptateur de test Visual Studio peut également être référencé via un fichier .runsettings.The Visual Studio test adapter can also be referenced through a .runsettings file. Le fichier .runsettings doit avoir une entrée semblable à ce qui est contenu dans l’exemple suivant :The .runsettings file must have an entry like the following example:

<RunSettings>
    <RunConfiguration>
          <TestAdaptersPaths>path-to-your-test-adapter</TestAdaptersPaths>
     </RunConfiguration>
</RunSettings>

Couverture incorrecte après la mise à niveauIncorrect coverage after upgrade

Pourquoi est-ce que Live Unit Testing indique une couverture incorrecte après la mise à niveau de l’adaptateur de test référencé dans vos projets Visual Studio vers la version prise en charge ?Why does Live Unit Testing show incorrect coverage after you upgrade the test adapter referenced in your Visual Studio Projects to the supported version?

  • Si plusieurs projets de la solution font référence au package de l’adaptateur de test NuGet, chacun d’eux doit être mis à niveau vers la version prise en charge.If multiple projects in the solution reference the NuGet test adapter package, each of them must be upgraded to the supported version.

  • Vérifiez que le fichier .props MSBuild importé à partir du package de l’adaptateur de test est mis à jour correctement.Make sure the MSBuild .props file imported from the test adapter package is correctly updated as well. Vérifiez la version/le chemin du package NuGet de l’importation, qui figure généralement vers le haut du fichier projet, comme suit :Check the NuGet package version/path of the import, which can usually be found near the top of the project file, like the following:

     <Import Project="..\packages\xunit.runner.visualstudio.2.2.0\build\net20\xunit.runner.visualstudio.props" Condition="Exists('..\packages\xunit.runner.visualstudio.2.2.0\build\net20\xunit.runner.visualstudio.props')" />
    

Personnaliser des buildsCustomize builds

Est-il possible de personnaliser les builds Live Unit Testing ?Can I customize my Live Unit Testing builds?

Si votre solution nécessite des étapes personnalisées de génération pour l’instrumentation (Live Unit Testing) qui ne sont pas nécessaires pour la génération non instrumentée « standard », vous pouvez ajouter du code à vos fichiers projet ou .targets pour vérifier la propriété BuildingForLiveUnitTesting et effectuer les étapes personnalisées avant et après la génération.If your solution requires custom steps to build for instrumentation (Live Unit Testing) that are not required for the "regular" non-instrumented build, then you can add code to your project or .targets files that checks for the BuildingForLiveUnitTesting property and performs custom pre/post build steps. Vous pouvez également choisir de supprimer certaines étapes de génération (telles que la publication ou la génération de packages) ou d’ajouter des étapes de génération (par exemple, la copie des composants requis) pour une build Live Unit Testing basée sur cette propriété de projet.You can also choose to remove certain build steps (like publishing or generating packages) or to add build steps (like copying prerequisites) to a Live Unit Testing build based on this project property. Le fait de personnaliser votre build avec cette propriété ne modifie pas votre build et impacte uniquement les builds Live Unit Testing.Customizing your build based on this property does not alter your regular build in any way, and only impacts Live Unit Testing builds.

Par exemple, vous pouvez avoir une cible qui génère des packages NuGet dans le cadre d’une build standard.For example, there may be a target that produces NuGet packages during a regular build. Vous préférerez sans doute éviter que des packages NuGet soient générés après chaque modification que vous effectuez.You probably do not want NuGet packages to be generated after every edit you make. Ainsi, vous pouvez désactiver cette cible dans la build Live Unit Testing en procédant comme suit :So you can disable that target in the Live Unit Testing build by doing something like the following:

<Target Name="GenerateNuGetPackages" BeforeTargets="AfterBuild" Condition="'$(BuildingForLiveUnitTesting)' != 'true'">
    <Exec Command='"$(MSBuildThisFileDirectory)..\tools\GenPac" '/>
</Target>

Messages d’erreur avec <OutputPath> ou <OutDir>Error messages with <OutputPath> or <OutDir>

Pourquoi l’erreur suivante s’affiche-t-elle quand Live Unit Testing tente de générer ma solution : « ... appears to unconditionally set <OutputPath> or <OutDir>. Live Unit Testing will not execute tests from the output assembly » ?Why do I get the following error when Live Unit Testing tries to build my solution: "...appears to unconditionally set <OutputPath> or <OutDir>. Live Unit Testing will not execute tests from the output assembly"?

Cette erreur peut se produire si le processus de génération de votre solution remplace sans condition <OutputPath> ou <OutDir> afin qu’il ne soit pas un sous-répertoire de <BaseOutputPath>.You can get this error if the build process for your solution unconditionally overrides <OutputPath> or <OutDir> so that it is not a subdirectory of <BaseOutputPath>. Dans ce cas, Live Unit Testing ne fonctionnera pas, car il remplace également ces valeurs pour garantir que les artefacts de build soient placés dans un dossier sous <BaseOutputPath>.In such cases, Live Unit Testing will not work because it also overrides these values to ensure that build artifacts are dropped to a folder under <BaseOutputPath>. Si vous devez remplacer l’emplacement où vous souhaitez déplacer vos artéfacts de build dans le cadre d’une build standard, remplacez <OutputPath> sous condition en fonction de <BaseOutputPath>.If you must override the location where you want your build artifacts to be dropped in a regular build, override the <OutputPath> conditionally based on <BaseOutputPath>.

Par exemple, si votre build remplace le <OutputPath> comme indiqué ci-dessous :For example, if your build overrides the <OutputPath> as shown below:

<Project>
  <PropertyGroup>
    <OutputPath>$(SolutionDir)Artifacts\$(Configuration)\bin\$(MSBuildProjectName)</OutputPath>
  </PropertyGroup>
</Project>

Ensuite, vous pouvez le remplacer par le code XML suivant :then you can replace it with the following XML:

<Project>
  <PropertyGroup>
    <BaseOutputPath Condition="'$(BaseOutputPath)' == ''">$(SolutionDir)Artifacts\$(Configuration)\bin\$(MSBuildProjectName)\</BaseOutputPath>
    <OutputPath Condition="'$(OutputPath)' == ''">$(BaseOutputPath)</OutputPath>
  </PropertyGroup>
</Project>

Vous avez ainsi la garantie que <OutputPath> se trouvera dans le dossier <BaseOutputPath>.This ensures that <OutputPath> lies within the <BaseOutputPath> folder.

Ne remplacez pas <OutDir> directement dans votre processus de génération ; remplacez plutôt <OutputPath> pour placer les artéfacts de build à un emplacement spécifique.Do not override <OutDir> directly in your build process; override <OutputPath> instead to drop build artifacts to a specific location.

Définir l’emplacement des artefacts de buildSet the location of build artifacts

J’aimerais que les artefacts d’une build Live Unit Testing soient placés à un emplacement spécifique au lieu de l’emplacement par défaut, sous le dossier .vs. Comment modifier cet emplacement ?I want the artifacts of a Live Unit Testing build to go to a specific location instead of the default location under the .vs folder. How can I change that?

Définissez la variable d’environnement de niveau utilisateur LiveUnitTesting_BuildRoot sur le chemin d’accès où vous souhaitez déposer les artéfacts de build Live Unit Testing.Set the LiveUnitTesting_BuildRoot user-level environment variable to the path where you want the Live Unit Testing build artifacts to be dropped.

Explorateur de tests et séries de tests Live Unit TestingTest Explorer vs. Live Unit Testing test runs

En quoi les tests exécutés dans la fenêtre de l’Explorateur de tests sont-ils différents de ceux exécutés dans Live Unit Testing ?How is running tests from Test Explorer window different from running tests in Live Unit Testing?

Il existe plusieurs différences :There are several differences:

  • L’exécution ou le débogage des tests depuis la fenêtre de l’Explorateur de tests exécute des fichiers binaires réguliers, tandis que Live Unit Testing exécute des fichiers binaires instrumentés.Running or debugging tests from the Test Explorer window runs regular binaries, whereas Live Unit Testing runs instrumented binaries. Si vous souhaitez déboguer des fichiers binaires instrumentés, l’ajout d’un appel de méthode Debugger.Launch dans votre méthode de test a pour effet de lancer le débogueur à chaque exécution de la méthode (y compris lorsqu’elle est exécutée par Live Unit Testing), après quoi vous pouvez attacher et déboguer le fichier binaire instrumenté.If you want to debug instrumented binaries, adding a Debugger.Launch method call in your test method causes the debugger to launch whenever that method is executed (including when it is executed by Live Unit Testing), and you can then attach and debug the instrumented binary. Nous espérons cependant que l’instrumentation soit pour vous parfaitement transparente dans la plupart des scénarios utilisateur, et que vous n’ayez pas besoin de déboguer de fichiers binaires instrumentés.However, our hope is that instrumentation is transparent to you for most user scenarios, and that you do not need to debug instrumented binaries.

  • Live Unit Testing ne crée pas de nouveau domaine d’application pour exécuter des tests, contrairement aux tests exécutés à partir de la fenêtre Explorateur de tests.Live Unit Testing does not create a new application domain to run tests, but tests run from the Test Explorer window do create a new application domain.

  • Live Unit Testing exécute des tests dans chaque assembly de test de façon séquentielle. Si vous exécutez plusieurs tests à partir de la fenêtre Explorateur de tests et que vous avez sélectionné le bouton Exécuter les tests en parallèle, ces tests s’exécuteront en parallèle.Live Unit Testing runs tests in each test assembly sequentially, whereas if you run multiple tests from the Test Explorer window and you selected the Run Tests in Parallel button, they will run in parallel.

  • La découverte et l’exécution de tests dans Live Unit Testing utilisent la version 2 de TestPlatform, tandis que la fenêtre Explorateur de tests utilise la version 1.Discovery and execution of tests in Live Unit Testing uses version 2 of TestPlatform, whereas the Test Explorer window uses version 1. Toutefois, dans la plupart des cas, vous ne devriez remarquer aucune différence.You won't notice a difference in most cases, though.

  • L’Explorateur de tests exécute des tests dans un seul thread cloisonné (STA) par défaut, tandis que Live Unit Testing exécute les tests dans plusieurs threads cloisonnés (MTA).Test Explorer currently runs tests in a single-threaded apartment (STA) by default, whereas Live Unit Testing runs tests in a multithreaded apartment (MTA). Pour exécuter les tests MSTest dans un STA dans Live Unit Testing, complétez la méthode de test ou la classe de conteneur avec l’attribut <STATestMethod> ou <STATestClass> qui se trouve dans le package NuGet MSTest.STAExtensions 1.0.3-beta.To run MSTest tests in STA in Live Unit Testing, decorate the test method or the containing class with the <STATestMethod> or <STATestClass> attribute that can be found in the MSTest.STAExtensions 1.0.3-beta NuGet package. Pour NUnit, complétez la méthode de test avec l’attribut <RequiresThread(ApartmentState.STA)>, et pour xUnit, avec l’attribut <STAFact>.For NUnit, decorate the test method with the <RequiresThread(ApartmentState.STA)> attribute, and for xUnit, with the <STAFact> attribute.

Exclure des testsExclude tests

Comment exclure des tests de Live Unit Testing ?How do I exclude tests from participating in Live Unit Testing?

Consultez la section « Inclure et exclure des projets de test et des méthodes de test » de l’article Utiliser Live Unit Testing dans Visual Studio 2017 Enterprise Edition pour connaître les paramètres spécifiques à l’utilisateur.See the "Include and exclude test projects and test methods" section of the Use Live Unit Testing in Visual Studio 2017 Enterprise Edition article for the user-specific setting. L’inclusion et l’exclusion de tests s’avèrent utiles quand vous souhaitez exécuter un ensemble spécifique de tests pour une session de modification particulière ou pour conserver vos préférences personnelles.Including or excluding tests is useful when you want to run a specific set of tests for a particular edit session or to persist your own personal preferences.

Pour les paramètres spécifiques à la solution, vous pouvez, à l’aide d’un programme, appliquer l’attribut System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute pour empêcher que des méthodes, des propriétés, des classes ou des structures soient instrumentées par Live Unit Testing.For solution-specific settings, you can apply the System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute attribute programmatically to exclude methods, properties, classes, or structures from being instrumented by Live Unit Testing. En outre, vous pouvez également définir la propriété <ExcludeFromCodeCoverage> sur true dans votre fichier projet pour exclure de l’instrumentation l’ensemble du projet.Additionally, you can also set the <ExcludeFromCodeCoverage> property to true in your project file to exclude the whole project from being instrumented. Live Unit Testing continue d’exécuter les tests qui n’ont pas été instrumentés, mais leur couverture n’est pas affichée.Live Unit Testing will still run the tests that have not been instrumented, but their coverage will not be visualized.

Vous pouvez également vérifier si Microsoft.CodeAnalysis.LiveUnitTesting.Runtime est chargé dans le domaine d’application actuel et désactiver les tests selon le résultat.You can also check whether Microsoft.CodeAnalysis.LiveUnitTesting.Runtime is loaded in the current application domain and disable tests based on why. Par exemple, vous pouvez procéder de cette manière avec xUnit :For example, you can do something like the following with xUnit:

[ExcludeFromCodeCoverage]
public class SkipLiveFactAttribute : FactAttribute
{
   private static bool s_lutRuntimeLoaded = AppDomain.CurrentDomain.GetAssemblies().Any(a => a.GetName().Name ==
                                            "Microsoft.CodeAnalysis.LiveUnitTesting.Runtime");
   public override string Skip => s_lutRuntimeLoaded ? "Test excluded from Live Unit Testing" : "";
}

public class Class1
{
   [SkipLiveFact]
   public void F()
   {
      Assert.True(true);
   }
}

En-têtes PE Win32Win32 PE headers

Pourquoi les en-têtes PE Win32 sont-ils différents dans les assemblys instrumentés générés par Live Unit Testing ?Why are Win32 PE headers different in instrumented assemblies built by Live Unit testing?

Ce problème est résolu et n’existe pas dans Visual Studio 2017 version 15.3.This issue is fixed and does not exist in Visual Studio 2017 version 15.3. Effectuez une mise à niveau vers cette version de Visual Studio.Upgrade to this version of Visual Studio.

Pour les précédentes versions de Visual Studio 2017, il existe un bogue connu qui peut empêcher les builds Live Unit Testing d’incorporer les données de l’en-tête PE Win32 suivantes :For older versions of Visual Studio 2017, there is a known bug that may result in Live Unit Testing builds failing to embed the following Win32 PE Header data:

  • Version de fichier (spécifiée par AssemblyFileVersionAttribute dans le code).File Version (specified by AssemblyFileVersionAttribute in code).

  • Icône Win32 (spécifiée par /win32icon: sur la ligne de commande).Win32 Icon (specified by /win32icon: on the command line).

  • Manifeste Win32 (spécifié par /win32manifest: sur la ligne de commande).Win32 Manifest (specified by /win32manifest: on the command line).

Les tests qui reposent sur ces valeurs peuvent échouer lorsqu’ils sont exécutés par Live Unit Testing.Tests that rely on these values may fail when executed by Live Unit testing.

Builds en continuContinuous builds

Pourquoi Live Unit Testing ne cesse-t-il de générer ma solution, même si je n’y apporte aucune modification ?Why does Live Unit testing keep building my solution all the time even if I am not making any edits?

Votre solution peut être générée même si vous n’apportez pas de modifications, si le processus de génération de votre solution génère un code source qui fait partie de la solution elle-même, et si les fichiers cibles de la build n’ont ni les entrées appropriées ni les sorties spécifiées.Your solution can build even if you're not making edits if the build process of your solution generates source code that is part of the solution itself, and your build target files do not have appropriate inputs and outputs specified. Les cibles doivent disposer d’une liste d’entrées et de sorties afin que MSBuild puisse effectuer les contrôles à jour appropriés et déterminer si une nouvelle build est requise.Targets should be given a list of inputs and outputs so that MSBuild can perform the appropriate up-to-date checks and determine whether a new build is required.

Live Unit Testing démarre une build chaque fois qu’il détecte une modification des fichiers sources.Live Unit Testing starts a build whenever it detects that source files have changed. Étant donné que la génération de votre solution génère des fichiers sources, Live Unit Testing obtient une boucle de génération infinie.Because the build of your solution generates source files, Live Unit Testing will get into an infinite build loop. Si, toutefois, les entrées et sorties de la cible sont vérifiées lorsque Live Unit Testing démarre la deuxième génération (après la détection des fichiers sources qui viennent d’être générés à partir de la build précédente), il quittera la boucle de génération puisque les vérifications des entrées et des sorties indiquent que tout est à jour.If, however, the inputs and outputs of the target are checked when Live Unit Testing starts the second build (after detecting the newly generated source files from the previous build), it will break out of the build loop because the inputs and outputs checks will indicate that everything is up-to-date.

Chargement de solution allégéLightweight solution load

Comment fonctionne Live Unit Testing avec le chargement de solution allégé ?How does Live Unit testing work with the lightweight solution load feature?

Actuellement, Live Unit Testing ne fonctionne pas correctement avec la fonctionnalité de chargement de solution allégé.Live Unit Testing currently doesn't work well with the lightweight solution load feature. Son fonctionnement n’est normal qu’après le chargement d’au moins un des projets de test.It works only after at least one of the test projects is loaded. Il ne peut pas en être autrement, car Live Unit Testing dépend au moins d’un des projets de test référençant un adaptateur de test (MSTest, xUnit ou NUnit) en cours de chargement.Until then, it won't work because Live Unit Testing is dependent on at least one of the test projects referencing a test adapter (MSTest, xUnit, or NUnit) being loaded.

Note

Le chargement de solution allégé n’est plus disponible dans la version 15.5 et les versions ultérieures de Visual Studio 2017,Lightweight solution load is no longer available in Visual Studio 2017 version 15.5 and later. dans lesquelles les solutions volumineuses qui contiennent du code managé se chargent beaucoup plus vite qu’avant, même sans utiliser le chargement de solution allégé.In Visual Studio 2017 version 15.5 and later, large solutions that contain managed code load much faster than previously, even without lightweight solution load.

Nouvelle couverture de processusNew process coverage

Pourquoi Live Unit Testing ne capture-t-il pas la couverture à partir d’un nouveau processus créé par un test ?Why doesn't Live Unit Testing capture coverage from a new process created by a test?

Il s’agit d’un problème connu qui devrait être corrigé dans une prochaine mise à jour de Visual Studio 2017.This is a known issue and should be fixed in a subsequent update of Visual Studio 2017.

L’inclusion ou l’exclusion de tests ne fonctionne pasIncluding or Excluding tests not working

Pourquoi rien ne se produit lorsque j’inclus ou exclus des tests à partir du jeu Live Test ?Why does nothing happen after I include or exclude tests from the Live Test set?

Ce problème est résolu et n’existe pas dans Visual Studio 2017 version 15.3.This issue is fixed and does not exist in Visual Studio 2017 version 15.3. Effectuez une mise à niveau vers cette version de Visual Studio.Upgrade to this version of Visual Studio.

Il s’agit d’un problème connu dans les versions antérieures de Visual Studio 2017.For older versions of Visual Studio 2017, this is a known issue. Pour contourner ce problème, vous devez apporter une modification à un fichier après avoir inclus ou exclu des tests.To work around this issue, you will need to make an edit to any file after you have included or excluded tests.

Icônes de l’éditeurEditor icons

Pourquoi les icônes ne sont-elles pas visibles dans l’éditeur, alors que Live Unit Testing semble exécuter les tests à partir des messages de la fenêtre Sortie ?Why do I not see any icons in the editor even though Live Unit Testing seems to be running the tests based on the messages in the Output window?

Les icônes ne sont pas visibles dans l’éditeur si les assemblys sur lesquels agit Live Unit Testing ne sont pas instrumentés pour une raison quelconque.You might not see icons in the editor if the assemblies that Live Unit Testing is operating on aren't instrumented for any reason. Par exemple, Live Unit Testing n’est pas compatible avec les projets qui définissent <UseHostCompilerIfAvailable>false</UseHostCompilerIfAvailable>.For example, Live Unit Testing is not compatible with projects that set <UseHostCompilerIfAvailable>false</UseHostCompilerIfAvailable>. Dans ce cas, votre processus de build doit être mis à jour pour supprimer ce paramètre ou le modifier en true afin de permettre à Live Unit Testing de fonctionner.In this case, your build process needs to be updated to either remove this setting or to change it to true for Live Unit Testing to work.

Capturer les journauxCapture logs

Comment collecter des journaux plus détaillés pour les rapports de bogues de fichiers ?How do I collect more detailed logs to file bug reports?

Vous pouvez collecter des journaux plus détaillés de plusieurs manières :You can do several things to collect more detailed logs:

  • Accédez à Outils > Options > Live Unit Testing et définissez l’option de journalisation sur Détaillé.Go to Tools > Options > Live Unit Testing and change the logging option to Verbose. La journalisation détaillée fournit des journaux plus détaillés dans la fenêtre Sortie.Verbose logging causes more detailed logs to be shown in the Output window.

  • Définissez la variable d’environnement utilisateur LiveUnitTesting_BuildLog sur le nom du fichier que vous souhaitez utiliser pour capturer le journal MSBuild.Set the LiveUnitTesting_BuildLog user environment variable to the name of the file you want to use to capture the MSBuild log. Vous pourrez ensuite récupérer à partir de ce fichier les messages détaillés du journal MSBuild compilé à partir des builds Live Unit Testing.Detailed MSBuild log messages from Live Unit Testing builds can then be retrieved from that file.

  • Affectez à la variable d’environnement utilisateur LiveUnitTesting_TestPlatformLog la valeur 1 pour capturer le journal de la plateforme de test.Set the LiveUnitTesting_TestPlatformLog user environment variable to 1 to capture the Test Platform log. Vous pourrez ensuite récupérer à partir de [Solution Root]\.vs\[Solution Name]\log\[VisualStudio Process ID] les messages détaillés de la plateforme de test issus des séries de tests Live Unit Testing.Detailed Test Platform log messages from Live Unit Testing runs can then be retrieved from [Solution Root]\.vs\[Solution Name]\log\[VisualStudio Process ID].

  • Créez une variable d’environnement de niveau utilisateur nommée VS_UTE_DIAGNOSTICS et affectez-lui la valeur 1 (ou n’importe quelle valeur), puis redémarrez Visual Studio.Create a user-level environment variable named VS_UTE_DIAGNOSTICS and set it to 1 (or any value) and restart Visual Studio. L’onglet Sortie - Tests de Visual Studio devrait maintenant contenir un nombre important de consignations.Now you should see lots of logging in the Output - Tests tab in Visual Studio.

Voir aussiSee also