NUnit 2.4のClassic Assert Modelでの変更点(^o^)

NUnit 2.4では新しいConstraint-Based Assert Modelのインパクトが大きいが、従来のClassic Assert Modelでも、VSTSのテスティングフレームワークと同様のCollectionAssertクラスや、MbUnitと同様のFileAssertクラスが追加されており、かなり便利になっている。

以下にそれぞれのLearning Testを書いておく。

using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using NUnit.Framework;

namespace LearningNUnit.Tests.ClassicModel
{
  [TestFixture]
  public class CollectionAssertTest
  {
    [Test]
    public void 全ての要素の同型チェックが成功すべき()
    {
      List<object> list = new List<object>();
      list.Add(1);
      list.Add(2);
      CollectionAssert.AllItemsAreInstancesOfType(list, typeof(int));
    }

    [Test]
    [ExpectedException(typeof(AssertionException))]
    public void 全ての要素の同型チェックが失敗すべき()
    {
      List<object> list = new List<object>();
      list.Add(1);
      list.Add("Test");
      CollectionAssert.AllItemsAreInstancesOfType(list, typeof(int));
    }

    [Test]
    public void 要素がない場合は全ての要素の同型チェックが成功すべき()
    {
      CollectionAssert.AllItemsAreInstancesOfType(new List<object>(), typeof(object));
    }

    [Test]
    public void 全ての要素の非nullチェックが成功すべき()
    {
      List<object> list = new List<object>();
      list.Add(1);
      list.Add(2);
      CollectionAssert.AllItemsAreNotNull(list);
    }

    [Test]
    [ExpectedException(typeof(AssertionException))]
    public void 全ての要素の非nullチェックが失敗すべき()
    {
      List<object> list = new List<object>();
      list.Add(1);
      list.Add(null);
      CollectionAssert.AllItemsAreNotNull(list);
    }

    [Test]
    public void 要素がない場合は全ての要素の非nullチェックが成功すべき()
    {
      CollectionAssert.AllItemsAreNotNull(new List<object>());
    }

    [Test]
    public void 全ての要素の一意チェックが成功すべき()
    {
      List<int> list = new List<int>();
      list.Add(1);
      list.Add(2);
      CollectionAssert.AllItemsAreUnique(list);
    }

    [Test]
    [ExpectedException(typeof(AssertionException))]
    public void 全ての要素の一意チェックが失敗すべき()
    {
      List<int> list = new List<int>();
      list.Add(1);
      list.Add(1);
      CollectionAssert.AllItemsAreUnique(list);
    }

    [Test]
    public void 要素がない場合は全ての要素の一意チェックが成功すべき()
    {
      CollectionAssert.AllItemsAreUnique(new List<int>());
    }

    [Test]
    public void 同値チェックが成功すべき()
    {
      List<int> expected = new List<int>();
      expected.Add(1);
      expected.Add(2);
      List<int> actual = new List<int>();
      actual.Add(1);
      actual.Add(2);
      CollectionAssert.AreEqual(expected, actual);
    }

    [Test]
    [ExpectedException(typeof(AssertionException))]
    public void 同値チェックが失敗すべき()
    {
      List<int> expected = new List<int>();
      expected.Add(1);
      expected.Add(2);
      List<int> actual = new List<int>();
      actual.Add(2);
      actual.Add(1);
      CollectionAssert.AreEqual(expected, actual);
    }

    [Test]
    public void 要素がない場合は同値チェックが成功すべき()
    {
      CollectionAssert.AreEqual(new List<int>(), new List<int>());
    }

    [Test]
    public void 同等要素のチェックが成功すべき()
    {
      List<int> expected = new List<int>();
      expected.Add(1);
      expected.Add(2);
      List<int> actual = new List<int>();
      actual.Add(2);
      actual.Add(1);
      CollectionAssert.AreEquivalent(expected, actual);
    }

    [Test]
    [ExpectedException(typeof(AssertionException))]
    public void 同等要素のチェックが失敗すべき()
    {
      List<int> expected = new List<int>();
      expected.Add(1);
      expected.Add(2);
      List<int> actual = new List<int>();
      actual.Add(2);
      actual.Add(3);
      CollectionAssert.AreEquivalent(expected, actual);
    }

    [Test]
    public void 要素がない場合は同等要素のチェックが成功すべき()
    {
      CollectionAssert.AreEquivalent(new List<int>(), new List<int>());
    }

    [Test]
    public void 異値チェックが成功すべき()
    {
      List<int> expected = new List<int>();
      expected.Add(1);
      expected.Add(2);
      List<int> actual = new List<int>();
      actual.Add(2);
      actual.Add(1);
      CollectionAssert.AreNotEqual(expected, actual);
    }

