public void ConsumeSteps(int pCurrIndex, int pCount)
{
var types = new List <Type>();
Type currType = typeof(FabArtifact);
Type newType = typeof(FabFactor);
vMockData.SetupGet(x => x.Items).Returns(GetMockItems(6));
vMockData.SetupGet(x => x.CurrIndex).Returns(pCurrIndex);
vMockData.SetupGet(x => x.CurrType).Returns(currType);
vMockData.SetupGet(x => x.Types).Returns(types);
vMockData.Setup(x => x.UpdateCurrentType(newType));
vMockData.Setup(x => x.IncrementCurrentIndex(pCount));
var tp = new TravPath(vMockData.Object);
IList <ITravPathItem> result = tp.ConsumeSteps(pCount, newType);
Assert.NotNull(result, "Result should be filled.");
Assert.AreEqual(pCount, result.Count, "Incorrect result count.");
CheckItemList(result, pCurrIndex);
Assert.AreEqual(pCount, types.Count, "Incorrect types.count.");
foreach (Type type in types)
{
Assert.AreEqual(currType, type, "Incorrect types list.");
}
vMockData.Verify(x => x.UpdateCurrentType(newType), Times.Once);
vMockData.Verify(x => x.IncrementCurrentIndex(pCount), Times.Once);
}
public void MemberId(int?pMemberId)
{
vMockData.SetupGet(x => x.MemberId).Returns(pMemberId);
var tp = new TravPath(vMockData.Object);
Assert.AreEqual(pMemberId, tp.MemberId, "Incorrect MemberId.");
}
public void AddBackToAlias(bool pDuplicate)
{
const string alias = "a";
const int asIndex = 1;
const int currIndex = 4;
Type asType = typeof(FabFactor);
var types = new List <Type>(new[] { null, asType });
var backs = new Dictionary <string, int>();
if (pDuplicate)
{
backs.Add(alias, 2);
}
var aliases = new Dictionary <string, int>();
aliases.Add(alias, asIndex);
vMockData.SetupGet(x => x.CurrIndex).Returns(currIndex);
vMockData.SetupGet(x => x.Aliases).Returns(aliases);
vMockData.SetupGet(x => x.Backs).Returns(backs);
vMockData.SetupGet(x => x.Types).Returns(types);
vMockData.Setup(x => x.UpdateCurrentType(asType));
var tp = new TravPath(vMockData.Object);
tp.AddBackToAlias(alias);
Assert.AreEqual(1, backs.Keys.Count, "Incorrect back keys count.");
Assert.AreEqual(currIndex, backs[alias], "Incorrect back index.");
}
public void IsAcceptableType(Type pType, bool pExact, bool pExpectResult)
{
vMockData.SetupGet(x => x.Items).Returns(GetMockItems(6));
vMockData.SetupGet(x => x.CurrType).Returns(typeof(FabTravRoot));
var tp = new TravPath(vMockData.Object);
bool result = tp.IsAcceptableType(pType, pExact);
Assert.AreEqual(pExpectResult, result, "Incorrect result.");
}
public void AllowBackToAlias(int pAs1Pos, int pBack1Pos, int pAs2Pos, bool pAllow)
{
const string alias0 = "A0";
const string alias1 = "A1";
const string alias2 = "A2";
const int as0I = 2;
const int back0I = 4;
int as1I = pAs1Pos * 2 + 6;
int back1I = pBack1Pos * 2 + 6;
int as2I = pAs2Pos * 2 + 6;
var aliases = new Dictionary <string, int>();
aliases.Add(alias0, as0I);
aliases.Add(alias1, as1I);
aliases.Add(alias2, as2I);
var backs = new Dictionary <string, int>();
backs.Add(alias0, back0I);
backs.Add(alias1, back1I);
////
var display = new Dictionary <int, string>();
display.Add(as0I, "As(" + alias0 + ")");
display.Add(as1I, "As(" + alias1 + ")");
display.Add(as2I, "As(" + alias2 + ")");
display.Add(back0I, "Back(" + alias0 + ")");
display.Add(back1I, "Back(" + alias1 + ")");
string str = "";
for (int i = 0; i < 12; ++i)
{
str += (display.ContainsKey(i) ? display[i] : "x" + i) + ".";
}
Log.Debug(str + "[allow Back(" + alias2 + ")?]");
////
vMockData.SetupGet(x => x.Aliases).Returns(aliases);
vMockData.SetupGet(x => x.Backs).Returns(backs);
string confAlias;
var tp = new TravPath(vMockData.Object);
bool result = tp.AllowBackToAlias(alias2, out confAlias);
Assert.AreEqual(pAllow, result, "Incorrect result.");
Assert.AreEqual((pAllow ? null : alias1), confAlias, "Incorrect conflicting alias.");
}
public void AddScript()
{
const string script = "My script";
vMockData.Setup(x => x.AddScript(script));
var tp = new TravPath(vMockData.Object);
tp.AddScript(script);
vMockData.Verify(x => x.AddScript(script), Times.Once);
}
public void GetFirstSteps(int pCount)
{
vMockData.SetupGet(x => x.Items).Returns(GetMockItems(6));
int expectCount = Math.Min(6, pCount);
var tp = new TravPath(vMockData.Object);
IList <ITravPathItem> result = tp.GetFirstSteps(pCount);
Assert.NotNull(result, "Result should be filled.");
Assert.AreEqual(expectCount, result.Count, "Incorrect result count.");
CheckItemList(result, 0);
}
public void HasAlias(string pTryAlias, bool pExpectResult)
{
var aliases = new Dictionary <string, int>();
aliases.Add("a", 0);
vMockData.SetupGet(x => x.Aliases).Returns(aliases);
var tp = new TravPath(vMockData.Object);
bool result = tp.HasAlias(pTryAlias);
Assert.AreEqual(pExpectResult, result, "Incorrect result.");
}
public void AddParam()
{
object param = "My script";
const string paramName = "_P0";
vMockData.Setup(x => x.AddParam(param)).Returns(paramName);
var tp = new TravPath(vMockData.Object);
string result = tp.AddParam(param);
Assert.AreEqual(paramName, result, "Incorrect result.");
vMockData.Verify(x => x.AddParam(param), Times.Once);
}
public void DoesBackTouchAs(int pCurrIndex, bool pExpectResult)
{
const string alias = "a";
var aliases = new Dictionary <string, int>();
aliases.Add(alias, 5);
vMockData.SetupGet(x => x.CurrIndex).Returns(pCurrIndex);
vMockData.SetupGet(x => x.Aliases).Returns(aliases);
var tp = new TravPath(vMockData.Object);
bool result = tp.DoesBackTouchAs(alias);
Assert.AreEqual(pExpectResult, result, "Incorrect result.");
}
public void AddAlias()
{
const string alias = "a";
const int currIndex = 123;
var aliases = new Dictionary <string, int>();
vMockData.SetupGet(x => x.CurrIndex).Returns(currIndex);
vMockData.SetupGet(x => x.Aliases).Returns(aliases);
var tp = new TravPath(vMockData.Object);
tp.AddAlias(alias);
Assert.AreEqual(1, aliases.Keys.Count, "Incorrect alias keys count.");
Assert.AreEqual(currIndex, aliases[alias], "Incorrect alias index.");
}
public void GetNextStep(int pCurrIndex, bool pNull)
{
vMockData.SetupGet(x => x.Items).Returns(GetMockItems(6));
vMockData.SetupGet(x => x.CurrIndex).Returns(pCurrIndex);
var tp = new TravPath(vMockData.Object);
ITravPathItem result = tp.GetNextStep();
if (pNull)
{
Assert.Null(result, "Result should be null.");
return;
}
Assert.NotNull(result, "Result should be filled.");
CheckItem(result, pCurrIndex);
}
public void GetSteps(int pCurrIndex, int pCount, bool pNull)
{
vMockData.SetupGet(x => x.Items).Returns(GetMockItems(6));
vMockData.SetupGet(x => x.CurrIndex).Returns(pCurrIndex);
var tp = new TravPath(vMockData.Object);
IList <ITravPathItem> result = tp.GetSteps(pCount);
if (pNull)
{
Assert.Null(result, "Result should be null.");
return;
}
Assert.NotNull(result, "Result should be filled.");
Assert.AreEqual(pCount, result.Count, "Incorrect result count.");
CheckItemList(result, pCurrIndex);
}
