ForTest.cs :  » Code-Coverage-Tools » NCover » AcceptenceTests » Cs » C# / CSharp Open Source

using System;
using System.IO;
using NUnit.Framework;
using NCover;
using NCover.Objects;

namespace AcceptenceTests.Cs{
  [TestFixture]
  public class ForTest
  {      
    [SetUp]
    public void SetUp()
    {
      NCoverCheck.ResetForTests();
      
      if (File.Exists(NCoverCheck.DESTINATION_FILENAME ))
      {
        File.Delete(NCoverCheck.DESTINATION_FILENAME );
      }
    }

    [Test]
    public void TestGoingIntoAForLoopIsCovered()
    {
      const string COVER = @"
        public class A 
        {
          public static bool[] B()        
          {
            for (int i = 0; i < 10; i++)//6
            {
              i++;//8
            }

            return NCover.NCoverCheck.covered;//11
          }  
        }";

      string instrumentedCode;
      TestUtilities.AssertCompiles(new string[] { COVER }, "A");

      CoveragePoint[] points = new Instrumenter(0, COVER, "").Do(out instrumentedCode, null);
      Assert.AreEqual(2, points.Length);

      bool[] results = (bool[]) TestUtilities.AssertCompiles(new string[] { instrumentedCode }, "A");
      Assert.AreEqual(2, results.Length);

      Assert.IsTrue(TestUtilities.WasHit(points, results, 6));
      Assert.IsTrue(TestUtilities.WasHit(points, results, 11));
    }

    [Test]
    public void TestNotGoingIntoLoopIsPickedUp()
    {
      const string COVER = @"
        public class A 
        {
          public static bool[] B()        
          {
            for (int i = 0; i > 10; i++)//6
            {
              i++;//8
            }

            return NCover.NCoverCheck.covered;//11
          }  
        }";

      string instrumentedCode;
      TestUtilities.AssertCompiles(new string[] { COVER }, "A");

      CoveragePoint[] points = new Instrumenter( 0, COVER, "").Do(out instrumentedCode, null);
      Assert.AreEqual(2, points.Length);

      bool[] results = (bool[]) TestUtilities.AssertCompiles(new string[] { instrumentedCode }, "A");
      //Assert.AreEqual(2, results.Length);

      Assert.IsFalse(TestUtilities.WasHit(points, results, 6));
      Assert.IsTrue(TestUtilities.WasHit(points, results, 11));
    }

    [Test(Description="Tests run in separate Virtual machines should produce combined coverage...")]
    public void TwoSeperateVirtualMachinesCombineCoverageNotOverwriteIt()
    {
      Assert.IsFalse(System.IO.File.Exists(NCoverCheck.DESTINATION_FILENAME));

      const string COVER = @"
        public class A 
        {
          public static bool[] B()
          {
            return NCover.NCoverCheck.covered;//6
          }  
        }
        public class C
        {
          public static bool[] D()
          {
            return NCover.NCoverCheck.covered;//13
          }  
        }";

      string instrumentedCode;
      CoveragePoint[] points = new Instrumenter( 0, COVER, "").Do(out instrumentedCode, null);
      Assert.AreEqual(2, points.Length);
      Assert.AreEqual(1, points[0].AbsoluteNumber);
      Assert.AreEqual(2, points[1].AbsoluteNumber);

      bool[] results = (bool[]) TestUtilities.AssertCompiles(new string[] { instrumentedCode }, "A");
      //Assert.AreEqual(2, results.Length);

      //Fist one should be visited at this point
      Assert.IsFalse(TestUtilities.WasHit(points, results, 13));
      Assert.IsTrue(TestUtilities.WasHit(points, results, 6));

      //Now other should be visited.
      NCoverCheck.ResetForTests(); 
      results = (bool[]) TestUtilities.AssertCompiles(new string[] { instrumentedCode }, "C");
      Assert.AreEqual(2, results.Length);
      Assert.IsFalse(TestUtilities.WasHit(points, results, 6));
      Assert.IsTrue(TestUtilities.WasHit(points, results, 13));

      //but if we look at the coverage file we should see that both have been visited....

      Coverage coverage = Coverage.LoadActualCoverage(new FileStream(NCoverCheck.DESTINATION_FILENAME  , FileMode.Open));
      Assert.AreEqual(2, coverage.CoveragePoints.Length);

      //the proof of the pudding is in the eating...
      Assert.AreEqual(1, coverage.CoveragePoints[0].AbsoluteNumber);
      Assert.AreEqual(2, coverage.CoveragePoints[1].AbsoluteNumber);
    }
  }
}