public void Constructor_CreatingNewObject_ReturnsObjectWithDefaultData()
{
const int zeroValue = 0;
var obj = new BaseTechObject();
Assert.Multiple(() =>
{
Assert.IsFalse(obj.UseGroups);
Assert.AreEqual(zeroValue, obj.SystemParams.Count);
Assert.AreEqual(zeroValue, obj.S88Level);
Assert.AreEqual(zeroValue, obj.Parameters.Items.Length);
Assert.IsNull(obj.Owner);
Assert.AreEqual(zeroValue, obj.ObjectGroupsList.Count);
Assert.IsEmpty(obj.Name);
Assert.IsNull(obj.MainAggregateParameter);
Assert.IsFalse(obj.IsPID);
Assert.IsFalse(obj.IsAttachable);
Assert.AreEqual(zeroValue, obj.Equipment.Count);
Assert.IsEmpty(obj.EplanName);
Assert.IsEmpty(obj.BindingName);
Assert.IsEmpty(obj.BasicName);
Assert.AreEqual(zeroValue, obj.BaseOperationsList.Count);
Assert.AreEqual(zeroValue, obj.BaseOperations.Count);
Assert.AreEqual(zeroValue, obj.AggregateParameters.Count);
Assert.IsEmpty(obj.LuaModuleName);
});
}
/// <summary>
/// Добавить опознанный объект при загрузке из LUA
/// </summary>
/// <param name="obj">Объект</param>
private void AddIdentifiedObjectWhenLoadFromLua(
TechObject.TechObject obj)
{
BaseTechObject baseTechObject = obj.BaseTechObject;
var type = (BaseTechObjectManager.ObjectType)baseTechObject
.S88Level;
string name = BaseTechObjectManager.GetInstance()
.GetS88Name(baseTechObject.S88Level);
switch (type)
{
case BaseTechObjectManager.ObjectType.ProcessCell:
AddProcessCellFromLua(obj);
break;
case BaseTechObjectManager.ObjectType.Unit:
AddS88ObjectFromLua(obj, name);
break;
case BaseTechObjectManager.ObjectType.Aggregate:
AddS88ObjectFromLua(obj, name);
break;
case BaseTechObjectManager.ObjectType.UserObject:
AddUserObject(obj);
break;
}
}
/// <summary>
/// Сохранить описание объектов для prg.lua
/// </summary>
/// <param name="prefix">Отступ</param>
/// <returns></returns>
private static string SaveObjectsInformationToPrgLua(string prefix)
{
string objectsInfo = "";
string operations = "";
string operationsSteps = "";
string operationsParameters = "";
string equipments = "";
var objects = techObjectManager.Objects;
foreach (TechObject.TechObject obj in objects)
{
BaseTechObject baseObj = obj.BaseTechObject;
var objName = "prg." + obj.NameEplanForFile.ToLower() +
obj.TechNumber.ToString();
objectsInfo += baseObj.SaveObjectInfoToPrgLua(objName, prefix);
var modesManager = baseObj.Owner.ModesManager;
var modes = modesManager.Modes;
bool haveBaseOperations = modes
.Where(x => x.DisplayText[1] != "").Count() != 0;
if (haveBaseOperations)
{
operations += baseObj.SaveOperations(
objName, prefix, modes);
operationsSteps += baseObj.SaveOperationsSteps(
objName, prefix, modes);
operationsParameters += baseObj.SaveOperationsParameters(
objName, prefix, modes);
}
equipments += baseObj.SaveEquipment(objName);
}
var accumulatedData = new string[]
{
objectsInfo,
operations,
operationsSteps,
operationsParameters,
equipments
};
var result = "";
foreach (var stringsForSave in accumulatedData)
{
if (stringsForSave != "")
{
result += stringsForSave + "\n";
}
}
return(result);
}
public void GetTechObjectCopy_EmptyManager_ReturnsCopyOfObjectOrNull(
IEnumerable <BaseTechObject> objectsToAdd,
string searchingNameOrEplanName, bool successSearch)
{
IBaseTechObjectManager manager = BaseTechObjectManager
.GetInstance();
manager.Objects.Clear();
manager.Objects.AddRange(objectsToAdd);
BaseTechObject obj = manager
.GetTechObjectCopy(searchingNameOrEplanName);
bool isSearchedOk = obj != null &&
(searchingNameOrEplanName == obj.Name ||
searchingNameOrEplanName == obj.EplanName);
Assert.AreEqual(successSearch, isSearchedOk);
}
public void CloneWithArgument_NormalBaseObject_ReturnsFullCopy()
{
// We can test only data which are existing in BaseTechObject entity.
// Clone() always called in Clone(args), we haven't to test Clone().
// Clone() contains a lot of dependencies which have to replace to
// interfaces but we can't do it now. So, the unit-test will test
// all except dependencies.
string expectedName = "Name";
string expectedBasicName = "BasicName";
string expectedEplanName = "EplanName";
int expectedS88Level = 2;
string expectedBindingName = "BindingName";
bool expectedIsPID = true;
string expectedLuaModuleName = "LuaModuleName";
var obj = new BaseTechObject();
obj.Name = expectedName;
obj.BasicName = expectedBasicName;
obj.EplanName = expectedEplanName;
obj.S88Level = expectedS88Level;
obj.BindingName = expectedBindingName;
obj.IsPID = expectedIsPID;
obj.LuaModuleName = expectedLuaModuleName;
// null - is Owner, dependency
var clonedObj = obj.Clone(null);
Assert.Multiple(() =>
{
Assert.AreNotEqual(obj.GetHashCode(), clonedObj.GetHashCode());
Assert.AreEqual(expectedName, clonedObj.Name);
Assert.AreEqual(expectedBasicName, clonedObj.BasicName);
Assert.AreEqual(expectedEplanName, clonedObj.EplanName);
Assert.AreEqual(expectedS88Level, clonedObj.S88Level);
Assert.AreEqual(expectedBindingName, clonedObj.BindingName);
Assert.AreEqual(expectedIsPID, clonedObj.IsPID);
Assert.AreEqual(expectedLuaModuleName, clonedObj.LuaModuleName);
});
}
public void AddBaseObject_EmptyManager_AddObjectsExceptTheSame(
IEnumerable <BaseTechObject> objectsToAdd, int expectedObjectsCount,
bool addResult)
{
IBaseTechObjectManager manager = BaseTechObjectManager
.GetInstance();
manager.Objects.Clear();
bool actualAddResult = false;
foreach (var obj in objectsToAdd)
{
manager.AddBaseObject(obj.Name, obj.EplanName, obj.S88Level,
obj.BasicName, obj.BindingName, obj.IsPID,
obj.LuaModuleName, obj.MonitorName);
BaseTechObject addedObj = manager.Objects
.Where(x => x.Name == obj.Name ||
x.EplanName == obj.EplanName)
.FirstOrDefault();
if (addedObj != null)
{
actualAddResult = addedObj.Name == obj.Name &&
addedObj.EplanName == obj.EplanName &&
addedObj.S88Level == obj.S88Level &&
addedObj.BasicName == obj.BasicName &&
addedObj.BindingName == obj.BindingName &&
addedObj.IsPID == obj.IsPID &&
addedObj.LuaModuleName == obj.LuaModuleName &&
addedObj.MonitorName == obj.MonitorName;
}
}
Assert.Multiple(() =>
{
Assert.AreEqual(expectedObjectsCount, manager.Objects.Count);
Assert.AreEqual(addResult, actualAddResult);
});
}
public void AddParameter_EmptyBaseTechObject_AddParametersToList(
int paramsCount)
{
BaseTechObject emptyObj = GetEmpty();
for (int i = 0; i < paramsCount; i++)
{
emptyObj.AddParameter(paramLuaName, paramName,
paramValue, paramMeter);
}
var firstParam = emptyObj.Parameters.GetParam(paramLuaName);
Assert.Multiple(() =>
{
Assert.AreEqual(paramsCount, emptyObj.Parameters.Items.Length);
Assert.AreEqual(paramName, firstParam.GetName());
Assert.AreEqual(paramLuaName, firstParam.GetNameLua());
Assert.AreEqual(paramMeter, firstParam.GetMeter());
Assert.AreEqual(paramValue.ToString(), firstParam.GetValue());
});
}
public void AddSystemParameter_EmptyBaseTechObject_AddParametersToList(
int paramsCount)
{
BaseTechObject emptyObject = GetEmpty();
for (int i = 0; i < paramsCount; i++)
{
emptyObject.AddSystemParameter(paramLuaName, paramName,
paramValue, paramMeter);
}
var firstParam = emptyObject.SystemParams.GetParam(paramLuaName);
Assert.Multiple(() =>
{
Assert.AreEqual(paramsCount, emptyObject.SystemParams.Count);
Assert.AreEqual(paramName, firstParam.Name);
Assert.AreEqual(paramLuaName, firstParam.LuaName);
Assert.AreEqual(paramMeter, firstParam.Meter);
Assert.AreEqual(paramValue.ToString(), firstParam.Value.Value);
});
}
public void Clone_StateUnderTestSource_ReturnsCopy()
{
string name = "Операция 1";
string luaName = "LuaName 1";
int defaultPosition = 1;
var operation = new BaseOperation(null)
{
Name = name,
LuaName = luaName,
DefaultPosition = defaultPosition
};
var runStep1 = new BaseStep("fRun", "RunFirSt", 1, operation);
var runStep2 = new BaseStep("sRun", "RunSecSt", 2, operation);
var stopStep1 = new BaseStep("fSt", "StopFirSt", 0, operation);
var pauseStep1 = new BaseStep("fP", "PauseFirst", 1, operation);
var pauseStep2 = new BaseStep("sP", "PauseSecond", 0, operation);
var addingStates = new Dictionary <string, List <BaseStep> >
{
{
State.StateType.RUN.ToString(),
new List <BaseStep> {
runStep1, runStep2
}
},
{
State.StateType.PAUSE.ToString(),
new List <BaseStep> {
pauseStep1, pauseStep2
}
},
{
State.StateType.STOP.ToString(),
new List <BaseStep> {
stopStep1
}
}
};
FillBaseOperationStatesWithReset(operation, addingStates);
operation.AddActiveParameter("p1", "пар1", string.Empty);
operation.AddActiveParameter("p2", "пар2", string.Empty);
var baseTechObj = new BaseTechObject()
{
S88Level = 1
};
var objParams = new List <BaseParameter>()
{
new ActiveParameter("op1", "обПар1"),
new ActiveParameter("op2", "обПар2"),
};
operation.AddProperties(objParams, baseTechObj);
BaseOperation cloned = operation.Clone();
Assert.Multiple(() =>
{
Assert.AreEqual(operation.DefaultPosition,
cloned.DefaultPosition);
Assert.AreEqual(operation.Name, cloned.Name);
Assert.AreEqual(operation.LuaName, cloned.LuaName);
Assert.IsNull(cloned.Owner);
foreach (var property in operation.Properties)
{
bool hasTheSameProperty = cloned.Properties
.Where(x => x.Name == property.Name &&
x.LuaName == property.LuaName &&
(x.Owner != property.Owner || x.Owner == baseTechObj))
.Count() == 1;
Assert.IsTrue(hasTheSameProperty);
}
foreach (var state in operation.States.Keys)
{
Assert.True(cloned.States.ContainsKey(state));
foreach (var step in operation.States[state])
{
Assert.True(cloned.States[state]
.Where(x => x.Name == step.Name &&
x.LuaName == step.LuaName &&
x.DefaultPosition == step.DefaultPosition &&
x.Owner != step.Owner)
.Count() == 1);
}
}
});
}
