public void InvalidParameters()
{
var parameters = new SimpleTreeLayoutParameters();
Assert.Throws <ArgumentOutOfRangeException>(() => parameters.VertexGap = -1);
Assert.Throws <ArgumentOutOfRangeException>(() => parameters.LayerGap = -1);
}
public void SimpleTreeLayoutAlgorithm(
[NotNull] IBidirectionalGraph <string, Edge <string> > graph,
int maxCrossCount)
{
IDictionary <string, Size> verticesSizes = GetVerticesSizes(graph.Vertices);
var parameters = new SimpleTreeLayoutParameters
{
LayerGap = 15,
VertexGap = 20
};
foreach (LayoutDirection direction in Enum.GetValues(typeof(LayoutDirection)))
{
parameters.Direction = direction;
foreach (SpanningTreeGeneration treeGen in Enum.GetValues(typeof(SpanningTreeGeneration)))
{
parameters.SpanningTreeGeneration = treeGen;
var algorithm = new SimpleTreeLayoutAlgorithm <string, Edge <string>, IBidirectionalGraph <string, Edge <string> > >(
graph,
verticesSizes,
parameters);
LayoutResults results = ExecuteLayoutAlgorithm(algorithm, verticesSizes);
results.CheckResult(maxCrossCount);
CheckTreeLayout(algorithm, verticesSizes);
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="DatasetGraphModel"/> class.
/// </summary>
/// <param name="context">The context that is used to execute actions on the UI thread.</param>
/// <param name="facade">The project that holds the graph of datasets.</param>
/// <param name="datasetModelBuilder">The function that builds <see cref="DatasetModel"/> objects.</param>
/// <exception cref="ArgumentNullException">
/// Thrown if <paramref name="context"/> is <see langword="null" />.
/// </exception>
/// <exception cref="ArgumentNullException">
/// Thrown if <paramref name="facade"/> is <see langword="null" />.
/// </exception>
/// <exception cref="ArgumentNullException">
/// Thrown if <paramref name="datasetModelBuilder"/> is <see langword="null" />.
/// </exception>
public DatasetGraphModel(
IContextAware context,
ProjectFacade facade,
Func <DatasetFacade, DatasetModel> datasetModelBuilder)
: base(context)
{
{
Enforce.Argument(() => facade);
}
m_Project = facade;
m_Project.OnDatasetCreated += (s, e) => AddDatasetToGraph();
m_Project.OnDatasetDeleted += (s, e) => RemoveDatasetFromGraph();
m_DatasetModelBuilder = datasetModelBuilder;
LayoutType = "Tree";
LayoutParameters = new SimpleTreeLayoutParameters
{
LayerGap = 250,
VertexGap = 250,
Direction = LayoutDirection.TopToBottom,
};
ReloadProject();
}
public void Constructor_Throws()
{
var verticesPositions = new Dictionary <string, Point>();
var verticesSizes = new Dictionary <string, Size>();
var graph = new BidirectionalGraph <string, Edge <string> >();
var parameters = new SimpleTreeLayoutParameters();
// ReSharper disable ObjectCreationAsStatement
// ReSharper disable AssignNullToNotNullAttribute
Assert.Throws <ArgumentNullException>(
() => new SimpleTreeLayoutAlgorithm <string, Edge <string>, IBidirectionalGraph <string, Edge <string> > >(graph, null));
Assert.Throws <ArgumentNullException>(
() => new SimpleTreeLayoutAlgorithm <string, Edge <string>, IBidirectionalGraph <string, Edge <string> > >(null, verticesSizes));
Assert.Throws <ArgumentNullException>(
() => new SimpleTreeLayoutAlgorithm <string, Edge <string>, IBidirectionalGraph <string, Edge <string> > >(null, null));
Assert.Throws <ArgumentNullException>(
() => new SimpleTreeLayoutAlgorithm <string, Edge <string>, IBidirectionalGraph <string, Edge <string> > >(graph, null, parameters));
Assert.Throws <ArgumentNullException>(
() => new SimpleTreeLayoutAlgorithm <string, Edge <string>, IBidirectionalGraph <string, Edge <string> > >(null, verticesSizes, parameters));
Assert.Throws <ArgumentNullException>(
() => new SimpleTreeLayoutAlgorithm <string, Edge <string>, IBidirectionalGraph <string, Edge <string> > >(null, null, parameters));
Assert.Throws <ArgumentNullException>(
() => new SimpleTreeLayoutAlgorithm <string, Edge <string>, IBidirectionalGraph <string, Edge <string> > >(graph, null, (IDictionary <string, Size>)null));
Assert.Throws <ArgumentNullException>(
() => new SimpleTreeLayoutAlgorithm <string, Edge <string>, IBidirectionalGraph <string, Edge <string> > >(null, null, verticesSizes));
Assert.Throws <ArgumentNullException>(
() => new SimpleTreeLayoutAlgorithm <string, Edge <string>, IBidirectionalGraph <string, Edge <string> > >(null, null, (IDictionary <string, Size>)null));
Assert.Throws <ArgumentNullException>(
() => new SimpleTreeLayoutAlgorithm <string, Edge <string>, IBidirectionalGraph <string, Edge <string> > >(graph, verticesPositions, null));
Assert.Throws <ArgumentNullException>(
() => new SimpleTreeLayoutAlgorithm <string, Edge <string>, IBidirectionalGraph <string, Edge <string> > >(null, verticesPositions, verticesSizes));
Assert.Throws <ArgumentNullException>(
() => new SimpleTreeLayoutAlgorithm <string, Edge <string>, IBidirectionalGraph <string, Edge <string> > >(null, verticesPositions, null));
Assert.Throws <ArgumentNullException>(
() => new SimpleTreeLayoutAlgorithm <string, Edge <string>, IBidirectionalGraph <string, Edge <string> > >(graph, null, null, parameters));
Assert.Throws <ArgumentNullException>(
() => new SimpleTreeLayoutAlgorithm <string, Edge <string>, IBidirectionalGraph <string, Edge <string> > >(null, null, verticesSizes, parameters));
Assert.Throws <ArgumentNullException>(
() => new SimpleTreeLayoutAlgorithm <string, Edge <string>, IBidirectionalGraph <string, Edge <string> > >(null, null, null, parameters));
Assert.Throws <ArgumentNullException>(
() => new SimpleTreeLayoutAlgorithm <string, Edge <string>, IBidirectionalGraph <string, Edge <string> > >(graph, verticesPositions, null, parameters));
Assert.Throws <ArgumentNullException>(
() => new SimpleTreeLayoutAlgorithm <string, Edge <string>, IBidirectionalGraph <string, Edge <string> > >(null, verticesPositions, verticesSizes, parameters));
Assert.Throws <ArgumentNullException>(
() => new SimpleTreeLayoutAlgorithm <string, Edge <string>, IBidirectionalGraph <string, Edge <string> > >(null, verticesPositions, null, parameters));
// ReSharper restore AssignNullToNotNullAttribute
// ReSharper restore ObjectCreationAsStatement
}
public ParallelStacksGraphLayout()
{
// TODO : Replace the current tree layout with EfficientSugiyama layout when Direction is available for this type of layout
var par = new SimpleTreeLayoutParameters();
par.LayerGap = 30;
par.VertexGap = 50;
par.Direction = LayoutDirection.BottomToTop;
par.SpanningTreeGeneration = SpanningTreeGeneration.DFS;
this.LayoutParameters = par;
}
/// <summary>
/// Performs the actual layout algorithm.
/// </summary>
/// <param name="graph">The object containing the graph data</param>
/// <param name="rootNode">Root node</param>
protected override void PerformLayout(GraphMapData graph, INode rootNode)
{
BidirectionalGraph <string, WeightedEdge <string> > bGraph = GraphSharpUtility.GetBidirectionalGraph(graph);
IDictionary <string, Vector> nodePositions = GraphSharpUtility.GetNodePositions(graph);
IDictionary <string, Size> nodeSizes = GraphSharpUtility.GetNodeSizes(graph);
SimpleTreeLayoutParameters simpleTreeLayoutParameters = new SimpleTreeLayoutParameters();
SimpleTreeLayoutAlgorithm <string, WeightedEdge <string>, BidirectionalGraph <string, WeightedEdge <string> > > simpleTreeLayoutAlgorithm = new SimpleTreeLayoutAlgorithm <string, WeightedEdge <string>, BidirectionalGraph <string, WeightedEdge <string> > >(bGraph, nodePositions, nodeSizes, simpleTreeLayoutParameters);
simpleTreeLayoutAlgorithm.Compute();
GraphSharpUtility.SetNodePositions(graph, simpleTreeLayoutAlgorithm.VertexPositions);
}
public MainWindowViewModel(List <string> allProcess, List <ProcessTreeMine> psTree)
{
allProcessString = allProcess;
psTreeMine = psTree;
Graph = new PocGraph(true);
allProcess.RemoveRange(0, 2);
List <PocVertex> existingVertices = new List <PocVertex>();
existingVertices.Add(new PocVertex("Start_Process", true));
foreach (var item in allProcess)
{
if (HashClass.UnPermittedProcess.FirstOrDefault(x => item.ToLower().Contains(x.ToLower().Replace(".exe", ""))) != null)
{
existingVertices.Add(new PocVertex(item, false, item));
}
else
{
existingVertices.Add(new PocVertex(item, true, item));
}
}
foreach (var existingVertex in existingVertices)
{
Graph.AddVertex(existingVertex);
}
foreach (var item in psTree)
{
AddNewGraphEdge(existingVertices[0], existingVertices.FirstOrDefault(x => x.ID == item.fatherName) ?? new PocVertex("NullProcess", false));
if (item.ChildList.Count > 0)
{
foreach (var processTreeMine in item.ChildList)
{
GenerateTree(processTreeMine, item.fatherName, existingVertices);
}
}
//else
//{
// AddNewGraphEdge(existingVertices[0], existingVertices.FirstOrDefault(x => x.ID==item.fatherName)??new PocVertex("NullProcess",false));
//}
}
TreeLayoutParameters = new SimpleTreeLayoutParameters();
TreeLayoutParameters.Direction = GraphSharp.Algorithms.Layout.LayoutDirection.TopToBottom; //THIS IS WHAT YOU EXPECT
TreeLayoutParameters.LayerGap = 200.0;
TreeLayoutParameters.OptimizeWidthAndHeight = true;
//TreeLayoutParameters.SpanningTreeGeneration =SpanningTreeGeneration.DFS;
TreeLayoutParameters.VertexGap = 1.0;
TreeLayoutParameters.WidthPerHeight = 1.0;
ConfigLayoutAlgorithmType();
//Pick a default Layout Algorithm Type
LayoutAlgorithmType = "ISOM";
}
public void Clone()
{
var parameters = new SimpleTreeLayoutParameters();
var clonedParameters = (SimpleTreeLayoutParameters)parameters.Clone();
Assert.AreEqual(parameters, clonedParameters);
parameters = new SimpleTreeLayoutParameters();
parameters.Direction = LayoutDirection.LeftToRight;
parameters.VertexGap = 50;
parameters.LayerGap = 50;
parameters.SpanningTreeGeneration = SpanningTreeGeneration.BFS;
clonedParameters = (SimpleTreeLayoutParameters)parameters.Clone();
Assert.AreEqual(parameters, clonedParameters);
}
public void ParameterRaise()
{
string expectedPropertyName = null;
var parameters = new SimpleTreeLayoutParameters();
parameters.PropertyChanged += (sender, args) =>
{
// ReSharper disable AccessToModifiedClosure
if (expectedPropertyName is null)
{
Assert.Fail("Must not raise.");
}
else
{
Assert.AreEqual(expectedPropertyName, args.PropertyName);
}
// ReSharper restore AccessToModifiedClosure
};
parameters.Direction = LayoutDirection.TopToBottom;
expectedPropertyName = nameof(SimpleTreeLayoutParameters.Direction);
parameters.Direction = LayoutDirection.BottomToTop;
expectedPropertyName = null;
parameters.VertexGap = 10;
expectedPropertyName = nameof(SimpleTreeLayoutParameters.VertexGap);
parameters.VertexGap = 42;
expectedPropertyName = null;
parameters.LayerGap = 10;
expectedPropertyName = nameof(SimpleTreeLayoutParameters.LayerGap);
parameters.LayerGap = 42;
expectedPropertyName = null;
parameters.SpanningTreeGeneration = SpanningTreeGeneration.DFS;
expectedPropertyName = nameof(SimpleTreeLayoutParameters.SpanningTreeGeneration);
parameters.SpanningTreeGeneration = SpanningTreeGeneration.BFS;
}
/// <summary>
/// Creates a new instance of <see cref="PointedTreeGraphLayout"/>.
/// </summary>
public PointedTreeGraphLayout()
{
HighlightAlgorithmType = "Simple";
LayoutAlgorithmType = "Tree";
OverlapRemovalAlgorithmType = "FSA";
OverlapRemovalConstraint = AlgorithmConstraints.Must;
OverlapRemovalParameters = new OverlapRemovalParameters
{
HorizontalGap = 10,
VerticalGap = 10
};
LayoutParameters = new SimpleTreeLayoutParameters
{
VertexGap = 10,
Direction = LayoutDirection.TopToBottom,
SpanningTreeGeneration = SpanningTreeGeneration.DFS
};
AnimationLength = new TimeSpan(0);
IsAnimationEnabled = false;
}
private ILayoutParameters GetParameter(string type)
{
switch (type)
{
case "Tree":
var treeParam = new SimpleTreeLayoutParameters();
treeParam.Direction = LayoutDirection.BottomToTop;
treeParam.LayerGap = 20;
treeParam.SpanningTreeGeneration = SpanningTreeGeneration.BFS;
treeParam.VertexGap = 20.0;
treeParam.WidthPerHeight = 50;
return(treeParam);
case "BoundedFR":
var frParam = new BoundedFRLayoutParameters();
return(frParam);
case "ISOM":
var isomParam = new ISOMLayoutParameters();
return(isomParam);
case "LinLog":
var linlogParam = new LinLogLayoutParameters();
return(linlogParam);
case "EfficientSugiyama":
var sugiyamaParam = new EfficientSugiyamaLayoutParameters();
sugiyamaParam.EdgeRouting = SugiyamaEdgeRoutings.Orthogonal;
sugiyamaParam.WidthPerHeight = 5;
return(sugiyamaParam);
default:
return(null);
}
}
public void Constructor()
{
var verticesPositions = new Dictionary <string, Point>();
var verticesSizes = new Dictionary <string, Size>();
var graph = new BidirectionalGraph <string, Edge <string> >();
var algorithm = new SimpleTreeLayoutAlgorithm <string, Edge <string>, IBidirectionalGraph <string, Edge <string> > >(graph, verticesSizes);
AssertAlgorithmProperties(algorithm, graph);
algorithm = new SimpleTreeLayoutAlgorithm <string, Edge <string>, IBidirectionalGraph <string, Edge <string> > >(graph, verticesSizes);
algorithm.IterationEnded += (sender, args) => { };
AssertAlgorithmProperties(algorithm, graph, expectedReportIterationEnd: true);
algorithm = new SimpleTreeLayoutAlgorithm <string, Edge <string>, IBidirectionalGraph <string, Edge <string> > >(graph, verticesSizes);
algorithm.ProgressChanged += (sender, args) => { };
AssertAlgorithmProperties(algorithm, graph, expectedReportProgress: true);
algorithm = new SimpleTreeLayoutAlgorithm <string, Edge <string>, IBidirectionalGraph <string, Edge <string> > >(graph, verticesSizes);
algorithm.IterationEnded += (sender, args) => { };
algorithm.ProgressChanged += (sender, args) => { };
AssertAlgorithmProperties(algorithm, graph, expectedReportIterationEnd: true, expectedReportProgress: true);
algorithm = new SimpleTreeLayoutAlgorithm <string, Edge <string>, IBidirectionalGraph <string, Edge <string> > >(graph, null, verticesSizes);
AssertAlgorithmProperties(algorithm, graph);
algorithm = new SimpleTreeLayoutAlgorithm <string, Edge <string>, IBidirectionalGraph <string, Edge <string> > >(graph, verticesPositions, verticesSizes);
AssertAlgorithmProperties(algorithm, graph, verticesPositions);
var parameters = new SimpleTreeLayoutParameters();
algorithm = new SimpleTreeLayoutAlgorithm <string, Edge <string>, IBidirectionalGraph <string, Edge <string> > >(graph, verticesSizes, parameters);
AssertAlgorithmProperties(algorithm, graph, parameters: parameters);
algorithm = new SimpleTreeLayoutAlgorithm <string, Edge <string>, IBidirectionalGraph <string, Edge <string> > >(graph, verticesPositions, verticesSizes, parameters);
AssertAlgorithmProperties(algorithm, graph, verticesPositions, parameters: parameters);
}
public void StandardFactory()
{
var positions = new Dictionary <TestVertex, Point>();
var sizes = new Dictionary <TestVertex, Size>();
var borders = new Dictionary <TestVertex, Thickness>();
var layoutTypes = new Dictionary <TestVertex, CompoundVertexInnerLayoutType>();
var graph = new BidirectionalGraph <TestVertex, Edge <TestVertex> >();
var simpleContext = new LayoutContext <TestVertex, Edge <TestVertex>, BidirectionalGraph <TestVertex, Edge <TestVertex> > >(
graph,
positions,
sizes,
LayoutMode.Simple);
var compoundContext1 = new LayoutContext <TestVertex, Edge <TestVertex>, BidirectionalGraph <TestVertex, Edge <TestVertex> > >(
graph,
positions,
sizes,
LayoutMode.Compound);
var compoundContext2 = new CompoundLayoutContext <TestVertex, Edge <TestVertex>, BidirectionalGraph <TestVertex, Edge <TestVertex> > >(
graph,
positions,
sizes,
LayoutMode.Compound,
borders,
layoutTypes);
var nullGraphContext = new LayoutContext <TestVertex, Edge <TestVertex>, BidirectionalGraph <TestVertex, Edge <TestVertex> > >(
null,
positions,
sizes,
LayoutMode.Simple);
var factory = new StandardLayoutAlgorithmFactory <TestVertex, Edge <TestVertex>, BidirectionalGraph <TestVertex, Edge <TestVertex> > >();
CollectionAssert.AreEqual(
new[]
{
"Circular", "Tree", "FR", "BoundedFR", "KK",
"ISOM", "LinLog", "Sugiyama", "CompoundFDP",
"Random"
},
factory.AlgorithmTypes);
Assert.IsNull(
factory.CreateAlgorithm(
string.Empty,
simpleContext,
new CircularLayoutParameters()));
Assert.IsNull(
factory.CreateAlgorithm(
"NotExist",
simpleContext,
new CircularLayoutParameters()));
Assert.IsNull(
factory.CreateAlgorithm(
"Circular",
nullGraphContext,
new CircularLayoutParameters()));
Assert.IsInstanceOf <CircularLayoutAlgorithm <TestVertex, Edge <TestVertex>, BidirectionalGraph <TestVertex, Edge <TestVertex> > > >(
factory.CreateAlgorithm(
"Circular",
simpleContext,
new CircularLayoutParameters()));
Assert.IsInstanceOf <SimpleTreeLayoutAlgorithm <TestVertex, Edge <TestVertex>, BidirectionalGraph <TestVertex, Edge <TestVertex> > > >(
factory.CreateAlgorithm(
"Tree",
simpleContext,
new SimpleTreeLayoutParameters()));
Assert.IsInstanceOf <FRLayoutAlgorithm <TestVertex, Edge <TestVertex>, BidirectionalGraph <TestVertex, Edge <TestVertex> > > >(
factory.CreateAlgorithm(
"FR",
simpleContext,
new FreeFRLayoutParameters()));
Assert.IsInstanceOf <FRLayoutAlgorithm <TestVertex, Edge <TestVertex>, BidirectionalGraph <TestVertex, Edge <TestVertex> > > >(
factory.CreateAlgorithm(
"BoundedFR",
simpleContext,
new BoundedFRLayoutParameters()));
Assert.IsInstanceOf <KKLayoutAlgorithm <TestVertex, Edge <TestVertex>, BidirectionalGraph <TestVertex, Edge <TestVertex> > > >(
factory.CreateAlgorithm(
"KK",
simpleContext,
new KKLayoutParameters()));
Assert.IsInstanceOf <ISOMLayoutAlgorithm <TestVertex, Edge <TestVertex>, BidirectionalGraph <TestVertex, Edge <TestVertex> > > >(
factory.CreateAlgorithm(
"ISOM",
simpleContext,
new ISOMLayoutParameters()));
Assert.IsInstanceOf <LinLogLayoutAlgorithm <TestVertex, Edge <TestVertex>, BidirectionalGraph <TestVertex, Edge <TestVertex> > > >(
factory.CreateAlgorithm(
"LinLog",
simpleContext,
new LinLogLayoutParameters()));
Assert.IsInstanceOf <SugiyamaLayoutAlgorithm <TestVertex, Edge <TestVertex>, BidirectionalGraph <TestVertex, Edge <TestVertex> > > >(
factory.CreateAlgorithm(
"Sugiyama",
simpleContext,
new SugiyamaLayoutParameters()));
Assert.IsInstanceOf <CompoundFDPLayoutAlgorithm <TestVertex, Edge <TestVertex>, BidirectionalGraph <TestVertex, Edge <TestVertex> > > >(
factory.CreateAlgorithm(
"CompoundFDP",
simpleContext,
new CompoundFDPLayoutParameters()));
Assert.IsInstanceOf <RandomLayoutAlgorithm <TestVertex, Edge <TestVertex>, BidirectionalGraph <TestVertex, Edge <TestVertex> > > >(
factory.CreateAlgorithm(
"Random",
simpleContext,
new RandomLayoutParameters()));
Assert.IsNull(
factory.CreateAlgorithm(
"CompoundFDP",
compoundContext1,
new CompoundFDPLayoutParameters()));
Assert.IsNull(
factory.CreateAlgorithm(
"Circular",
compoundContext2,
new CompoundFDPLayoutParameters()));
Assert.IsInstanceOf <CompoundFDPLayoutAlgorithm <TestVertex, Edge <TestVertex>, BidirectionalGraph <TestVertex, Edge <TestVertex> > > >(
factory.CreateAlgorithm(
"CompoundFDP",
compoundContext2,
new CompoundFDPLayoutParameters()));
var testParameters = new TestLayoutParameters();
var circularParameters = new CircularLayoutParameters();
ILayoutParameters createdParameters = factory.CreateParameters(string.Empty, circularParameters);
Assert.IsNull(createdParameters);
createdParameters = factory.CreateParameters("NotExist", circularParameters);
Assert.IsNull(createdParameters);
createdParameters = factory.CreateParameters("Circular", null);
Assert.IsInstanceOf <CircularLayoutParameters>(createdParameters);
Assert.AreNotSame(circularParameters, createdParameters);
createdParameters = factory.CreateParameters("Circular", testParameters);
Assert.IsInstanceOf <CircularLayoutParameters>(createdParameters);
Assert.AreNotSame(testParameters, createdParameters);
createdParameters = factory.CreateParameters("Circular", circularParameters);
Assert.IsInstanceOf <CircularLayoutParameters>(createdParameters);
Assert.AreNotSame(circularParameters, createdParameters);
var treeParameters = new SimpleTreeLayoutParameters();
createdParameters = factory.CreateParameters("Tree", null);
Assert.IsInstanceOf <SimpleTreeLayoutParameters>(createdParameters);
Assert.AreNotSame(treeParameters, createdParameters);
createdParameters = factory.CreateParameters("Tree", testParameters);
Assert.IsInstanceOf <SimpleTreeLayoutParameters>(createdParameters);
Assert.AreNotSame(testParameters, createdParameters);
createdParameters = factory.CreateParameters("Tree", treeParameters);
Assert.IsInstanceOf <SimpleTreeLayoutParameters>(createdParameters);
Assert.AreNotSame(treeParameters, createdParameters);
var frParameters = new FreeFRLayoutParameters();
createdParameters = factory.CreateParameters("FR", null);
Assert.IsInstanceOf <FreeFRLayoutParameters>(createdParameters);
Assert.AreNotSame(frParameters, createdParameters);
createdParameters = factory.CreateParameters("FR", testParameters);
Assert.IsInstanceOf <FreeFRLayoutParameters>(createdParameters);
Assert.AreNotSame(treeParameters, createdParameters);
createdParameters = factory.CreateParameters("FR", frParameters);
Assert.IsInstanceOf <FreeFRLayoutParameters>(createdParameters);
Assert.AreNotSame(frParameters, createdParameters);
var boundedFrParameters = new BoundedFRLayoutParameters();
createdParameters = factory.CreateParameters("BoundedFR", null);
Assert.IsInstanceOf <BoundedFRLayoutParameters>(createdParameters);
Assert.AreNotSame(boundedFrParameters, createdParameters);
createdParameters = factory.CreateParameters("BoundedFR", testParameters);
Assert.IsInstanceOf <BoundedFRLayoutParameters>(createdParameters);
Assert.AreNotSame(treeParameters, createdParameters);
createdParameters = factory.CreateParameters("BoundedFR", boundedFrParameters);
Assert.IsInstanceOf <BoundedFRLayoutParameters>(createdParameters);
Assert.AreNotSame(boundedFrParameters, createdParameters);
var kkParameters = new KKLayoutParameters();
createdParameters = factory.CreateParameters("KK", null);
Assert.IsInstanceOf <KKLayoutParameters>(createdParameters);
Assert.AreNotSame(kkParameters, createdParameters);
createdParameters = factory.CreateParameters("KK", testParameters);
Assert.IsInstanceOf <KKLayoutParameters>(createdParameters);
Assert.AreNotSame(treeParameters, createdParameters);
createdParameters = factory.CreateParameters("KK", kkParameters);
Assert.IsInstanceOf <KKLayoutParameters>(createdParameters);
Assert.AreNotSame(kkParameters, createdParameters);
var isomParameters = new ISOMLayoutParameters();
createdParameters = factory.CreateParameters("ISOM", null);
Assert.IsInstanceOf <ISOMLayoutParameters>(createdParameters);
Assert.AreNotSame(isomParameters, createdParameters);
createdParameters = factory.CreateParameters("ISOM", testParameters);
Assert.IsInstanceOf <ISOMLayoutParameters>(createdParameters);
Assert.AreNotSame(treeParameters, createdParameters);
createdParameters = factory.CreateParameters("ISOM", isomParameters);
Assert.IsInstanceOf <ISOMLayoutParameters>(createdParameters);
Assert.AreNotSame(isomParameters, createdParameters);
var linLogParameters = new LinLogLayoutParameters();
createdParameters = factory.CreateParameters("LinLog", null);
Assert.IsInstanceOf <LinLogLayoutParameters>(createdParameters);
Assert.AreNotSame(linLogParameters, createdParameters);
createdParameters = factory.CreateParameters("LinLog", testParameters);
Assert.IsInstanceOf <LinLogLayoutParameters>(createdParameters);
Assert.AreNotSame(treeParameters, createdParameters);
createdParameters = factory.CreateParameters("LinLog", linLogParameters);
Assert.IsInstanceOf <LinLogLayoutParameters>(createdParameters);
Assert.AreNotSame(linLogParameters, createdParameters);
var sugiyamaParameters = new SugiyamaLayoutParameters();
createdParameters = factory.CreateParameters("Sugiyama", null);
Assert.IsInstanceOf <SugiyamaLayoutParameters>(createdParameters);
Assert.AreNotSame(sugiyamaParameters, createdParameters);
createdParameters = factory.CreateParameters("Sugiyama", testParameters);
Assert.IsInstanceOf <SugiyamaLayoutParameters>(createdParameters);
Assert.AreNotSame(treeParameters, createdParameters);
createdParameters = factory.CreateParameters("Sugiyama", sugiyamaParameters);
Assert.IsInstanceOf <SugiyamaLayoutParameters>(createdParameters);
Assert.AreNotSame(sugiyamaParameters, createdParameters);
var compoundFDPParameters = new CompoundFDPLayoutParameters();
createdParameters = factory.CreateParameters("CompoundFDP", null);
Assert.IsInstanceOf <CompoundFDPLayoutParameters>(createdParameters);
Assert.AreNotSame(compoundFDPParameters, createdParameters);
createdParameters = factory.CreateParameters("CompoundFDP", testParameters);
Assert.IsInstanceOf <CompoundFDPLayoutParameters>(createdParameters);
Assert.AreNotSame(treeParameters, createdParameters);
createdParameters = factory.CreateParameters("CompoundFDP", compoundFDPParameters);
Assert.IsInstanceOf <CompoundFDPLayoutParameters>(createdParameters);
Assert.AreNotSame(compoundFDPParameters, createdParameters);
var randomParameters = new RandomLayoutParameters();
createdParameters = factory.CreateParameters("Random", null);
Assert.IsInstanceOf <RandomLayoutParameters>(createdParameters);
Assert.AreNotSame(randomParameters, createdParameters);
createdParameters = factory.CreateParameters("Random", testParameters);
Assert.IsInstanceOf <RandomLayoutParameters>(createdParameters);
Assert.AreNotSame(treeParameters, createdParameters);
createdParameters = factory.CreateParameters("Random", randomParameters);
Assert.IsInstanceOf <RandomLayoutParameters>(createdParameters);
Assert.AreNotSame(randomParameters, createdParameters);
Assert.IsFalse(factory.IsValidAlgorithm(null));
Assert.IsFalse(factory.IsValidAlgorithm(string.Empty));
Assert.IsTrue(factory.IsValidAlgorithm("Circular"));
Assert.IsFalse(factory.IsValidAlgorithm("circular"));
Assert.IsTrue(factory.IsValidAlgorithm("Tree"));
Assert.IsTrue(factory.IsValidAlgorithm("FR"));
Assert.IsTrue(factory.IsValidAlgorithm("BoundedFR"));
Assert.IsTrue(factory.IsValidAlgorithm("KK"));
Assert.IsTrue(factory.IsValidAlgorithm("ISOM"));
Assert.IsTrue(factory.IsValidAlgorithm("LinLog"));
Assert.IsTrue(factory.IsValidAlgorithm("Sugiyama"));
Assert.IsTrue(factory.IsValidAlgorithm("CompoundFDP"));
Assert.IsTrue(factory.IsValidAlgorithm("Random"));
var algorithm1 = new TestLayoutAlgorithm();
Assert.IsEmpty(factory.GetAlgorithmType(algorithm1));
var algorithm2 = new CircularLayoutAlgorithm <TestVertex, Edge <TestVertex>, BidirectionalGraph <TestVertex, Edge <TestVertex> > >(graph, positions, sizes, circularParameters);
Assert.AreEqual("Circular", factory.GetAlgorithmType(algorithm2));
var algorithm3 = new SimpleTreeLayoutAlgorithm <TestVertex, Edge <TestVertex>, BidirectionalGraph <TestVertex, Edge <TestVertex> > >(graph, positions, sizes, treeParameters);
Assert.AreEqual("Tree", factory.GetAlgorithmType(algorithm3));
var algorithm4 = new FRLayoutAlgorithm <TestVertex, Edge <TestVertex>, BidirectionalGraph <TestVertex, Edge <TestVertex> > >(graph, positions, frParameters);
Assert.AreEqual("FR", factory.GetAlgorithmType(algorithm4));
var algorithm5 = new FRLayoutAlgorithm <TestVertex, Edge <TestVertex>, BidirectionalGraph <TestVertex, Edge <TestVertex> > >(graph, positions, boundedFrParameters);
Assert.AreEqual("BoundedFR", factory.GetAlgorithmType(algorithm5));
var algorithm6 = new KKLayoutAlgorithm <TestVertex, Edge <TestVertex>, BidirectionalGraph <TestVertex, Edge <TestVertex> > >(graph, positions, kkParameters);
Assert.AreEqual("KK", factory.GetAlgorithmType(algorithm6));
var algorithm7 = new ISOMLayoutAlgorithm <TestVertex, Edge <TestVertex>, BidirectionalGraph <TestVertex, Edge <TestVertex> > >(graph, positions, isomParameters);
Assert.AreEqual("ISOM", factory.GetAlgorithmType(algorithm7));
var algorithm8 = new LinLogLayoutAlgorithm <TestVertex, Edge <TestVertex>, BidirectionalGraph <TestVertex, Edge <TestVertex> > >(graph);
Assert.AreEqual("LinLog", factory.GetAlgorithmType(algorithm8));
var algorithm9 = new SugiyamaLayoutAlgorithm <TestVertex, Edge <TestVertex>, BidirectionalGraph <TestVertex, Edge <TestVertex> > >(graph, positions, sizes, sugiyamaParameters);
Assert.AreEqual("Sugiyama", factory.GetAlgorithmType(algorithm9));
var algorithm10 = new CompoundFDPLayoutAlgorithm <TestVertex, Edge <TestVertex>, BidirectionalGraph <TestVertex, Edge <TestVertex> > >(graph, sizes, borders, layoutTypes);
Assert.AreEqual("CompoundFDP", factory.GetAlgorithmType(algorithm10));
var algorithm11 = new RandomLayoutAlgorithm <TestVertex, Edge <TestVertex>, BidirectionalGraph <TestVertex, Edge <TestVertex> > >(graph, sizes, null, randomParameters);
Assert.AreEqual("Random", factory.GetAlgorithmType(algorithm11));
Assert.IsFalse(factory.NeedEdgeRouting(string.Empty));
Assert.IsTrue(factory.NeedEdgeRouting("Circular"));
Assert.IsTrue(factory.NeedEdgeRouting("Tree"));
Assert.IsTrue(factory.NeedEdgeRouting("FR"));
Assert.IsTrue(factory.NeedEdgeRouting("BoundedFR"));
Assert.IsTrue(factory.NeedEdgeRouting("KK"));
Assert.IsTrue(factory.NeedEdgeRouting("ISOM"));
Assert.IsTrue(factory.NeedEdgeRouting("LinLog"));
Assert.IsFalse(factory.NeedEdgeRouting("Sugiyama"));
Assert.IsTrue(factory.NeedEdgeRouting("CompoundFDP"));
Assert.IsTrue(factory.NeedEdgeRouting("Random"));
Assert.IsFalse(factory.NeedOverlapRemoval(string.Empty));
Assert.IsFalse(factory.NeedOverlapRemoval("Circular"));
Assert.IsFalse(factory.NeedOverlapRemoval("Tree"));
Assert.IsTrue(factory.NeedOverlapRemoval("FR"));
Assert.IsTrue(factory.NeedOverlapRemoval("BoundedFR"));
Assert.IsTrue(factory.NeedOverlapRemoval("KK"));
Assert.IsTrue(factory.NeedOverlapRemoval("ISOM"));
Assert.IsTrue(factory.NeedOverlapRemoval("LinLog"));
Assert.IsFalse(factory.NeedOverlapRemoval("Sugiyama"));
Assert.IsFalse(factory.NeedOverlapRemoval("CompoundFDP"));
Assert.IsTrue(factory.NeedOverlapRemoval("Random"));
}
