public void TestControlFlows(SearcherContext context, Type loopType, string query, int count, int index)
{
var db = new GraphElementSearcherDatabase(Stencil)
.AddControlFlows()
.Build();
var results = db.Search(query, out _);
Assert.AreEqual(count, results.Count);
var item = results[index] as ISearcherItemDataProvider;
Assert.IsNotNull(item);
var data = (ControlFlowSearcherItemData)item.Data;
Assert.AreEqual(SearcherItemTarget.ControlFlow, data.Target);
Assert.AreEqual(loopType, data.Type);
if (context == SearcherContext.Graph)
{
Assert.IsTrue(results[index] is GraphNodeModelSearcherItem);
}
else
{
Assert.IsTrue(results[index] is StackNodeModelSearcherItem);
}
}
public void TestBinaryOperator(SpawnFlags mode)
{
var db = new GraphElementSearcherDatabase(Stencil)
.AddBinaryOperators()
.Build();
var results = db.Search(nameof(BinaryOperatorKind.Subtract), out _);
Assert.AreEqual(1, results.Count);
var item = results[0] as GraphNodeModelSearcherItem;
Assert.NotNull(item);
var data = (BinaryOperatorSearcherItemData)item.Data;
Assert.AreEqual(SearcherItemTarget.BinaryOperator, data.Target);
Assert.AreEqual(BinaryOperatorKind.Subtract, data.Kind);
CreateNodesAndValidateGraphModel(item, mode, initialNodes =>
{
var node = GraphModel.NodeModels.OfType <BinaryOperatorNodeModel>().FirstOrDefault();
Assert.IsNotNull(node);
Assert.AreEqual(node.Kind, BinaryOperatorKind.Subtract);
Assert.AreEqual(initialNodes.Count + 1, GraphModel.NodeModels.Count);
});
}
public void TestNodesWithSearcherItemAttributes(SearcherContext context, string query, Type type, SpawnFlags mode)
{
var db = new GraphElementSearcherDatabase(Stencil)
.AddNodesWithSearcherItemAttribute()
.Build();
var results = db.Search(query, out _);
var item = (ISearcherItemDataProvider)results[0];
var data = (NodeSearcherItemData)item.Data;
Assert.AreEqual(SearcherItemTarget.Node, data.Target);
Assert.AreEqual(type, data.Type);
if (context == SearcherContext.Graph)
{
Assert.IsTrue(results[0] is GraphNodeModelSearcherItem);
CreateNodesAndValidateGraphModel((GraphNodeModelSearcherItem)item, mode, initialNodes =>
{
var node = GraphModel.NodeModels.FirstOrDefault(n => n.GetType() == type);
Assert.IsNotNull(node);
Assert.AreEqual(initialNodes.Count + 1, GraphModel.NodeModels.Count);
});
}
else
{
Assert.IsTrue(results[0] is StackNodeModelSearcherItem);
CreateNodesAndValidateStackModel((StackNodeModelSearcherItem)item, mode, (initialGraphNodes, stack) =>
{
var node = stack.NodeModels.FirstOrDefault(n => n.GetType() == type);
Assert.IsNotNull(node);
Assert.AreEqual(stack.NodeModels.Count(), 1);
Assert.AreEqual(initialGraphNodes.Count, GraphModel.NodeModels.Count);
});
}
}
public void TestFunctionMembers(string query, Type type, SpawnFlags mode)
{
var funcModel = GraphModel.CreateFunction("TestFunc", Vector2.zero);
funcModel.CreateFunctionVariableDeclaration("var", typeof(int).GenerateTypeHandle(GraphModel.Stencil));
funcModel.CreateAndRegisterFunctionParameterDeclaration("par", typeof(string).GenerateTypeHandle(GraphModel.Stencil));
var db = new GraphElementSearcherDatabase(Stencil)
.AddFunctionMembers(funcModel)
.Build();
var results = db.Search(query, out _);
Assert.AreEqual(1, results.Count);
var item = (GraphNodeModelSearcherItem)results[0];
var data = (TypeSearcherItemData)item.Data;
Assert.AreEqual(SearcherItemTarget.Variable, data.Target);
Assert.AreEqual(Stencil.GenerateTypeHandle(type), data.Type);
CreateNodesAndValidateGraphModel(item, mode, initialNodes =>
{
var node = GraphModel.NodeModels.OfType <VariableNodeModel>().FirstOrDefault();
Assert.IsNotNull(node);
Assert.AreEqual(initialNodes.Count + 1, GraphModel.NodeModels.Count);
Assert.AreEqual(type, node.DataType.Resolve(Stencil));
});
}
public void Test_CreateNodeFromSearcherCommand([Values] TestingMode mode)
{
var gedb = new GraphElementSearcherDatabase(Stencil, GraphModel);
Type0FakeNodeModel.AddToSearcherDatabase(GraphModel, gedb);
var db = gedb.Build();
var item = (GraphNodeModelSearcherItem)db.Search(nameof(Type0FakeNodeModel))[0];
TestPrereqCommandPostreq(mode,
() =>
{
Assert.That(GetNodeCount(), Is.EqualTo(0));
return(new CreateNodeFromSearcherCommand(new Vector2(100, 200), item,
new SerializableGUID("0123456789abcdef0123456789abcdef")));
},
() =>
{
Assert.That(GetNodeCount(), Is.EqualTo(1));
Assert.That(GraphModel.NodeModels.First(), Is.TypeOf <Type0FakeNodeModel>());
Assert.AreEqual(new SerializableGUID("0123456789abcdef0123456789abcdef"),
GraphModel.NodeModels.First().Guid);
Assert.That(GraphModel.NodeModels.First().Position,
Is.EqualTo(new Vector2(100, 200)));
}
);
}
internal static GraphElementSearcherDatabase AddDotsEvents(this GraphElementSearcherDatabase self)
{
var eventTypes = TypeCache.GetTypesDerivedFrom <IDotsEvent>()
.Where(t => !Attribute.IsDefined(t, typeof(HiddenAttribute)));
var sendEventNodeType = typeof(SendEventNodeModel);
var onEventNodeType = typeof(OnEventNodeModel);
foreach (var eventType in eventTypes)
{
var typeHandle = eventType.GenerateTypeHandle(self.Stencil);
self.Items.AddAtPath(new GraphNodeModelSearcherItem(
new NodeSearcherItemData(sendEventNodeType),
data => data.CreateNode(
sendEventNodeType,
preDefineSetup: n => ((IEventNodeModel)n).TypeHandle = typeHandle),
$"Send {eventType.FriendlyName()}"),
"Events");
self.Items.AddAtPath(new GraphNodeModelSearcherItem(
new NodeSearcherItemData(onEventNodeType),
data => data.CreateNode(
onEventNodeType,
preDefineSetup: n => ((IEventNodeModel)n).TypeHandle = typeHandle),
$"On {eventType.FriendlyName()}"),
"Events");
}
return(self);
}
public void Test_CreateNodeFromOutputPort(TestingMode testingMode, GroupingMode groupingMode)
{
var db = new GraphElementSearcherDatabase(Stencil).AddBinaryOperators().Build();
var item = (GraphNodeModelSearcherItem)db.Search("add", out _).First();
var inGroupTest = groupingMode == GroupingMode.Grouped;
var node0 = GraphModel.CreateNode <Type1FakeNodeModel>("Node0", Vector2.zero);
var output0 = node0.Output;
var group = inGroupTest ? GraphModel.CreateGroupNode(string.Empty, Vector2.zero) : null;
TestPrereqActionPostreq(testingMode,
() =>
{
Assert.That(GetNodeCount(), Is.EqualTo(inGroupTest ? 2 : 1));
Assert.That(GetEdgeCount(), Is.EqualTo(0));
return(new CreateNodeFromOutputPortAction(output0, Vector2.down, item, null, group));
},
() =>
{
Assert.That(GetNodeCount(), Is.EqualTo(inGroupTest ? 3 : 2));
Assert.That(GetEdgeCount(), Is.EqualTo(1));
var newNode = GetNode(inGroupTest ? 2 : 1);
Assert.That(newNode, Is.TypeOf <BinaryOperatorNodeModel>());
Assert.That(newNode.IsGrouped, Is.EqualTo(inGroupTest));
Assert.That(newNode.GroupNodeModel, Is.EqualTo(group));
var portModel = node0.Output;
Assert.That(portModel.ConnectionPortModels.Single(), Is.EqualTo(newNode.InputsByDisplayOrder.First()));
});
}
public void TestUnaryOperators(SearcherContext context, string query, UnaryOperatorKind kind,
SpawnFlags mode)
{
var db = new GraphElementSearcherDatabase(Stencil)
.AddUnaryOperators()
.Build();
var results = db.Search(query, out _);
Assert.AreEqual(1, results.Count);
var item = results[0] as ISearcherItemDataProvider;
Assert.IsNotNull(item);
var data = (UnaryOperatorSearcherItemData)item.Data;
Assert.AreEqual(SearcherItemTarget.UnaryOperator, data.Target);
Assert.AreEqual(kind, data.Kind);
if (context == SearcherContext.Graph)
{
Assert.IsTrue(results[0] is GraphNodeModelSearcherItem);
CreateNodesAndValidateGraphModel((GraphNodeModelSearcherItem)item, mode, initialNodes =>
{
var node = GraphModel.NodeModels.OfType <UnaryOperatorNodeModel>().FirstOrDefault();
Assert.IsNotNull(node);
Assert.AreEqual(kind, node.Kind);
Assert.AreEqual(initialNodes.Count + 1, GraphModel.NodeModels.Count);
});
}
else
{
Assert.IsTrue(results[0] is StackNodeModelSearcherItem);
CreateNodesAndValidateStackModel((StackNodeModelSearcherItem)item, mode, (initialGraphNodes, stack) =>
{
var node = stack.NodeModels.OfType <UnaryOperatorNodeModel>().FirstOrDefault();
Assert.IsNotNull(node);
Assert.AreEqual(kind, node.Kind);
Assert.AreEqual(1, stack.NodeModels.Count());
Assert.AreEqual(initialGraphNodes.Count, GraphModel.NodeModels.Count);
});
}
}
