Comment exécuter NUnit par programme

Question

J'ai un assembly qui fait référence à NUnit et crée une seule classe de test avec une seule méthode de test. Je suis en mesure d'obtenir le chemin d'accès du système de fichiers à cet assembly (par exemple "C: ... \ test.dll"). Je voudrais utiliser par programme NUnit pour fonctionner contre cet assembly.

Jusqu'à présent, j'ai:

var runner = new SimpleTestRunner(); 
runner.Load(path); 
var result = runner.Run(NullListener.NULL); 

Toutefois, l'appel runner.Load (chemin) renvoie une exception FileNotFound. Je peux voir à travers la trace de la pile que le problème est avec NUnit appelant Assembly.Load (chemin) en bas de la pile. Si je change le chemin pour être quelque chose comme "Test, Version = 1.0.0.0, Culture = neutre, PublicKeyToken = null" alors je reçois toujours la même erreur.

J'ai ajouté un gestionnaire d'événements à AppDomain.Current.AssemblyResolve pour voir si je pouvais résoudre manuellement ce type mais mon gestionnaire n'est jamais appelé.

Quel est le secret pour obtenir Assembly.Load (...) au travail?

Answer 1

Si vous souhaitez ouvrir en mode console , ajouter nunit-console-runner.dll référence et utilisation:

NUnit.ConsoleRunner.Runner.Main(new string[] 
    { 
     System.Reflection.Assembly.GetExecutingAssembly().Location, 
    }); 

Si vous souhaitez ouvrir dans un mode de IUG, ajouter nunit-IUG-runner.dll référence et utilisation:

NUnit.Gui.AppEntry.Main(new string[] 
    { 
     System.Reflection.Assembly.GetExecutingAssembly().Location, 
     "/run" 
    }); 

C'est la meilleure approche parce que vous ne VHA pas e pour spécifier un chemin.

Une autre option est d'intégrer coureur NUnit dans la sortie du débogueur Visual Studio:

public static void Main() 
{ 
    var assembly = Assembly.GetExecutingAssembly().FullName; 
    new TextUI (new DebugTextWriter()).Execute(new[] { assembly, "-wait" }); 
} 

public class DebugTextWriter : StreamWriter 
{ 
    public DebugTextWriter() 
     : base(new DebugOutStream(), Encoding.Unicode, 1024) 
    { 
     this.AutoFlush = true; 
    } 

    class DebugOutStream : Stream 
    { 
     public override void Write(byte[] buffer, int offset, int count) 
     { 
      Debug.Write(Encoding.Unicode.GetString(buffer, offset, count)); 
     } 

     public override bool CanRead { get { return false; } } 
     public override bool CanSeek { get { return false; } } 
     public override bool CanWrite { get { return true; } } 
     public override void Flush() { Debug.Flush(); } 
     public override long Length { get { throw new InvalidOperationException(); } } 
     public override int Read(byte[] buffer, int offset, int count) { throw new InvalidOperationException(); } 
     public override long Seek(long offset, SeekOrigin origin) { throw new InvalidOperationException(); } 
     public override void SetLength(long value) { throw new InvalidOperationException(); } 
     public override long Position 
     { 
      get { throw new InvalidOperationException(); } 
      set { throw new InvalidOperationException(); } 
     } 
    }; 
} 

Answer 2

"Quel est le secret pour faire fonctionner Assembly.Load?" System.Reflection.Assembly.Load prend une chaîne contenant un nom d'assembly, pas un chemin d'accès à un fichier.

Si vous voulez charger un assemblage d'une utilisation du fichier:

Assembly a = System.Reflection.Assembly.LoadFrom(pathToFileOnDisk); 

(LoadFrom utilise en fait Assembly.Load interne)

Soit dit en passant, est-il une raison pour laquelle vous pouvez; t utiliser le NUnit-Console command line tool et il suffit de passer le chemin de votre ensemble de test? Vous pourriez alors simplement utiliser le System.Diagnostics.Process pour l'exécuter à partir de votre application client, pourrait être plus simple?