    [Test]
    [ExpectedException(typeof(AssertionException))]
    public void 異値チェックが失敗すべき()
    {
      List<int> expected = new List<int>();
      expected.Add(1);
      expected.Add(2);
      List<int> actual = new List<int>();
      actual.Add(1);
      actual.Add(2);
      CollectionAssert.AreNotEqual(expected, actual);
    }

    [Test]
    [ExpectedException(typeof(AssertionException))]
    public void 要素がない場合は異値チェックが失敗すべき()
    {
      CollectionAssert.AreNotEqual(new List<int>(), new List<int>());
    }

    [Test]
    public void 非同等要素のチェックが成功すべき()
    {
      List<int> expected = new List<int>();
      expected.Add(1);
      expected.Add(2);
      List<int> actual = new List<int>();
      actual.Add(2);
      actual.Add(3);
      CollectionAssert.AreNotEquivalent(expected, actual);
    }

    [Test]
    [ExpectedException(typeof(AssertionException))]
    public void 非同等要素のチェックが失敗すべき()
    {
      List<int> expected = new List<int>();
      expected.Add(1);
      expected.Add(2);
      List<int> actual = new List<int>();
      actual.Add(2);
      actual.Add(1);
      CollectionAssert.AreNotEquivalent(expected, actual);
    }

    [Test]
    [ExpectedException(typeof(AssertionException))]
    public void 要素がない場合は非同等要素のチェックが失敗すべき()
    {
      CollectionAssert.AreNotEquivalent(new List<int>(), new List<int>());
    }

    [Test]
    public void 要素含有チェックが成功すべき()
    {
      List<int> list = new List<int>();
      list.Add(1);
      list.Add(2);
      CollectionAssert.Contains(list, 1);
      CollectionAssert.Contains(list, 2);
    }

    [Test]
    [ExpectedException(typeof(AssertionException))]
    public void 要素含有チェックが失敗すべき()
    {
      List<int> list = new List<int>();
      list.Add(1);
      list.Add(2);
      CollectionAssert.Contains(list, 3);
    }

    [Test]
    [ExpectedException(typeof(AssertionException))]
    public void 要素がない場合は要素含有チェックが失敗すべき()
    {
      CollectionAssert.Contains(new List<int>(), 0);
    }

    [Test]
    public void 要素非含有チェックが成功すべき()
    {
      List<int> list = new List<int>();
      list.Add(1);
      CollectionAssert.DoesNotContain(list, 2);
    }

    [Test]
    [ExpectedException(typeof(AssertionException))]
    public void 要素非含有チェックが失敗すべき()
    {
      List<int> list = new List<int>();
      list.Add(1);
      CollectionAssert.DoesNotContain(list, 1);
    }

    [Test]
    public void 要素がない場合は要素非含有チェックが成功すべき()
    {
      CollectionAssert.DoesNotContain(new List<int>(), 0);
    }

    [Test]
    public void 別のコレクションのサブセットかどうかのチェックが成功すべき()
    {
      List<int> subset = new List<int>();
      subset.Add(1);
      subset.Add(3);
      List<int> superset = new List<int>();
      superset.Add(1);
      superset.Add(2);
      superset.Add(3);
      CollectionAssert.IsSubsetOf(subset, superset);
    }

    [Test]
    [ExpectedException(typeof(AssertionException))]
    public void 別のコレクションのサブセットかどうかのチェックが失敗すべき()
    {
      List<int> subset = new List<int>();
      subset.Add(1);
      subset.Add(4);
      List<int> superset = new List<int>();
      superset.Add(1);
      superset.Add(2);
      superset.Add(3);
      CollectionAssert.IsSubsetOf(subset, superset);
    }

    [Test]
    public void 要素がない場合は別のコレクションのサブセットかどうかのチェックが成功すべき()
    {
      CollectionAssert.IsSubsetOf(new List<int>(), new List<int>());
    }

    [Test]
    public void 別のコレクションのサブセットでないかどうかのチェックが成功すべき()
    {
      List<int> subset = new List<int>();
      subset.Add(1);
      subset.Add(4);
      List<int> superset = new List<int>();
      superset.Add(1);
      superset.Add(2);
      superset.Add(3);
      CollectionAssert.IsNotSubsetOf(subset, superset);
    }

    [Test]
    [ExpectedException(typeof(AssertionException))]
    public void 別のコレクションのサブセットでないかどうかのチェックが失敗すべき()
    {
      List<int> subset = new List<int>();
      subset.Add(1);
      subset.Add(3);
      List<int> superset = new List<int>();
      superset.Add(1);
      superset.Add(2);
      superset.Add(3);
      CollectionAssert.IsNotSubsetOf(subset, superset);
    }

    [Test]
    [ExpectedException(typeof(AssertionException))]
    public void 要素がない場合は別のコレクションのサブセットでないかどうかのチェックが失敗すべき()
    {
      CollectionAssert.IsNotSubsetOf(new List<int>(), new List<int>());
    }

    [Test]
    public void 要素なしチェックが成功すべき()
    {
      CollectionAssert.IsEmpty(new List<int>());
    }

