IdBaseTest.cs :  » Web-Frameworks » Ingenious-MVC » Ingenious » Mvc » UnitTest » C# / CSharp Open Source

#region License

/**
 * Ingenious MVC : An MVC framework for .NET 2.0
 * Copyright (C) 2006, JDP Group
 * 
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 * 
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 * 
 * Authors: - Kent Boogaart (kentcb@internode.on.net)
 */

#endregion

using System;
using System.Collections.Generic;
using System.Threading;
using NUnit.Framework;
using Ingenious.Mvc;

namespace Ingenious.Mvc.UnitTest{
  /// <summary>
  /// Unit tests the <see cref="IdBase"/> type.
  /// </summary>
  public sealed class IdBaseTest : UnitTestBase
  {
    [Test]
    [ExpectedException(typeof(ArgumentException))]
    public void TestEmptyStringId()
    {
      ConcreteId1.CreateId(string.Empty);
    }

    [Test]
    public void TestEquals()
    {
      //IdSet1.Id1 == IdSet1.Id1
      IdBase id1 = (ConcreteId1) IdSet1.Id1;
      IdBase id2 = (ConcreteId1) IdSet1.Id1;
      Assert.AreEqual(id1, id2);

      //IdSet1.Id1 != IdSet1.Id2
      id2 = (ConcreteId1) IdSet1.Id2;
      Assert.IsFalse(id1.Equals(id2));

      //IdSet1.Id1 == IdSet2.Id1
      id2 = (ConcreteId1) IdSet2.Id1;
      Assert.AreEqual(id1, id2);

      //IdSet1.Id1 != IdSet1.Id1 (different scope)
      id2 = (ConcreteId2) IdSet1.Id1;
      Assert.IsFalse(id1.Equals(id2));
    }

    [Test]
    public void TestToString()
    {
      ConcreteId1 id = (ConcreteId1) IdSet1.Id1;
      Assert.AreEqual("Id1", id.ToString());

      id = ConcreteId1.CreateId("My ID");
      Assert.AreEqual("My ID", id.ToString());
    }

    [Test]
    public void TestHashCode()
    {
      ConcreteId1 id1 = IdSet1.Id1;
      ConcreteId1 id2 = IdSet1.Id1;
      Assert.AreEqual(id1.GetHashCode(), id2.GetHashCode());

      id2 = IdSet1.Id2;
      Assert.IsFalse(id1.GetHashCode() == id2.GetHashCode());

      id2 = "Id1";
      Assert.AreEqual(id1.GetHashCode(), id2.GetHashCode());

      id1 = "Id1";
      Assert.AreEqual(id1.GetHashCode(), id2.GetHashCode());

      id2 = "Id1";
      Assert.AreEqual(id1.GetHashCode(), id2.GetHashCode());
    }

    [Test]
    public void TestDictionary()
    {
      IDictionary<ConcreteId1, object> dictionary = new Dictionary<ConcreteId1, object>();
      object data1 = new object();
      object data2 = new object();
      dictionary["Id1"] = data1;
      Assert.AreEqual(data1, dictionary[IdSet1.Id1]);
      dictionary[IdSet2.Id3] = data2;
      Assert.AreEqual(data2, dictionary[IdSet2.Id3]);
    }

    #region Supporting Types

    private sealed class ConcreteId1 : IdBase
    {
      private static readonly IdCache<ConcreteId1> _idCache = new IdCache<ConcreteId1>(CreateId);

      public static ConcreteId1 CreateId(string stringId)
      {
        return new ConcreteId1(stringId);
      }

      public static implicit operator ConcreteId1(string stringId)
      {
        return _idCache.GetOrCreateId(stringId);
      }

      public static implicit operator ConcreteId1(Enum enumId)
      {
        return _idCache.GetOrCreateId(enumId);
      }

      private ConcreteId1(string stringId)
        : base(stringId)
      {
      }
    }

    private sealed class ConcreteId2 : IdBase
    {
      private static readonly IdCache<ConcreteId2> _idCache = new IdCache<ConcreteId2>(CreateId);

      public static ConcreteId2 CreateId(string stringId)
      {
        return new ConcreteId2(stringId);
      }

      public static implicit operator ConcreteId2(string stringId)
      {
        return _idCache.GetOrCreateId(stringId);
      }

      public static implicit operator ConcreteId2(Enum enumId)
      {
        return _idCache.GetOrCreateId(enumId);
      }

      private ConcreteId2(string stringId)
        : base(stringId)
      {
      }
    }

    /// <summary>
    /// Mock IDs for testing.
    /// </summary>
    private enum IdSet1
    {
      Id1,
      Id2,
      Id3
    }

    /// <summary>
    /// Mock IDs for testing.
    /// </summary>
    private enum IdSet2
    {
      Id1,
      Id2,
      Id3
    }

    #endregion
  }
}