Pernyataan MSTest

Gunakan kelas dari namespace Assert untuk memverifikasi fungsionalitas tertentu. Metode pengujian menjalankan kode dalam aplikasi Anda tetapi melaporkan kebenaran hanya saat Anda menyertakan Assert pernyataan.

Gambaran Umum

MSTest menyediakan tiga kelas pernyataan:

Class Tujuan
Assert Pernyataan tujuan umum untuk nilai, jenis, dan pengecualian.
StringAssert Pernyataan khusus string untuk pola, substring, dan perbandingan.
CollectionAssert Pernyataan pengumpulan untuk membandingkan dan memvalidasi koleksi.

Penting

Untuk kode baru, selalu gunakan Assert kelas . Kelas StringAssert dan CollectionAssert kemungkinan tidak digunakan lagi dalam rilis mendatang. Mereka dipertahankan terutama demi kompatibilitas ke belakang, tetapi tidak direkomendasikan karena memisahkan asersi ke dalam tiga jenis menyulitkan penemuan.

Semua metode pernyataan menerima parameter pesan opsional yang ditampilkan saat pernyataan gagal, membantu Anda mengidentifikasi penyebabnya:

Assert.AreEqual(expected, actual, "Values should match after processing");

Kelas Assert

Assert Gunakan kelas untuk memverifikasi bahwa kode yang sedang diuji berulah seperti yang diharapkan.

Nota

Dimulai dengan MSTest 4.0, semua Assert API mengambil ekspresi argumen dan menyertakannya dalam pesan kegagalan. Dukungan ini menyediakan diagnostik yang lebih kaya tanpa parameter manual message .

Metode pernyataan umum

[TestMethod]
public async Task AssertExamples()
{
    // Equality
    Assert.AreEqual(5, calculator.Add(2, 3));
    Assert.AreNotEqual(0, result);

    // Reference equality
    Assert.AreSame(expected, actual);
    Assert.AreNotSame(obj1, obj2);

    // Boolean conditions
    Assert.IsTrue(result > 0);
    Assert.IsFalse(string.IsNullOrEmpty(name));

    // Null checks
    Assert.IsNull(optionalValue);
    Assert.IsNotNull(requiredValue);

    // Type checks
    Assert.IsInstanceOfType<IDisposable>(obj);
    Assert.IsNotInstanceOfType<string>(obj);

    // Exception testing (MSTest v3.8+)
    Assert.ThrowsExactly<ArgumentNullException>(() => service.Process(null!));
    await Assert.ThrowsExactlyAsync<InvalidOperationException>(
        async () => await service.ProcessAsync());
}

Metode Assert.That

Dimulai dengan MSTest 4.0, Assert.That mengevaluasi ekspresi Boolean apa pun dan menghasilkan pesan kegagalan yang jelas. Untuk diagnostik yang lebih kaya, Assert.That gunakan [CallerArgumentExpression] untuk mengambil teks ekspresi secara otomatis.

Assert.That(order.Total > 0);

API yang Tersedia

Nota

Dimulai dengan MSTest 3.8, pernyataan koleksi meliputi Assert.Contains, , Assert.DoesNotContain, Assert.HasCountAssert.IsEmpty, Assert.IsNotEmpty, dan Assert.ContainsSingle.

Dimulai dengan MSTest 3.10, pernyataan perbandingan termasuk Assert.IsInRange, , Assert.IsGreaterThan, Assert.IsGreaterThanOrEqualTo, Assert.IsLessThanAssert.IsLessThanOrEqualTo, Assert.IsPositive, dan Assert.IsNegative.

Dimulai dengan MSTest 3.10, pernyataan pencocokan string meliputi Assert.StartsWith, , Assert.EndsWith, Assert.MatchesRegex, Assert.DoesNotStartWith, Assert.DoesNotEndWith, dan Assert.DoesNotMatchRegex.

Dimulai dengan MSTest 4.1, Assert.IsExactInstanceOfType dan Assert.IsNotExactInstanceOfType memerlukan kecocokan jenis yang tepat. Tidak seperti Assert.IsInstanceOfType, metode ini tidak cocok dengan jenis turunan.

Asersi koleksi dan ekivalensi baru di MSTest 4.3

Nota

Metode pernyataan berikut diperkenalkan dalam MSTest 4.3.0.

  • Assert.AreSequenceEqual / Assert.AreNotSequenceEqual — perbandingan sekuens per elemen. Loloskan SequenceOrder.InAnyOrder untuk mengabaikan urutan elemen.
  • Assert.AreEquivalent / Assert.AreNotEquivalent — perbandingan struktural mendalam dari dua objek atau koleksi.
  • Assert.ContainsAll / Assert.DoesNotContainAll — menegaskan bahwa koleksi berisi (atau tidak berisi) setiap elemen yang diharapkan.
  • Assert.AreAllNotNull — menegaskan bahwa setiap elemen koleksi adalah non-null.
  • Assert.AreAllDistinct — menegaskan bahwa semua elemen koleksi berbeda.
  • Assert.AreAllOfType — menegaskan bahwa setiap elemen koleksi adalah jenis yang diharapkan.