    [Test]
    [ExpectedException(typeof(AssertionException))]
    public void 要素なしチェックが失敗すべき()
    {
      List<int> list = new List<int>();
      list.Add(1);
      CollectionAssert.IsEmpty(list);
    }

    [Test]
    public void 要素ありチェックが成功すべき()
    {
      List<int> list = new List<int>();
      list.Add(1);
      CollectionAssert.IsNotEmpty(list);
    }

    [Test]
    [ExpectedException(typeof(AssertionException))]
    public void 要素ありチェックが失敗すべき()
    {
      CollectionAssert.IsNotEmpty(new List<int>());
    }
  }
}

using System;
using System.IO;
using System.Collections.Generic;
using System.Text;
using NUnit.Framework;

namespace LearningNUnit.Tests.ClassicModel
{
  [TestFixture]
  public class FileAssertTest
  {
    private readonly FileInfo Sample1File = new FileInfo("sample1.txt");
    private readonly FileInfo Sample2File = new FileInfo("sample2.txt");
    private readonly FileInfo CopiedSample1File = new FileInfo("copied_sample1.txt");

    [TestFixtureSetUp]
    public void テスト用ファイルの生成()
    {
      using (StreamWriter writer = new StreamWriter(Sample1File.FullName))
      {
        writer.WriteLine("123");
      }

      using (StreamWriter writer = new StreamWriter(Sample2File.FullName))
      {
        writer.WriteLine("456");
      }

      File.Copy(Sample1File.FullName, CopiedSample1File.FullName, true);
    }

    [TestFixtureTearDown]
    public void テスト用ファイルの削除()
    {
      File.Delete(Sample1File.FullName);
      File.Delete(Sample2File.FullName);
      File.Delete(CopiedSample1File.FullName);
    }

    [Test]
    public void Streamでの同値チェックが成功すべき()
    {
      using (Stream expected = new FileStream(Sample1File.FullName, FileMode.Open))
      {
        using (Stream actual = new FileStream(CopiedSample1File.FullName, FileMode.Open))
        {
          FileAssert.AreEqual(expected, actual);
        }
      }
    }

    [Test]
    [ExpectedException(typeof(AssertionException))]
    public void Streamでの同値チェックが失敗すべき()
    {
      using (Stream expected = new FileStream(Sample1File.FullName, FileMode.Open))
      {
        using (Stream actual = new FileStream(Sample2File.FullName, FileMode.Open))
        {
          FileAssert.AreEqual(expected, actual);
        }
      }
    }

    [Test]
    public void FileInfoでの同値チェックが成功すべき()
    {
      FileAssert.AreEqual(Sample1File, CopiedSample1File);
    }

    [Test]
    [ExpectedException(typeof(AssertionException))]
    public void FileInfoでの同値チェックが失敗すべき()
    {
      FileAssert.AreEqual(Sample1File, Sample2File);
    }

    [Test]
    public void Pathでの同値チェックが成功すべき()
    {
      FileAssert.AreEqual(Sample1File.FullName, CopiedSample1File.FullName);
    }

    [Test]
    [ExpectedException(typeof(AssertionException))]
    public void Pathでの同値チェックが失敗すべき()
    {
      FileAssert.AreEqual(Sample1File.FullName, Sample2File.FullName);
    }

    [Test]
    public void Streamでの異値チェックが成功すべき()
    {
      using (Stream expected = new FileStream(Sample1File.FullName, FileMode.Open))
      {
        using (Stream actual = new FileStream(Sample2File.FullName, FileMode.Open))
        {
          FileAssert.AreNotEqual(expected, actual);
        }
      }
    }

    [Test]
    [ExpectedException(typeof(AssertionException))]
    public void Streamでの異値チェックが失敗すべき()
    {
      using (Stream expected = new FileStream(Sample1File.FullName, FileMode.Open))
      {
        using (Stream actual = new FileStream(CopiedSample1File.FullName, FileMode.Open))
        {
          FileAssert.AreNotEqual(expected, actual);
        }
      }
    }

    [Test]
    public void FileInfoでの異値チェックが成功すべき()
    {
      FileAssert.AreNotEqual(Sample1File, Sample2File);
    }

    [Test]
    [ExpectedException(typeof(AssertionException))]
    public void FileInfoでの異値チェックが失敗すべき()
    {
      FileAssert.AreNotEqual(Sample1File, CopiedSample1File);
    }

    [Test]
    public void Pathでの異値チェックが成功すべき()
    {
      FileAssert.AreNotEqual(Sample1File.FullName, Sample2File.FullName);
    }

    [Test]
    [ExpectedException(typeof(AssertionException))]
    public void Pathでの異値チェックが失敗すべき()
    {
      FileAssert.AreNotEqual(Sample1File.FullName, CopiedSample1File.FullName);
    }
  }
}