private void AddReferenceCoordinateSystemForAssemblyRoot(avm.Design ad_import, CyPhy.DesignEntity cyphy_container)
{
foreach (var root in ad_import.DomainFeature.OfType <avm.cad.AssemblyRoot>())
{
CyPhyML.ComponentRef componentRef;
if (idToComponentInstanceMap.TryGetValue(root.AssemblyRootComponentInstance, out componentRef))
{
MgaFCO rcs = CreateChild((ISIS.GME.Common.Interfaces.Model)componentRef.ParentContainer, typeof(CyPhyML.ReferenceCoordinateSystem));
rcs.Name = "AssemblyRoot";
CyPhyML.ReferenceCoordinateSystem componentRcs = componentRef.Referred.Component.Children.ReferenceCoordinateSystemCollection.FirstOrDefault();
if (componentRcs == null)
{
componentRcs = CyPhyClasses.ReferenceCoordinateSystem.Create(componentRef.Referred.Component);
}
((MgaModel)componentRef.ParentContainer.Impl).CreateSimpleConnDisp(((MgaMetaModel)componentRef.ParentContainer.Impl.MetaBase).RoleByName[typeof(CyPhyML.RefCoordSystem2RefCoordSystem).Name],
rcs, (MgaFCO)componentRcs.Impl, null, (MgaFCO)componentRef.Impl);
while (rcs.ParentModel.ID != cyphy_container.ID)
{
var oldrcs = rcs;
rcs = CreateChild(rcs.ParentModel.ParentModel, typeof(CyPhyML.ReferenceCoordinateSystem));
rcs.Name = "AssemblyRoot";
((MgaModel)rcs.ParentModel).CreateSimplerConnDisp(((MgaMetaModel)rcs.ParentModel.Meta).RoleByName[typeof(CyPhyML.RefCoordSystem2RefCoordSystem).Name],
rcs, oldrcs);
}
}
}
}
private CyPhy.ComponentAssembly CreateComponentAssemblyRoot(avm.Design ad_import)
{
CyPhy.ComponentAssemblies cyphy_cas;
CyPhy.RootFolder rf = CyPhyClasses.RootFolder.GetRootFolder((MgaProject)project);
cyphy_cas = rf.Children.ComponentAssembliesCollection.Where(d => d.Name == typeof(CyPhyClasses.ComponentAssemblies).Name).FirstOrDefault();
if (cyphy_cas == null)
{
cyphy_cas = CyPhyClasses.ComponentAssemblies.Create(rf);
cyphy_cas.Name = typeof(CyPhyClasses.ComponentAssemblies).Name;
}
CyPhy.ComponentAssembly cyphy_container = CyPhyClasses.ComponentAssembly.Create(cyphy_cas);
// container.Name = ad_import.Name; RootContainer has a name too
// TODO: check ad_import.SchemaVersion
int designID;
if (int.TryParse(ad_import.DesignID, out designID))
{
cyphy_container.Attributes.ID = designID;
}
if (string.IsNullOrEmpty(ad_import.RootContainer.Description) == false)
{
cyphy_container.Attributes.Description = ad_import.RootContainer.Description;
}
return(cyphy_container);
}
public void Export()
{
avm.Design design = null;
proj.PerformInTransaction(delegate
{
// Retrieve design contain as MgaObject
MgaObject objDesignContainer = null;
objDesignContainer = proj.get_ObjectByPath(@"DesignSpaces/DesignContainer");
Assert.NotNull(objDesignContainer);
// Cast as DesignContainer and run converter
var designContainer = ISIS.GME.Dsml.CyPhyML.Classes.DesignContainer.Cast(objDesignContainer);
design = CyPhy2DesignInterchange.CyPhy2DesignInterchange.Convert(designContainer);
});
Assert.NotNull(design);
String pathXmlOut = Path.Combine(fixture.PathTest, "DesignContainer.adm");
using (StreamWriter sw = new StreamWriter(pathXmlOut, false))
{
sw.Write(design.Serialize());
}
var checker = new LayoutDataChecker();
var result = checker.Check(design.RootContainer);
if (result.Any())
{
String msg = Environment.NewLine +
String.Join(Environment.NewLine,
result);
Assert.True(false, msg);
}
}
public void DupPortIds()
{
String pathCA = "ComponentAssemblies/DupPortIds";
Xunit.Assert.Throws(typeof(ApplicationException), () =>
{
avm.Design design = Convert(pathCA);
});
}
public Model ImportFile(string inputFilePath, DesignImportMode mode = DesignImportMode.CREATE_DS)
{
writeMessage(String.Format("Importing {0}", inputFilePath), MessageType.INFO);
UnzipToTemp unzip = null;
bool bZipArchive = Path.GetExtension(inputFilePath).Equals(".adp");
if (bZipArchive)
{
unzip = new UnzipToTemp(null);
List <string> entries = unzip.UnzipFile(inputFilePath);
inputFilePath = entries.Where(entry => Path.GetDirectoryName(entry) == "" && entry.ToLower().EndsWith(".adm")).FirstOrDefault();
if (inputFilePath != null)
{
inputFilePath = Path.Combine(unzip.TempDirDestination, inputFilePath);
}
}
Model rtn = null;
avm.Design ad_import = null;
using (unzip)
{
using (StreamReader streamReader = new StreamReader(inputFilePath))
{
ad_import = CyPhyDesignImporterInterpreter.DeserializeAvmDesignXml(streamReader);
}
if (ad_import == null)
{
throw new Exception("Could not load ADM file.");
}
rtn = ImportDesign(ad_import, mode);
// Copy artifacts
if (bZipArchive)
{
// Delete ADM file from tmp folder
File.Delete(inputFilePath);
foreach (var keyAndEntity in id2DesignEntity)
{
string id = keyAndEntity.Key;
var ca = keyAndEntity.Value as CyPhy.ComponentAssembly;
string tempPath = Path.Combine(unzip.TempDirDestination, id);
if (Directory.Exists(tempPath))
{
var pathCA = ca.GetDirectoryPath(ComponentLibraryManager.PathConvention.ABSOLUTE);
DirectoryCopy(tempPath, pathCA, true);
}
}
}
}
return(rtn);
}
public void DS_CustomFormula()
{
String pathDS = "DesignSpaces/DC_CustomFormula";
avm.Design design = Convert(pathDS);
// Get objects
var rc = design.RootContainer;
Assert.NotNull(rc);
var cf1 = rc.Formula.OfType <avm.ComplexFormula>().FirstOrDefault(f => f.Name == "CustomFormula1");
Assert.NotNull(cf1);
var cf2 = rc.Formula.OfType <avm.ComplexFormula>().FirstOrDefault(f => f.Name == "CustomFormula2");
Assert.NotNull(cf2);
var prop1 = rc.Property.OfType <avm.PrimitiveProperty>().FirstOrDefault(p => p.Name == "Prop1");
Assert.NotNull(prop1);
var prop2 = rc.Property.OfType <avm.PrimitiveProperty>().FirstOrDefault(p => p.Name == "Prop2");
Assert.NotNull(prop2);
var prop3 = rc.Property.OfType <avm.PrimitiveProperty>().FirstOrDefault(p => p.Name == "Prop3");
Assert.NotNull(prop3);
// Check Value Flows
Assert.Equal(2, cf1.Operand.Count);
var op1_cf1 = cf1.Operand.FirstOrDefault(op => op.ValueSource == prop1.Value.ID);
Assert.NotNull(op1_cf1);
Assert.Equal(prop1.Name, op1_cf1.Symbol);
var op2_cf1 = cf1.Operand.FirstOrDefault(op => op.ValueSource == prop2.Value.ID);
Assert.NotNull(op2_cf1);
Assert.Equal("A", op2_cf1.Symbol);
var op1_cf2 = cf2.Operand.FirstOrDefault(op => op.ValueSource == prop1.Value.ID);
Assert.NotNull(op1_cf2);
Assert.Equal(prop1.Name, op1_cf2.Symbol);
var op2_cf2 = cf2.Operand.FirstOrDefault(op => op.ValueSource == cf1.ID);
Assert.NotNull(op2_cf2);
Assert.Equal("C", op2_cf2.Symbol);
var dv = prop3.Value.ValueExpression as avm.DerivedValue;
Assert.NotNull(dv);
Assert.Equal(cf2.ID, dv.ValueSource);
}
public void CA_SimpleFormula()
{
String pathCA = "ComponentAssemblies/SimpleFormula";
avm.Design design = Convert(pathCA);
// Get objects
var rc = design.RootContainer;
Assert.NotNull(rc);
var sf1 = rc.Formula.OfType <avm.SimpleFormula>().FirstOrDefault(f => f.Name == "SimpleFormula1");
Assert.NotNull(sf1);
var sf2 = rc.Formula.OfType <avm.SimpleFormula>().FirstOrDefault(f => f.Name == "SimpleFormula2");
Assert.NotNull(sf2);
var prop1 = rc.Property.OfType <avm.PrimitiveProperty>().FirstOrDefault(p => p.Name == "Prop1");
Assert.NotNull(prop1);
var prop2 = rc.Property.OfType <avm.PrimitiveProperty>().FirstOrDefault(p => p.Name == "Prop2");
Assert.NotNull(prop2);
var prop3 = rc.Property.OfType <avm.PrimitiveProperty>().FirstOrDefault(p => p.Name == "Prop3");
Assert.NotNull(prop3);
var param = rc.Property.OfType <avm.PrimitiveProperty>().FirstOrDefault(p => p.Name == "Param");
Assert.NotNull(param);
// Check Value Flows
Assert.Equal(2, sf1.Operand.Count);
Assert.True(sf1.Operand.Contains(prop1.Value.ID));
Assert.True(sf1.Operand.Contains(prop2.Value.ID));
Assert.Equal(2, sf2.Operand.Count);
Assert.True(sf2.Operand.Contains(prop2.Value.ID));
Assert.True(sf2.Operand.Contains(sf1.ID));
var dv = prop3.Value.ValueExpression as avm.DerivedValue;
Assert.NotNull(dv);
Assert.Equal(sf2.ID, dv.ValueSource);
Assert.NotNull(param.Value.ValueExpression);
Assert.IsType <avm.ParametricValue>(param.Value.ValueExpression);
var pv_param = param.Value.ValueExpression as avm.ParametricValue;
Assert.NotNull(pv_param.AssignedValue);
Assert.IsType <avm.DerivedValue>(pv_param.AssignedValue);
Assert.Equal(sf2.ID, (pv_param.AssignedValue as avm.DerivedValue).ValueSource);
}
public void CA_SubAsmFlowToComponentInstance()
{
String pathCA = "ComponentAssemblies/SubAsmFlowToComponentInstance";
avm.Design design = Convert(pathCA);
var rc = design.RootContainer;
Assert.NotNull(rc);
#region Get Objects
var CompA = rc.ComponentInstance.FirstOrDefault(ci => ci.Name.Equals("CompA"));
Assert.NotNull(CompA);
var CompA_Prop1 = CompA.PrimitivePropertyInstance.FirstOrDefault(ppi => ppi.IDinComponentModel.Equals("Prop1"));
Assert.NotNull(CompA_Prop1);
var CompA_Param1 = CompA.PrimitivePropertyInstance.FirstOrDefault(ppi => ppi.IDinComponentModel.Equals("Param1"));
Assert.NotNull(CompA_Param1);
var CompA_Prop2 = CompA.PrimitivePropertyInstance.FirstOrDefault(ppi => ppi.IDinComponentModel.Equals("Prop2"));
Assert.NotNull(CompA_Prop2);
var CompA_Param2 = CompA.PrimitivePropertyInstance.FirstOrDefault(ppi => ppi.IDinComponentModel.Equals("Param2"));
Assert.NotNull(CompA_Param2);
var subAsm = rc.Container1.OfType <avm.Compound>().FirstOrDefault(c => c.Name.Equals("SubAsm"));
Assert.NotNull(subAsm);
var in_prop_prop = subAsm.Property.OfType <avm.PrimitiveProperty>().FirstOrDefault(p => p.Name.Equals("in_prop_prop"));
Assert.NotNull(in_prop_prop);
var in_param_prop = subAsm.Property.OfType <avm.PrimitiveProperty>().FirstOrDefault(p => p.Name.Equals("in_param_prop"));
Assert.NotNull(in_param_prop);
var in_prop_param = subAsm.Property.OfType <avm.PrimitiveProperty>().FirstOrDefault(p => p.Name.Equals("in_prop_param"));
Assert.NotNull(in_prop_param);
var in_param_param = subAsm.Property.OfType <avm.PrimitiveProperty>().FirstOrDefault(p => p.Name.Equals("in_param_param"));
Assert.NotNull(in_param_param);
var out_prop = subAsm.Property.OfType <avm.PrimitiveProperty>().FirstOrDefault(p => p.Name.Equals("out_prop"));
Assert.NotNull(out_prop);
var out_param = subAsm.Property.OfType <avm.PrimitiveProperty>().FirstOrDefault(p => p.Name.Equals("out_param"));
Assert.NotNull(out_param);
#endregion
VerifyComponentPropertySource(out_param.Value.ID, CompA_Param2);
VerifyComponentPropertySource(out_prop.Value.ID, CompA_Prop2);
Assert.NotNull(in_param_prop.Value.ValueExpression);
Assert.IsType <avm.ParametricValue>(in_param_prop.Value.ValueExpression);
var pv_in_param_prop = in_param_prop.Value.ValueExpression as avm.ParametricValue;
Assert.NotNull(pv_in_param_prop.AssignedValue);
Assert.IsType <avm.DerivedValue>(pv_in_param_prop.AssignedValue);
Assert.Equal(CompA_Prop1.Value.ID, (pv_in_param_prop.AssignedValue as avm.DerivedValue).ValueSource);
}
public void CA_SimpleFormula_OpTypes()
{
String pathCA = "ComponentAssemblies/SimpleFormula_OpTypes";
avm.Design design = Convert(pathCA);
var rc = design.RootContainer;
Assert.NotNull(rc);
Assert.Equal(6, rc.Formula.OfType <avm.SimpleFormula>().Count());
foreach (var sf in rc.Formula.OfType <avm.SimpleFormula>())
{
Assert.True(sf.OperationSpecified);
// The name of the SimpleFormula object will match the operation type.
Assert.Equal(sf.Name, sf.Operation.ToString());
}
}
private void TestPortsAndConnections <T>() where T : avm.Port
{
String pathCA = "ca/Tonka";
avm.Design design = fixture.Convert(pathCA);
var rc = design.RootContainer;
Assert.NotNull(rc);
#region get components and containers
var topconnector = rc.Connector.First(c => c.Name.Equals("topconnector"));
var comp1 = rc.ComponentInstance.First(ci => ci.Name.Equals("comp1"));
var comp2 = rc.ComponentInstance.First(ci => ci.Name.Equals("comp2"));
var subasm = rc.Container1.OfType <avm.Compound>().First();
var comp3 = subasm.ComponentInstance.First();
#endregion
var domainPortTypeName = typeof(T).Name;
#region get ports
var top_domainport = rc.Port.OfType <T>().First();
var topconnector_domainport = topconnector.Role.OfType <T>().First();
var comp1_domainport = comp1.PortInstance.First(pi => pi.IDinComponentModel.Equals(domainPortTypeName));
var comp2_domainport = comp2.PortInstance.First(pi => pi.IDinComponentModel.Equals(domainPortTypeName));
var subasm_domainport = subasm.Port.OfType <T>().First();
var comp3_domainport = comp3.PortInstance.First(pi => pi.IDinComponentModel.Equals(domainPortTypeName));
#endregion
#region assert connections
top_domainport.IsConnectedTo(topconnector_domainport);
top_domainport.IsConnectedTo(subasm_domainport);
topconnector_domainport.IsConnectedTo(comp1_domainport);
comp1_domainport.IsConnectedTo(comp2_domainport);
comp1_domainport.IsConnectedTo(subasm_domainport);
subasm_domainport.IsConnectedTo(comp3_domainport);
#endregion
}
public bool CheckForDuplicateIDs(avm.Design d)
{
//String str = d.Serialize();
String str = OpenMETA.Interchange.AvmXmlSerializer.Serialize(d);
XmlDocument doc = new XmlDocument();
doc.LoadXml(str);
XmlNode root = doc.DocumentElement;
var ls_EncounteredIDs = new List <String>();
foreach (XmlAttribute node in root.SelectNodes("//@ID"))
{
ls_EncounteredIDs.Add(node.Value);
}
// Get all duplicate IDs that aren't empty/whitespace
var duplicates = ls_EncounteredIDs.Where(s => !String.IsNullOrWhiteSpace(s))
.GroupBy(s => s)
.Where(g => g.Count() > 1)
.Select(g => g.Key)
.ToList();
if (duplicates.Any())
{
String msg = "Duplicate IDs found in exported design: ";
foreach (var dupe in duplicates)
{
msg += String.Format("{0}\"{1}\", ", Environment.NewLine, dupe);
}
if (Logger != null)
{
Logger.WriteError(msg);
}
return(true);
}
return(false);
}
public void CA_FlowBetweenComponentInstances()
{
String pathCA = "ComponentAssemblies/FlowBetweenComponentInstances";
avm.Design design = Convert(pathCA);
var rc = design.RootContainer;
Assert.NotNull(rc);
var CompA = rc.ComponentInstance.FirstOrDefault(ci => ci.Name.Equals("CompA"));
Assert.NotNull(CompA);
var CompA_Prop1 = CompA.PrimitivePropertyInstance.FirstOrDefault(ppi => ppi.IDinComponentModel.Equals("Prop1"));
Assert.NotNull(CompA_Prop1);
var CompA_Param1 = CompA.PrimitivePropertyInstance.FirstOrDefault(ppi => ppi.IDinComponentModel.Equals("Param1"));
Assert.NotNull(CompA_Param1);
var CompB = rc.ComponentInstance.FirstOrDefault(ci => ci.Name.Equals("CompB"));
Assert.NotNull(CompB);
var CompB_Prop1 = CompB.PrimitivePropertyInstance.FirstOrDefault(ppi => ppi.IDinComponentModel.Equals("Prop1"));
Assert.NotNull(CompB_Prop1);
var CompB_Prop2 = CompB.PrimitivePropertyInstance.FirstOrDefault(ppi => ppi.IDinComponentModel.Equals("Prop2"));
Assert.NotNull(CompB_Prop2);
var CompB_Param1 = CompB.PrimitivePropertyInstance.FirstOrDefault(ppi => ppi.IDinComponentModel.Equals("Param1"));
Assert.NotNull(CompB_Param1);
var CompB_Param2 = CompB.PrimitivePropertyInstance.FirstOrDefault(ppi => ppi.IDinComponentModel.Equals("Param2"));
Assert.NotNull(CompB_Param2);
VerifyComponentPropertySource(CompA_Prop1.Value.ID, CompB_Prop1);
VerifyComponentPropertySource(CompA_Prop1.Value.ID, CompB_Param2);
VerifyComponentPropertySource(CompA_Param1.Value.ID, CompB_Param1);
VerifyComponentPropertySource(CompA_Param1.Value.ID, CompB_Prop2);
}
public void DS_SimpleFormula()
{
String pathDS = "DesignSpaces/DC_SimpleFormula";
avm.Design design = Convert(pathDS);
// Get objects
var rc = design.RootContainer;
Assert.NotNull(rc);
var sf1 = rc.Formula.OfType <avm.SimpleFormula>().FirstOrDefault(f => f.Name == "SimpleFormula1");
Assert.NotNull(sf1);
var sf2 = rc.Formula.OfType <avm.SimpleFormula>().FirstOrDefault(f => f.Name == "SimpleFormula2");
Assert.NotNull(sf2);
var prop1 = rc.Property.OfType <avm.PrimitiveProperty>().FirstOrDefault(p => p.Name == "Prop1");
Assert.NotNull(prop1);
var prop2 = rc.Property.OfType <avm.PrimitiveProperty>().FirstOrDefault(p => p.Name == "Prop2");
Assert.NotNull(prop2);
var prop3 = rc.Property.OfType <avm.PrimitiveProperty>().FirstOrDefault(p => p.Name == "Prop3");
Assert.NotNull(prop3);
// Check Value Flows
Assert.Equal(2, sf1.Operand.Count);
Assert.True(sf1.Operand.Contains(prop1.Value.ID));
Assert.True(sf1.Operand.Contains(prop2.Value.ID));
Assert.Equal(2, sf2.Operand.Count);
Assert.True(sf2.Operand.Contains(prop2.Value.ID));
Assert.True(sf2.Operand.Contains(sf1.ID));
var dv = prop3.Value.ValueExpression as avm.DerivedValue;
Assert.NotNull(dv);
Assert.Equal(sf2.ID, dv.ValueSource);
}
private CyPhy.DesignContainer CreateDesignSpaceRoot(avm.Design ad_import)
{
CyPhy.DesignSpace ds;
CyPhy.RootFolder rf = CyPhyClasses.RootFolder.GetRootFolder((MgaProject)project);
ds = rf.Children.DesignSpaceCollection.Where(d => d.Name == "DesignSpaces").FirstOrDefault();
if (ds == null)
{
ds = CyPhyClasses.DesignSpace.Create(rf);
ds.Name = "DesignSpaces";
}
CyPhy.DesignContainer cyphy_container = CyPhyClasses.DesignContainer.Create(ds);
// container.Name = ad_import.Name; RootContainer has a name too
int designID;
if (int.TryParse(ad_import.DesignID, out designID))
{
cyphy_container.Attributes.ID = designID;
}
cyphy_container.Attributes.ContainerType = CyPhyClasses.DesignContainer.AttributesClass.ContainerType_enum.Compound;
return(cyphy_container);
}
public void DS_FlowToComponentInstance()
{
String pathDS = "DesignSpaces/DC_FlowToComponentInstance";
avm.Design design = Convert(pathDS);
#region Get Objects
var rc = design.RootContainer;
Assert.NotNull(rc);
var InSF = rc.Formula.OfType <avm.SimpleFormula>().FirstOrDefault(f => f.Name.Equals("InSF"));
Assert.NotNull(InSF);
var InCF = rc.Formula.OfType <avm.ComplexFormula>().FirstOrDefault(f => f.Name.Equals("InCF"));
Assert.NotNull(InCF);
var InProp = rc.Property.OfType <avm.PrimitiveProperty>().FirstOrDefault(p => p.Name.Equals("InProp"));
Assert.NotNull(InProp);
var InParam = rc.Property.OfType <avm.PrimitiveProperty>().FirstOrDefault(p => p.Name.Equals("InParam"));
Assert.NotNull(InParam);
var OutSF = rc.Formula.OfType <avm.SimpleFormula>().FirstOrDefault(f => f.Name.Equals("OutSF"));
Assert.NotNull(OutSF);
var OutCF = rc.Formula.OfType <avm.ComplexFormula>().FirstOrDefault(f => f.Name.Equals("OutCF"));
Assert.NotNull(OutCF);
var OutProp = rc.Property.OfType <avm.PrimitiveProperty>().FirstOrDefault(p => p.Name.Equals("OutProp"));
Assert.NotNull(OutProp);
var OutParam = rc.Property.OfType <avm.PrimitiveProperty>().FirstOrDefault(p => p.Name.Equals("OutParam"));
Assert.NotNull(OutParam);
Assert.Equal(1, rc.ComponentInstance.Count);
var compInst = rc.ComponentInstance.First();
Assert.NotNull(compInst);
var in_prop_sf = compInst.PrimitivePropertyInstance.FirstOrDefault(p => p.IDinComponentModel.Equals("in_prop_sf"));
Assert.NotNull(in_prop_sf);
var in_param_sf = compInst.PrimitivePropertyInstance.FirstOrDefault(p => p.IDinComponentModel.Equals("in_param_sf"));
Assert.NotNull(in_param_sf);
var in_prop_cf = compInst.PrimitivePropertyInstance.FirstOrDefault(p => p.IDinComponentModel.Equals("in_prop_cf"));
Assert.NotNull(in_prop_cf);
var in_param_cf = compInst.PrimitivePropertyInstance.FirstOrDefault(p => p.IDinComponentModel.Equals("in_param_cf"));
Assert.NotNull(in_param_cf);
var in_prop_prop = compInst.PrimitivePropertyInstance.FirstOrDefault(p => p.IDinComponentModel.Equals("in_prop_prop"));
Assert.NotNull(in_prop_prop);
var in_param_prop = compInst.PrimitivePropertyInstance.FirstOrDefault(p => p.IDinComponentModel.Equals("in_param_prop"));
Assert.NotNull(in_param_prop);
var in_prop_param = compInst.PrimitivePropertyInstance.FirstOrDefault(p => p.IDinComponentModel.Equals("in_prop_param"));
Assert.NotNull(in_prop_param);
var in_param_param = compInst.PrimitivePropertyInstance.FirstOrDefault(p => p.IDinComponentModel.Equals("in_param_param"));
Assert.NotNull(in_param_param);
var out_prop = compInst.PrimitivePropertyInstance.FirstOrDefault(p => p.IDinComponentModel.Equals("out_prop"));
Assert.NotNull(out_prop);
var out_param = compInst.PrimitivePropertyInstance.FirstOrDefault(p => p.IDinComponentModel.Equals("out_param"));
Assert.NotNull(out_param);
#endregion
Assert.Equal(4, OutCF.Operand.Count);
Assert.Equal(1, OutCF.Operand.Count(op => op.Symbol.Equals("param_alias") && op.ValueSource.Equals(out_param.Value.ID)));
Assert.Equal(1, OutCF.Operand.Count(op => op.Symbol.Equals("prop_alias") && op.ValueSource.Equals(out_prop.Value.ID)));
Assert.Equal(1, OutCF.Operand.Count(op => op.Symbol.Equals("out_param") && op.ValueSource.Equals(out_param.Value.ID)));
Assert.Equal(1, OutCF.Operand.Count(op => op.Symbol.Equals("out_prop") && op.ValueSource.Equals(out_prop.Value.ID)));
Assert.Equal(2, OutSF.Operand.Count);
Assert.Equal(1, OutSF.Operand.Count(op => op.Equals(out_prop.Value.ID)));
Assert.Equal(1, OutSF.Operand.Count(op => op.Equals(out_param.Value.ID)));
var dv_outProp = OutProp.Value.ValueExpression as avm.DerivedValue;
Assert.NotNull(dv_outProp);
Assert.Equal(out_prop.Value.ID, dv_outProp.ValueSource);
var pv_outParam = OutParam.Value.ValueExpression as avm.ParametricValue;
Assert.NotNull(pv_outParam);
var dv_outParam = pv_outParam.AssignedValue as avm.DerivedValue;
Assert.NotNull(dv_outParam);
Assert.Equal(out_param.Value.ID, dv_outParam.ValueSource);
VerifyComponentPropertySource(InSF.ID, in_prop_sf);
VerifyComponentPropertySource(InSF.ID, in_param_sf);
VerifyComponentPropertySource(InCF.ID, in_prop_cf);
VerifyComponentPropertySource(InCF.ID, in_param_cf);
VerifyComponentPropertySource(InProp.Value.ID, in_param_prop);
VerifyComponentPropertySource(InProp.Value.ID, in_prop_prop);
VerifyComponentPropertySource(InParam.Value.ID, in_param_param);
VerifyComponentPropertySource(InParam.Value.ID, in_prop_param);
Assert.Equal("kg", OutParam.Value.Unit);
Assert.Equal("kg", OutProp.Value.Unit);
Assert.Equal("kg", InParam.Value.Unit);
Assert.Equal("kg", InProp.Value.Unit);
}
public void DS_FlowToSubAsm()
{
String pathDS = "DesignSpaces/DC_FlowToDesignContainer";
avm.Design design = Convert(pathDS);
#region Get Objects
var rc = design.RootContainer;
Assert.NotNull(rc);
var InSF = rc.Formula.OfType <avm.SimpleFormula>().FirstOrDefault(f => f.Name.Equals("InSF"));
Assert.NotNull(InSF);
var InCF = rc.Formula.OfType <avm.ComplexFormula>().FirstOrDefault(f => f.Name.Equals("InCF"));
Assert.NotNull(InCF);
var InProp = rc.Property.OfType <avm.PrimitiveProperty>().FirstOrDefault(p => p.Name.Equals("InProp"));
Assert.NotNull(InProp);
var InParam = rc.Property.OfType <avm.PrimitiveProperty>().FirstOrDefault(p => p.Name.Equals("InParam"));
Assert.NotNull(InParam);
var OutSF = rc.Formula.OfType <avm.SimpleFormula>().FirstOrDefault(f => f.Name.Equals("OutSF"));
Assert.NotNull(OutSF);
var OutCF = rc.Formula.OfType <avm.ComplexFormula>().FirstOrDefault(f => f.Name.Equals("OutCF"));
Assert.NotNull(OutCF);
var OutProp = rc.Property.OfType <avm.PrimitiveProperty>().FirstOrDefault(p => p.Name.Equals("OutProp"));
Assert.NotNull(OutProp);
var OutParam = rc.Property.OfType <avm.PrimitiveProperty>().FirstOrDefault(p => p.Name.Equals("OutParam"));
Assert.NotNull(OutParam);
var subAsm = rc.Container1.OfType <avm.Compound>().FirstOrDefault(c => c.Name.Equals("SubDC"));
Assert.NotNull(subAsm);
var in_prop_sf = subAsm.Property.OfType <avm.PrimitiveProperty>().FirstOrDefault(p => p.Name.Equals("in_prop_sf"));
Assert.NotNull(in_prop_sf);
var in_param_sf = subAsm.Property.OfType <avm.PrimitiveProperty>().FirstOrDefault(p => p.Name.Equals("in_param_sf"));
Assert.NotNull(in_param_sf);
var in_prop_cf = subAsm.Property.OfType <avm.PrimitiveProperty>().FirstOrDefault(p => p.Name.Equals("in_prop_cf"));
Assert.NotNull(in_prop_cf);
var in_param_cf = subAsm.Property.OfType <avm.PrimitiveProperty>().FirstOrDefault(p => p.Name.Equals("in_param_cf"));
Assert.NotNull(in_param_cf);
var in_prop_prop = subAsm.Property.OfType <avm.PrimitiveProperty>().FirstOrDefault(p => p.Name.Equals("in_prop_prop"));
Assert.NotNull(in_prop_prop);
var in_param_prop = subAsm.Property.OfType <avm.PrimitiveProperty>().FirstOrDefault(p => p.Name.Equals("in_param_prop"));
Assert.NotNull(in_param_prop);
var in_prop_param = subAsm.Property.OfType <avm.PrimitiveProperty>().FirstOrDefault(p => p.Name.Equals("in_prop_param"));
Assert.NotNull(in_prop_param);
var in_param_param = subAsm.Property.OfType <avm.PrimitiveProperty>().FirstOrDefault(p => p.Name.Equals("in_param_param"));
Assert.NotNull(in_param_param);
var out_prop = subAsm.Property.OfType <avm.PrimitiveProperty>().FirstOrDefault(p => p.Name.Equals("out_prop"));
Assert.NotNull(out_prop);
var out_param = subAsm.Property.OfType <avm.PrimitiveProperty>().FirstOrDefault(p => p.Name.Equals("out_param"));
Assert.NotNull(out_param);
#endregion
Assert.Equal(4, OutCF.Operand.Count);
Assert.Equal(1, OutCF.Operand.Count(op => op.Symbol.Equals("param_alias") && op.ValueSource.Equals(out_param.Value.ID)));
Assert.Equal(1, OutCF.Operand.Count(op => op.Symbol.Equals("prop_alias") && op.ValueSource.Equals(out_prop.Value.ID)));
Assert.Equal(1, OutCF.Operand.Count(op => op.Symbol.Equals("out_param") && op.ValueSource.Equals(out_param.Value.ID)));
Assert.Equal(1, OutCF.Operand.Count(op => op.Symbol.Equals("out_prop") && op.ValueSource.Equals(out_prop.Value.ID)));
Assert.Equal(2, OutSF.Operand.Count);
Assert.Equal(1, OutSF.Operand.Count(op => op.Equals(out_prop.Value.ID)));
Assert.Equal(1, OutSF.Operand.Count(op => op.Equals(out_param.Value.ID)));
var dv_outProp = OutProp.Value.ValueExpression as avm.DerivedValue;
Assert.NotNull(dv_outProp);
Assert.Equal(out_prop.Value.ID, dv_outProp.ValueSource);
var pv_outParam = OutParam.Value.ValueExpression as avm.ParametricValue;
Assert.NotNull(pv_outParam);
var dv_outParam = pv_outParam.AssignedValue as avm.DerivedValue;
Assert.NotNull(dv_outParam);
Assert.Equal(out_param.Value.ID, dv_outParam.ValueSource);
}
public Model ImportDesign(avm.Design ad_import, DesignImportMode mode = DesignImportMode.CREATE_DS)
{
TellCyPhyAddonDontAssignIds();
// TODO: check ad_import.SchemaVersion
CyPhy.DesignEntity cyphy_container;
if (mode == DesignImportMode.CREATE_CA_IF_NO_DS_CONCEPTS)
{
bool containsNonCompound = false;
Queue <avm.Container> containers = new Queue <avm.Container>();
containers.Enqueue(ad_import.RootContainer);
if (ad_import.RootContainer == null)
{
throw new ApplicationException("No RootContainer, or unknown RootContainer type");
}
while (containers.Count > 0)
{
avm.Container container = containers.Dequeue();
containsNonCompound |= container is avm.Optional || container is avm.Alternative;
foreach (var subcontainer in container.Container1)
{
containers.Enqueue(subcontainer);
}
}
if (containsNonCompound)
{
cyphy_container = CreateDesignSpaceRoot(ad_import);
}
else
{
cyphy_container = CreateComponentAssemblyRoot(ad_import);
}
}
else if (mode == DesignImportMode.CREATE_CAS)
{
cyphy_container = CreateComponentAssemblyRoot(ad_import);
}
else if (mode == DesignImportMode.CREATE_DS)
{
cyphy_container = CreateDesignSpaceRoot(ad_import);
}
else
{
throw new ArgumentOutOfRangeException("Unrecognized mode " + mode.ToString());
}
var ad_container = ad_import.RootContainer;
ImportContainer(cyphy_container, ad_container);
processValues();
processPorts();
Dictionary <avm.ConnectorCompositionTarget, avm.ConnectorCompositionTarget> connectorMap = new Dictionary <avm.ConnectorCompositionTarget, avm.ConnectorCompositionTarget>();
foreach (var obj in this._avmCyPhyMLObjectMap)
{
if (obj.Key is avm.ConnectorCompositionTarget)
{
avm.ConnectorCompositionTarget ad_compositionTarget1 = (avm.ConnectorCompositionTarget)obj.Key;
foreach (var ad_compositionTarget2ID in ad_compositionTarget1.ConnectorComposition.Where(id => string.IsNullOrEmpty(id) == false))
{
var ad_compositionTarget2 = _idConnectorMap[ad_compositionTarget2ID];
var cyphy_target = _avmCyPhyMLObjectMap[ad_compositionTarget2]; // TODO: handle lookup failure
if (string.Compare(ad_compositionTarget1.ID, ad_compositionTarget2.ID) < 0)
{
continue;
}
connectAcrossHierarchy(obj.Value, cyphy_target, typeof(CyPhy.ConnectorComposition).Name);
}
}
}
AddReferenceCoordinateSystemForAssemblyRoot(ad_import, cyphy_container);
DoLayout();
return((Model)cyphy_container);
}
public void CA_Parameters()
{
String pathCA = "ComponentAssemblies/Parameters";
avm.Design design = Convert(pathCA);
var rc = design.RootContainer;
Assert.NotNull(rc);
// HasDefault
var pv_HasDefault = GetValueExpression(rc, "HasDefault");
Assert.IsType <avm.FixedValue>(pv_HasDefault.Default);
Assert.Equal("1", (pv_HasDefault.Default as avm.FixedValue).Value);
// HasRangeIntegers
CheckParameterRange(rc, "-2", "2", "HasRangeIntegers");
// HasRangeReals
CheckParameterRange(rc, "-2.3", "2.93", "HasRangeReals");
// HasValue
var pv_HasValue = GetValueExpression(rc, "HasValue");
Assert.IsType <avm.FixedValue>(pv_HasValue.AssignedValue);
var fv_HasValue = pv_HasValue.AssignedValue as avm.FixedValue;
Assert.Equal("1", fv_HasValue.Value);
var val_HasValue = GetValue(rc, "HasValue");
// DerivedValue_HasRangeReals
CheckParameterRange(rc, "-2.3", "2.93", "DerivedValue_HasRangeReals");
MustHaveNullDefault(rc, "DerivedValue_HasRangeReals");
// DerivedValue_HasRangeIntegers
CheckParameterRange(rc, "-2", "2", "DerivedValue_HasRangeIntegers");
MustHaveNullDefault(rc, "DerivedValue_HasRangeIntegers");
// DerivedValue_HasDefault
var pv_DerivedValue_HasDefault = GetValueExpression(rc, "DerivedValue_HasDefault");
Assert.NotNull(pv_DerivedValue_HasDefault.Default);
Assert.IsType <avm.FixedValue>(pv_DerivedValue_HasDefault.Default);
Assert.Equal("4", (pv_DerivedValue_HasDefault.Default as avm.FixedValue).Value);
// DerivedValue_HasValue
var pv_DerivedValue_HasValue = GetValueExpression(rc, "DerivedValue_HasValue");
Assert.NotNull(pv_DerivedValue_HasValue.AssignedValue);
Assert.IsType <avm.DerivedValue>(pv_DerivedValue_HasValue.AssignedValue);
Assert.Equal(val_HasValue.ID, (pv_DerivedValue_HasValue.AssignedValue as avm.DerivedValue).ValueSource);
MustHaveNullDefault(rc, "DerivedValue_HasValue");
// InvalidRange_Whitespace
var pv_InvalidRange_Whitespace = GetValueExpression(rc, "InvalidRange_Whitespace");
Assert.Null(pv_InvalidRange_Whitespace.Minimum);
Assert.Null(pv_InvalidRange_Whitespace.Maximum);
// InvalidRange_OneNumber
var pv_InvalidRange_OneNumber = GetValueExpression(rc, "InvalidRange_OneNumber");
Assert.Null(pv_InvalidRange_OneNumber.Minimum);
Assert.Null(pv_InvalidRange_OneNumber.Maximum);
// InvalidRange_String
var pv_InvalidRange_String = GetValueExpression(rc, "InvalidRange_String");
Assert.Null(pv_InvalidRange_String.Minimum);
Assert.Null(pv_InvalidRange_String.Maximum);
}