Saat membandingkan koleksi, lebih suka metode ini daripada Assert.AreEqual, yang membandingkan referensi daripada elemen.

MSTest 4.3 juga menambahkan:

  • API eksperimental Assert.AddValueFormatter untuk menyesuaikan cara nilai ditampilkan dalam pesan kegagalan assertion.
  • Span<T> dan Memory<T> kelebihan beban untuk Assert.HasCount.
  • Pesan kegagalan asersi terstruktur untuk Assert.IsTrue, Assert.IsFalse, Assert.IsNull, dan Assert.IsNotNull yang menyertakan ekspresi yang dievaluasi.
  • Kelebihan beban pesan string terinterpolasi untuk metode async Assert.ThrowsAsync/Assert.ThrowsExactlyAsync, dan penolakan delegasi yang mengembalikan ValueTask<TResult> yang jika tidak demikian tidak akan di-await.
  • Detail lengkap pengecualian, termasuk stack trace dan pengecualian internal, dalam pesan kegagalan Assert.Throws*.
  • Tumpukan kegagalan pernyataan yang menyembunyikan bingkai implementasi MSTest dan merender nilai numerik bawaan dengan presisi penuh.

Penting

Overload asersi berikut direncanakan untuk MSTest 4.4 dan hanya tersedia dalam versi pratinjau sampai MSTest 4.4.0 dirilis.

MSTest 4.4 menambahkan rentang dan kelebihan memori ke Assert.IsEmpty, Assert.IsNotEmpty, dan API koleksi yang tersisa. Overload ini menerima Span<T>, ReadOnlySpan<T>, Memory<T>, dan ReadOnlyMemory<T>:

  • Pemeriksaan semua item: AreAllDistinct, AreAllNotNull, dan AreAllOfType.
  • Perbandingan: AreEquivalent, AreNotEquivalent, AreSequenceEqual, dan AreNotSequenceEqual.
  • Penahanan: Contains, ContainsAll, ContainsSingle, DoesNotContain, dan DoesNotContainAll.

Dengan pratinjau MSTest 4.4 dan MTP 2.4, IDE dan reporter yang mendukung menerima nilai yang diharapkan dan nilai aktual dari asersi sebagai properti terstruktur yang terpisah. Konsumen tidak perlu mengurai nilai-nilai ini dari pesan kegagalan.

Assert.AddValueFormatter mengembalikan sebuah registrasi IDisposable. Hapus registrasi untuk menghapus pemformat. Formatter hanya berlaku untuk konteks asinkron saat ini, sehingga pengujian paralel dapat menggunakan formatter yang berbeda tanpa mengubah output satu sama lain. Karena API bersifat eksperimental di MSTest 4.3, akui atau nonaktifkan diagnostik MSTESTEXP sebelum Anda menggunakannya.

Asersi lunak dengan Assert.Scope()

Penting

