Common-VS2019/SacsCoreUnitTests/Standard/Base/Bus/SysId_Tester.cs

using Microsoft.VisualStudio.TestTools.UnitTesting;
using Sarand.Net.Standard.Base.Bus;
using Sarand.Net.Standard.Base.Utils;
using System;
using System.Collections.Generic;

namespace Sacs.UnitTests.Net.Standard.Base.Bus
{
	[TestClass]
	public class SysId_Tester
	{
		//-------------------------------------------------------------------
		// Data members.
		private readonly SysId idNull = null;
		private readonly SysId id_ = new SysId();
		private readonly SysId id0 = new SysId(0);
		private readonly SysId id1 = new SysId(1);

		//-------------------------------------------------------------------
		[TestMethod]
		public void SysId_CTR_Void ()
		{
			Assert.IsNotNull(new SysId());
			Assert.AreEqual(new SysId().ToInt(), 0);
			Assert.IsTrue(String.IsNullOrEmpty(new SysId().ToString()));
			Assert.IsTrue(StringUtil.IsEmpty(new SysId().ToString()));
			Assert.AreEqual(new SysId().ToString(), "");
			Assert.AreEqual(new SysId().ToString(), string.Empty);
		}

		[TestMethod]
		public void SysId_CTR_Long ()
		{
			// Zero - invalid.
			Assert.IsNotNull(new SysId(0));

			// 1 - Valid.
			Assert.IsNotNull(new SysId(1));
			Assert.IsNotNull(new SysId(-1));
		}

		//-------------------------------------------------------------------
		// Is Valid.
		[TestMethod]
		public void SysId_IsValid ()
		{
			Assert.IsFalse(SysId.IsValid(null));
			Assert.IsFalse(SysId.IsValid(new SysId()));
			Assert.IsFalse(SysId.IsValid(new SysId(0)));
			Assert.IsTrue(SysId.IsValid(new SysId(1)));
			Assert.IsTrue(SysId.IsValid(new SysId(-1)));
		}

		//-------------------------------------------------------------------
		// Invalid on null.
		[TestMethod]
		public void SysId_InvalidOnNull ()
		{
			Assert.IsNotNull(SysId.InvalidOnNull(null));
			Assert.IsFalse(SysId.IsValid(SysId.InvalidOnNull(null)));
			Assert.IsFalse(SysId.IsValid(SysId.InvalidOnNull(new SysId())));
			Assert.IsFalse(SysId.IsValid(SysId.InvalidOnNull(new SysId(0))));
			Assert.IsTrue(SysId.IsValid(SysId.InvalidOnNull(new SysId(1))));
			Assert.IsTrue(SysId.IsValid(SysId.InvalidOnNull(new SysId(-1))));
		}

		//-------------------------------------------------------------------
		[TestMethod]
		public void SysId_Equals_Object ()
		{
			Assert.IsFalse(id_.Equals(null));
			Assert.IsFalse(id0.Equals(null));
			Assert.IsFalse(id1.Equals(null));
			Assert.IsFalse(id_.Equals((Object)id_));
			Assert.IsFalse(id_.Equals((Object)id0));
			Assert.IsFalse(id_.Equals((Object)id1));
			Assert.IsFalse(id0.Equals((Object)id_));
			Assert.IsFalse(id0.Equals((Object)id0));
			Assert.IsFalse(id0.Equals((Object)id1));
			Assert.IsFalse(id1.Equals((Object)id_));
			Assert.IsFalse(id1.Equals((Object)id0));
			Assert.IsTrue(id1.Equals((Object)id1));
		}
		[TestMethod]
		public void SysId_Equals_SysId ()
		{
			// Invalid values always unequal.
			Assert.IsFalse(id_.Equals(null));
			Assert.IsFalse(id_.Equals(idNull));
			Assert.IsFalse(id_.Equals(id_));
			Assert.IsFalse(id_.Equals(id0));
			Assert.IsFalse(id_.Equals(new SysId()));

			// Valid values.
			Assert.IsTrue(id1.Equals(new SysId(1)));

			for (int i = 1; i <= 1000; i++)
			{
				SysId idI = new SysId(i);
				for (int j = 1; j <= 1000; j++)
				{
					SysId idJ = new SysId(j);
					if (i == j) Assert.IsTrue(idI.Equals(idJ));
					else Assert.IsFalse(idI.Equals(idJ));

				}
			}
		}
		//-------------------------------------------------------------------

		//-------------------------------------------------------------------
		//                        S y s I d   L i s t
		//-------------------------------------------------------------------
		[TestMethod]
		public void SysId_List_GetIdCount ()
		{
			List<SysId> ids = new List<SysId>()
			{
				new SysId(),
				new SysId(1),
				new SysId(2),
				new SysId(3),
				new SysId(),
				new SysId(3),
				new SysId(2),
				new SysId(1),
				new SysId(),
			};
			// Unique, valid only.
			Assert.AreEqual(3, ids.GetIdCount());
			Assert.AreEqual(3, ids.GetIdCount(true,true));
			// Unique including invalid.
			Assert.AreEqual(4, ids.GetIdCount(false));
			Assert.AreEqual(4, ids.GetIdCount(false,true));
			// Duplicate, valid only.
			Assert.AreEqual(6, ids.GetIdCount(true, false));
			// Duplicate including invalid.
			Assert.AreEqual(9, ids.GetIdCount(false,false));
		}

		//-------------------------------------------------------------------
		[TestMethod]
		public void SysId_List_HasValidIds ()
		{
			List<SysId> ids = new List<SysId>();

			// Single valid Id.
			ids.Clear();
			ids.Add(new SysId(123));
			Assert.AreEqual(true, ids.HasValidIds());

			// Several valid ids.
			ids.Clear();
			ids.AddRange(new List<SysId>()
			{
				new SysId(1),
				new SysId(2),
				new SysId(3),
			});
			Assert.AreEqual(true, ids.HasValidIds());

			// Invalid only.
			ids.Clear();
			ids.AddRange(new List<SysId>()
			{
				new SysId(),
				new SysId(),
				new SysId(),
			});
			Assert.AreEqual(false, ids.HasValidIds());

			// Add valid Id.
			ids.Add(new SysId(123));
			Assert.AreEqual(true, ids.HasValidIds());
		}

		//-------------------------------------------------------------------
	}
}