Assert.Scope() adalah API eksperimental. Menggunakannya menghasilkan diagnostik MSTESTEXP, yang Anda nonaktifkan (misalnya, dengan #pragma warning disable MSTESTEXP atau dalam file .editorconfig proyek Anda) sebagai pengakuan bahwa bentuk dan perilaku API dapat berubah pada rilis mendatang.

Secara bawaan, setiap asersi akan melemparkan AssertFailedException segera setelah gagal, sehingga pengujian langsung berakhir. Assert.Scope() memperkenalkan asersi lunak: selama suatu cakupan aktif, kegagalan asersi dikumpulkan alih-alih dilempar, sehingga eksekusi tetap berlanjut dan Anda dapat melihat semua kegagalan dalam cakupan tersebut sekaligus. Ketika ruang lingkup dilepas, kegagalan yang dikumpulkan dilaporkan sekaligus:

[TestMethod]
public void ValidatePerson()
{
    using (Assert.Scope())
    {
        Assert.AreEqual("Jane", person.FirstName); // failure collected, execution continues
        Assert.AreEqual("Doe", person.LastName);   // failure collected, execution continues
        Assert.IsTrue(person.IsActive);            // failure collected, execution continues
    }
    // On Dispose, all collected failures are reported together.
}

Ketika lingkup dilepas:

  • Jika tepat satu kegagalan dikumpulkan, yang asli AssertFailedException akan dilemparkan.
  • Jika beberapa kegagalan dikumpulkan, satu AssertFailedException akan dilempar yang membungkus semuanya dalam AggregateException.

Kondisi pasca tidak diterapkan di dalam cakupan

Karena asersi yang gagal tidak lagi melempar pengecualian di dalam suatu cakupan, kode yang dijalankan setelahnya tidak dapat mengandalkan bahwa asersi tersebut telah berhasil. Ini berlaku untuk setiap pascakondisi, termasuk kemungkinan bernilai null dan penyempitan tipe:

using (Assert.Scope())
{
    Assert.IsNotNull(item);
    // 'item' might still be null here: the failure was collected, not thrown.
    Assert.AreEqual("expected", item.Value);
    // 'item.Value' might not equal "expected" either.
}

Jika pernyataan yang gagal akan menyebabkan NullReferenceException (atau pengecualian lainnya) pada baris selanjutnya dalam cakupan, pengecualian sekunder tersebut adalah gejala dari kegagalan yang sudah dikumpulkan, bukan bug terpisah. Kegagalan pernyataan asli masih dilaporkan ketika cakupan dibuang.

Asersi yang mengembalikan nilai akan mengembalikan null/default saat gagal di dalam cakupan

Beberapa pernyataan mengembalikan nilai pada keberhasilan—misalnya, Throws dan ThrowsExactly mengembalikan pengecualian yang tertangkap, dan ContainsSingle mengembalikan elemen yang cocok. Ketika salah satu asersi ini gagal di dalam cakupan, kegagalan tersebut dikumpulkan dan metode mengembalikan null/default alih-alih melempar pengecualian:

using (Assert.Scope())
{
    // No exception is thrown by the lambda, so the assertion fails. The failure is
    // collected and 'ex' is null. Accessing 'ex' below throws NullReferenceException.
    InvalidOperationException ex = Assert.Throws<InvalidOperationException>(() => { });
    _ = ex.Message; // NullReferenceException—don't use the return value in a scope
}

Jangan mengandalkan nilai yang dikembalikan oleh asersi lunak dalam cakupan. Jika Anda memerlukan nilai yang dikembalikan (seperti pengecualian yang tertangkap), panggil asersi di luar lingkup, atau atur ulang pengujian agar tidak ada yang bergantung pada nilai yang dikembalikan hingga lingkup selesai.

Assert.Fail dan Assert.Inconclusive selalu menghasilkan error

Fail dan Inconclusive tidak pernah lunak. Mereka selalu segera melemparkan, bahkan di dalam cakupan, karena mereka mengekspresikan hasil pengujian tanpa syarat. Gunakan salah satunya ketika kondisi kritis dan sisa pengujian tidak dapat bermakna dilanjutkan tanpanya.

Cakupan berlapis tidak didukung

Anda tidak dapat menyematkan panggilan Assert.Scope() di dalam panggilan lain. Hanya satu cakupan asersi yang dapat aktif dalam satu waktu.

Kelas StringAssert

StringAssertGunakan kelas untuk membandingkan dan memeriksa string.

Warning

Kelas StringAssert ini kemungkinan tidak digunakan lagi dalam rilis mendatang. Ini hanya dipertahankan untuk kompatibilitas mundur dan tidak direkomendasikan untuk kode baru. Semua StringAssert metode memiliki kesetaraan pada Assert kelas , yang menawarkan penemuan yang lebih baik. Untuk memigrasikan penggunaan yang sudah ada, lihat penganalisis MSTEST0046.

API yang tersedia adalah:

Kelas CollectionAssert

CollectionAssertGunakan kelas untuk membandingkan koleksi objek, atau untuk memverifikasi status koleksi.

Warning

Kelas CollectionAssert ini kemungkinan tidak digunakan lagi dalam rilis mendatang. Ini terutama dipertahankan untuk kompatibilitas ke belakang dan tidak direkomendasikan untuk kode baru. Ketika metode yang setara ada pada Assert (seperti Assert.Contains, , Assert.DoesNotContainatau Assert.HasCount), gunakan Assert untuk penemuan yang lebih baik.

API yang tersedia adalah:

Membuat pernyataan kustom dengan Assert.That

Metode pernyataan bawaan tidak mencakup setiap skenario. Untuk memperluas infrastruktur pernyataan dengan pemeriksaan Anda sendiri, MSTest mengekspos Assert.That properti singleton sebagai kait ekstensibilitas. Anda menambahkan asersi kustom sebagai metode ekstensi C# pada tipe instans Assert, dan pemanggil menggunakannya dengan sintaks Assert.That.MyAssertion(...) yang sudah familier.

Untuk penemuan yang lebih baik, atur pernyataan di seluruh proyek dalam kelas statis khusus. Pernyataan kustom yang dicapai melalui Assert.That muncul bersama metode bawaan di IntelliSense, sehingga konsumen tidak perlu mengingat jenis pembantu terpisah.

Menulis pernyataan kustom

Tambahkan metode ekstensi yang menargetkan tipe Assert dan melempar AssertFailedException ketika kondisinya tidak terpenuhi:

using System;
using System.Linq;
using Microsoft.VisualStudio.TestTools.UnitTesting;

public static class CustomAssertExtensions
{
    public static void IsPrime(this Assert assert, int value)
    {
        if (value < 2 || Enumerable.Range(2, (int)Math.Sqrt(value) - 1).Any(i => value % i == 0))
        {
            throw new AssertFailedException($"Assert.That.IsPrime failed. Value <{value}> is not a prime number.");
        }
    }
}

Menggunakan pernyataan kustom

Setelah Anda mengimpor namespace yang berisi metode ekstensi Anda, panggil pernyataan kustom Anda melalui Assert.That:

[TestMethod]
public void Compute_ReturnsPrime()
{
    int result = _calculator.NextPrime(10);
    Assert.That.IsPrime(result);
}

Kait ekstensi aktif StringAssert dan CollectionAssert

Properti StringAssert.That dan CollectionAssert.That menyediakan pola singleton yang sama untuk kompatibilitas ke belakang. Untuk pernyataan kustom baru, selalu targetkan Assert.That. Jika tidak, pembantu Anda mewarisi masalah penemuan yang sama dengan kelas warisan, dan mereka akan memerlukan migrasi jika StringAssert dan CollectionAssert tidak digunakan lagi.

Assert.That properti versus Assert.That(...) metode

Nota

Jangan bingungkan Assert.Thatproperti singleton—yang digunakan sebagai kait ekstensi—dengan Assert.That(() => condition)metode yang ditambahkan di MSTest 3.8. Yang terakhir menerima ekspresi Boolean dan menghasilkan pesan kegagalan terperinci dengan menganalisis pohon ekspresi (misalnya, Assert.That(() => order.Total > 0)). Kedua API berbagi nama tetapi melayani tujuan yang berbeda.

Praktik terbaik

  • Gunakan pernyataan tertentu: Lebih disukai AreEqual untuk memberikan IsTrue(a == b) pesan kegagalan yang lebih baik.

  • Menyertakan pesan deskriptif: Membantu mengidentifikasi kegagalan dengan cepat dengan pesan pernyataan yang jelas.

  • Uji satu per satu: Setiap metode pengujian harus memverifikasi satu perilaku.

  • Menggunakan Throws/ThrowsExactly untuk pengecualian: Di MSTest v3.8+, lebih suka Assert.Throws, Assert.ThrowsExactly, dan mitra asinkron mereka (ThrowsAsync, ThrowsExactlyAsync) daripada ExpectedException atribut .

  • Gunakan Assert alih-alih StringAssert/CollectionAssert: Agar lebih mudah ditemukan dan lebih konsisten, gunakan kelas Assert. Kelas StringAssert dan CollectionAssert kemungkinan tidak digunakan lagi dalam rilis mendatang.

  • Perluas Assert.That untuk pernyataan kustom: Untuk penemuan yang konsisten, tambahkan pernyataan kustom sebagai metode ekstensi pada Assert dan panggil melalui Assert.That. Jangan menargetkan StringAssert.That atau CollectionAssert.That dalam kode baru.

Penganalisis berikut membantu memastikan penggunaan pernyataan yang tepat:

  • MSTEST0006 - Hindari ExpectedException atribut, gunakan Assert.Throws metode sebagai gantinya.
  • MSTEST0017 - Argumen pernyataan harus diteruskan dalam urutan yang benar.
  • MSTEST0023 - Jangan meniadakan pernyataan boolean.
  • MSTEST0025 - Lebih suka Assert.Fail daripada kondisi yang selalu salah.
  • MSTEST0026 - Argumen pernyataan harus menghindari akses bersyarat.
  • MSTEST0032 - Tinjau kondisi pernyataan yang selalu benar.
  • MSTEST0037 - Gunakan metode pernyataan yang tepat.
  • MSTEST0038 - Hindari Assert.AreSame dengan tipe nilai.
  • MSTEST0039 - Gunakan metode yang lebih Assert.Throws baru.
  • MSTEST0040 - Hindari menggunakan assert dalam konteks async void.
  • MSTEST0046 - Gunakan Assert alih-alih StringAssert.
  • - Assert.Throws MSTEST0051 harus berisi satu pernyataan.
  • MSTEST0053 - Hindari Assert parameter format.
  • MSTEST0058 - Hindari penggunaan 'assert' dalam blok tangkapan.

Lihat juga

  • Last updated on